build - shen - erlang solutions

¿Qué herramienta utilizas para construir un programa de Erlang?

Question

¿Qué herramienta utilizas para construir un programa Erlang: Emake, makiefile u otro?

Answer 1

¡Usa Sinan para construir y Faxien para instalar! Echa un vistazo a erlware.org. Son mucho mejores que un archivo de make y proporcionan una fácil distribución. Ambos están en un gran desarrollo activo y se presentarán en: http://www.manning.com/logan/

Answer 2

Aquí está el Makefile y el Emakefile que suelo usar con make (origen desconocido).

Makefile:

ERL=erl
APPFILE=myApp.app

all: ebin/$(APPFILE)
    $(ERL) -make 

ebin/$(APPFILE): src/$(APPFILE)
    cp $< $@ 

Emakefile:

{"src/*", [debug_info, {outdir, "ebin"}, {i, "include"}]}.

Answer 3

Desde estas respuestas, ha surgido un nuevo estándar en la comunidad de Erlang:

Rebar https://github.com/basho/rebar/

Answer 4

Propongo mi propia herramienta :) Eake ... es muy similar al rastrillo del entorno Ruby:

http://github.com/andrzejsliwa/eake

o

http://andrzejsliwa.com/2009/05/28/eake-narzedzie-budowania-dla-erlanga-bazujace-na-rake/

Aquí está el ejemplo de eakefile

-module(eakefile). -compile([export_all]). -import(eake, [task/3, namespace/3, run_target/2, run/1]). execute() -> [ namespace(db, "test", [ task(migrate, "That is migration", fun(Params) -> io:format("in migration params: ~w", [Params]), run_target(''db:rollback'', []) end), task(rollback, "That is rollback", fun(_) -> io:format("in rollback"), run("ls") end) ]) ].

y este es un ejemplo usando:

$ eake db:migrate $ eake db:migrate db:rollback $ eake db:migrate=[1,atom] $ eake db:migrate=name

Answer 5

Puedes revisar mis Makefiles, los tomé de mochiweb o algo así. Lo siento, pero el código tiene algunas partes específicas del proyecto

http://github.com/JLarky/eadc-hub/blob/master/Makefile

MARKDOWN_SOURCES=$(wildcard doc/*.md) MARKDOWN_TARGETS=$(patsubst doc/%.md,doc/html/%.html,$(MARKDOWN_SOURCES)) all: eadc boot deps eadc: ebin cd src && $(MAKE) deps: (cd deps/somedeps;$(MAKE);) docs: erlang-docs # html-docs erlang-docs: doc/edoc (cd src;$(MAKE) docs) html-docs: doc/html $(MARKDOWN_TARGETS) doc/edoc: mkdir -p doc/edoc doc/html: mkdir -p doc/html doc/html/%.html: doc/%.md (title=`grep ''^# '' $ $@ ;/ python doc/buildtoc.py $$t ;/ markdown $$t >> $@ ;/ rm $$t ;/ cat doc/footer.html >> $@) ebin: mkdir -p ebin clean: clean-docs (cd src;$(MAKE) clean) (cd deps/*/; $(MAKE) clean) $(RM) -r priv $(RM) ebin/*.boot ebin/*.script ebin/*crash.dump ebin/*~ src/*~ priv/*~ *~ /#*/# clean-docs: clean-html $(rm) -rf doc/edoc clean-html: rm -rf doc/html boot: ebin/eadc.boot ebin/eadc.boot: ebin/eadc.rel ebin/eadc.app erl -pa ebin -noshel -run eadc_utils make_script -run erlang halt cleandb: $(RM) -r ebin/Mnesia*

http://github.com/JLarky/eadc-hub/blob/master/support/include.mk

## -*- makefile -*- ## Erlang ERL := erl ERLC := $(ERL)c INCLUDE_DIRS := ../include $(wildcard ../deps/*/include) EBIN_DIRS := $(wildcard ../deps/*/ebin) ERLC_FLAGS := -W $(INCLUDE_DIRS:../%=-I ../%) $(EBIN_DIRS:%=-pa %) ifndef no_debug_info ERLC_FLAGS += +debug_info endif ifdef debug ERLC_FLAGS += -Ddebug endif EBIN_DIR := ../ebin DOC_DIR := ../doc/edoc EMULATOR := beam ERL_SOURCES := $(wildcard *.erl) ERL_HEADERS := $(wildcard *.hrl) $(wildcard ../include/*.hrl) ERL_OBJECTS := $(ERL_SOURCES:%.erl=$(EBIN_DIR)/%.$(EMULATOR)) ERL_DOCUMENTS := $(ERL_SOURCES:%.erl=$(DOC_DIR)/%.html) ERL_OBJECTS_LOCAL := $(ERL_SOURCES:%.erl=./%.$(EMULATOR)) APP_FILES := $(wildcard *.app) REL_FILES := $(wildcard *.rel) EBIN_FILES_NO_DOCS = $(ERL_OBJECTS) $(APP_FILES:%.app=../ebin/%.app) $(REL_FILES:%.rel=../ebin/%.rel) EBIN_FILES = $(ERL_DOCUMENTS) $(EBIN_FILES_NO_DOCS) MODULES = $(ERL_SOURCES:%.erl=%) ../ebin/%.app: %.app cp $

http://github.com/JLarky/eadc-hub/blob/master/src/Makefile

include ../support/include.mk all: $(EBIN_FILES_NO_DOCS) docs: $(ERL_DOCUMENTS) *emphasized text* debug: $(MAKE) DEBUG=-DDEBUG clean: rm -rf $(EBIN_FILES) $(PLUGINS_OBJECTS)

Answer 6

Usamos un Emakefile similar también.

{"src/*", [debug_info, {outdir, "ebin"}, {i, "include"}]}.

Utilizo la funcionalidad erlang make para ejecutar pruebas después de una compilación exitosa.

Extracto de makefile:

all: compile

compile:
        erlc -o ebin +debug_info erl_make.erl       
        erl -pa ./ebin -eval "erl_make:make(development)" -s init stop -noshell

erl_make.erl

-module(erl_make).

-export([make/1]).

make(Mode) ->
    case make:all([{d, Mode}]) of
        error ->
            error;
        _ ->
            test_suite:test()
    end.

Answer 7

Yo uso un Rakefile llamando a un Emakefile. Rakefile para flexibilidad y Emakefile para velocidad !

Este sistema de compilación es bastante poderoso, vea erl_rake en GitHub

Genera archivos .app, genera lanzamientos automáticamente, ejecuta la prueba EUnit. Y dado que está construido alrededor de un Rakefile, agregué fácilmente el lanzamiento a AWS y ejecuté mis pruebas con etap en su lugar.

Personalicé una versión antigua para mis proyectos de github.