CapicuaGen 0.0.2

data/lib/CapicuaGen/attribute_mixer.rb

@@ -0,0 +1,77 @@
+=begin
+
+CapicuaGen
+
+CapicuaGen es un software que ayuda a la creación automática de
+sistemas empresariales a través de la definición y ensamblado de
+diversos generadores de características.
+
+El proyecto fue iniciado por José Luis Bautista Martin, el 6 de enero
+del 2016.
+
+Puede modificar y distribuir este software, según le plazca, y usarlo
+para cualquier fin ya sea comercial, personal, educativo, o de cualquier
+índole, siempre y cuando incluya este mensaje, y se permita acceso el
+código fuente.
+
+Este software es código libre, y se licencia bajo LGPL.
+
+Para más información consultar http://www.gnu.org/licenses/lgpl.html
+=end
+
+module CapicuaGen
+
+  # Clase que permite un escalonamiento de propidades de forma que un AttributeMixer
+  # puede estar dentro de otro (recursivamente) y permitir acceder a cualquier atributo
+  # definido en cualquiera de ellos, permitiendo que se sobreescriban.
+  class AttributeMixer
+
+
+    public
+
+    #  Mezclador de la base
+    attr_accessor :mixer_base
+
+    def initialize
+      @internal_mixer= {}
+      @mixer_base    = nil
+    end
+
+    # Recuperamos un valor
+    def [](key)
+      return @internal_mixer[key] if @internal_mixer[key]
+      return @mixer_base[key] if @mixer_base
+      return nil
+    end
+
+
+    # Añade un hash de valores
+    def add(hash={})
+      hash.each_pair do |k, v|
+        self[k]=v
+      end
+    end
+
+
+    #agregamos un valor
+    def []= (key, value)
+      @internal_mixer[key]= value
+    end
+
+    # Indica que un attribute esta definido en la base
+    def has_in_base?(attribute)
+      return false unless @mixer_base
+      return true if @mixer_base.has_in_self?(attribute)
+      return @mixer_base.has_in_base?(attribute)
+    end
+
+    # Indica que un attribute esta definido en el objeto mismo
+    def has_in_self?(attribute)
+      return false unless @internal_mixer
+      return (@internal_mixer.has_key?(attribute) and @internal_mixer[attribute])
+    end
+
+  end
+
+end
+

data/lib/CapicuaGen/capicua_gen.rb

@@ -0,0 +1,38 @@
+=begin
+
+CapicuaGen
+
+CapicuaGen es un software que ayuda a la creación automática de
+sistemas empresariales a través de la definición y ensamblado de
+diversos generadores de características.
+
+El proyecto fue iniciado por José Luis Bautista Martin, el 6 de enero
+del 2016.
+
+Puede modificar y distribuir este software, según le plazca, y usarlo
+para cualquier fin ya sea comercial, personal, educativo, o de cualquier
+índole, siempre y cuando incluya este mensaje, y se permita acceso el
+código fuente.
+
+Este software es código libre, y se licencia bajo LGPL.
+
+Para más información consultar http://www.gnu.org/licenses/lgpl.html
+=end
+
+=begin
+CapicuaGen es una herrmamienta de generacion de codigo basado en caracteristicas
+configurables y extensibles.
+=end
+
+require_relative 'version'
+require_relative 'template_feature'
+require_relative 'feature'
+require_relative 'target'
+require_relative 'generator'
+require_relative 'Tools/template_helper'
+require_relative 'template'
+require_relative 'template_target'
+require_relative 'attribute_mixer'
+require_relative 'file_information'
+require_relative 'Tools/message_helper'
+require_relative 'Tools/xml_helper'

data/lib/CapicuaGen/feature.rb

@@ -0,0 +1,151 @@
+=begin
+
+CapicuaGen
+
+CapicuaGen es un software que ayuda a la creación automática de
+sistemas empresariales a través de la definición y ensamblado de
+diversos generadores de características.
+
+El proyecto fue iniciado por José Luis Bautista Martin, el 6 de enero
+del 2016.
+
+Puede modificar y distribuir este software, según le plazca, y usarlo
+para cualquier fin ya sea comercial, personal, educativo, o de cualquier
+índole, siempre y cuando incluya este mensaje, y se permita acceso el
+código fuente.
+
+Este software es código libre, y se licencia bajo LGPL.
+
+Para más información consultar http://www.gnu.org/licenses/lgpl.html
+=end
+
+require_relative 'Mixins/reflection_mixin'
+
+module CapicuaGen
+
+  class Feature
+    include CapicuaGen
+
+    protected
+    attr_accessor :types
+
+    public
+    attr_accessor :name, :generation_attributes
+    attr_reader :generator
+
+    def initialize(attributes= {})
+      initialize_properties(attributes, false)
+
+      # Configuro los parametros de tipo
+      @types= []
+      if attributes[:types]
+        @types= attributes[:types]
+        if @types and not @types.instance_of?(Array)
+          @types= [types]
+        end
+      end
+
+
+      #Define los atributos de la generacion
+      @generation_attributes= AttributeMixer.new
+
+      # Generador asociado
+      @generator            = nil
+
+      #Ejecuto configuracion en bloque
+      yield self if block_given?
+    end
+
+    def clean
+      message_helper.puts_generating_feature(self)
+    end
+
+
+    def generate
+      message_helper.puts_generating_feature(self)
+    end
+
+
+    # Devuelve los archivos generados por esta caracteristicas
+    def get_out_file_information(values= {})
+      return []
+    end
+
+    # Devuelve los archivos generados por esta caracteristicas
+    def get_relative_out_files(values= {})
+      result= []
+      # Obtengo la ruta base
+      if values[:directory_base]
+        directory_base= values[:directory_base]
+      else
+        directory_base= @generation_attributes[:out_dir]
+      end
+
+      get_out_file_information(values).each do |f|
+        relative_path= f.get_relative_file_path(directory_base)
+
+        result << relative_path
+      end
+
+
+      return result
+    end
+
+    # Indica que el destino es de un tipo determinado
+    def is_type?(type)
+      return type.include(type)
+    end
+
+    # Indica que el destino es de un tipo determinado
+    def is_any_type?(types)
+      if types and not types.instance_of?(Array)
+        types= [types]
+      end
+      return (@types & types).length > 0
+    end
+
+
+    # Configura el generador y se
+    def generator= (value)
+
+      @generator= value
+
+      if @generator
+        reset_attributes()
+        @generation_attributes.mixer_base= generator.generation_attributes
+        configure_attributes()
+      end
+
+    end
+
+    # Resetea los atributos personalizados de la caracteristica (antes de establecer el generador)
+    def reset_attributes
+
+    end
+
+    # Configura los atributos personalizados de la caracteristica (antes de establecer el generador)
+    def configure_attributes()
+
+    end
+
+
+    def argv_options
+      return @generator.argv_options
+    end
+
+    def message_helper
+      return MessageHelper.New unless @generator
+      return @generator.message_helper
+    end
+
+    def clone(attributes= {})
+      result=super()
+      result.initialize_properties(attributes, false)
+      return result
+    end
+
+
+  end
+
+end
+

data/lib/CapicuaGen/file_information.rb

@@ -0,0 +1,52 @@
+=begin
+
+CapicuaGen
+
+CapicuaGen es un software que ayuda a la creación automática de
+sistemas empresariales a través de la definición y ensamblado de
+diversos generadores de características.
+
+El proyecto fue iniciado por José Luis Bautista Martin, el 6 de enero
+del 2016.
+
+Puede modificar y distribuir este software, según le plazca, y usarlo
+para cualquier fin ya sea comercial, personal, educativo, o de cualquier
+índole, siempre y cuando incluya este mensaje, y se permita acceso el
+código fuente.
+
+Este software es código libre, y se licencia bajo LGPL.
+
+Para más información consultar http://www.gnu.org/licenses/lgpl.html
+=end
+
+require 'pathname'
+
+module CapicuaGen
+
+  # Representa informacion acerca de un archivo
+  class FileInformation
+
+
+    public
+    attr_accessor :file_name
+
+		# Inicializa la caracteristica
+    def initialize(values= {})
+      @file_name= values[:file_name]
+    end
+
+    def get_relative_file_path(directory_base)
+
+      return file_name unless directory_base
+
+
+      first= Pathname.new directory_base
+      second= Pathname.new file_name
+
+      return second.relative_path_from(first).to_s
+
+    end
+
+  end
+end
+

data/lib/CapicuaGen/generator.rb

@@ -0,0 +1,289 @@
+=begin
+
+CapicuaGen
+
+CapicuaGen es un software que ayuda a la creación automática de
+sistemas empresariales a través de la definición y ensamblado de
+diversos generadores de características.
+
+El proyecto fue iniciado por José Luis Bautista Martin, el 6 de enero
+del 2016.
+
+Puede modificar y distribuir este software, según le plazca, y usarlo
+para cualquier fin ya sea comercial, personal, educativo, o de cualquier
+índole, siempre y cuando incluya este mensaje, y se permita acceso el
+código fuente.
+
+Este software es código libre, y se licencia bajo LGPL.
+
+Para más información consultar http://www.gnu.org/licenses/lgpl.html
+=end
+
+require 'active_support/core_ext/object/blank'
+require_relative 'Mixins/reflection_mixin'
+require_relative 'generator_command_line'
+
+module CapicuaGen
+
+
+  # Clase generadora, nueclo de CapicuaGen, al que se le configuran todas las caracteristicas
+  # y las llama segun corresponda para que generen la parte de codigo asociado a ellas
+
+  class Generator
+    include CapicuaGen
+
+    public
+
+    attr_accessor :generation_attributes, :retry_failed, :continue_on_failed, :retries, :local_feature_directory
+    attr_accessor :message_helper, :start_time, :end_time, :argv_options
+
+    # Inicializo el objeto
+    def initialize(attributes= {})
+      initialize_properties(attributes, false)
+
+
+      # Valores determinados
+      @retry_failed             = true unless @retry_failed
+      @retries                  = 1 unless @retries
+      @continue_on_failed       = true unless @continue_on_failed
+      @local_feactures_directory= 'Capicua' unless @local_features_directory
+
+      # Colecciones de caracteristicas que posee el generador
+      @features                 = []
+
+      # Caraceristicas a ejecutar
+      @targets                  = []
+
+      # Atributos generales de generacion
+      @generation_attributes    = AttributeMixer.new
+
+      # Configuro el gestor de mensajes
+      @message_helper           = MessageHelper.new
+
+      # Hora de comienzo y final
+      @start_time               = Time.now
+      @end_time                 = Time.now
+
+      # Opciones
+      @argv_options             =OpenStruct.new
+
+      # Aranco configuracion si es necesario
+      yield self if block_given?
+    end
+
+    # Coleccion de caracteristicas del generador
+    def features(values= {})
+
+      # Configuro los parametros por defecto
+      enable_generation= nil
+      enable           = true
+
+      # Configuro los parametros
+      enable_generation= values[:enable_generation] if values[:enable_generation]
+      enable           = values[:enable_generation] if values[:enable_generation]
+
+      return @features
+    end
+
+    # Agrega una caracteristica en el generador
+    def add_feature (feature)
+      @features<<feature
+    end
+
+    # Quita la caracteristica
+    def remove_feature (feature)
+      @features.delete(feature)
+    end
+
+    # Quita la caracterisitca en base al nombre
+    def remove_feature_by_name(feature_name)
+      @features.delete_if { |f| f.name==feature_name }
+    end
+
+    # Obtiene la caracteristica en base al nombre
+    def get_feature_by_name(feature_name)
+      return @features.detect { |f| f.name==feature_name }
+    end
+
+    # Obtiene las caracteriscas de un tipo
+    def get_features_by_type(feature_type)
+      return @features.select { |f| f.type==type }
+    end
+
+    # Obtiene el nombre de todos los objetivos
+    def targets
+      return @targets
+    end
+
+    # Agrega un objetivo
+    def add_target(target)
+      @targets<<target
+    end
+
+    # Elimina un objetivo
+    def remove_target(target)
+      @targets.delete(target)
+    end
+
+
+    # Agrega una caracteristica y al mismo tiempo la convierte en objetivo
+    def add_feature_and_target(*features)
+      features.each do |feature|
+        add_feature(feature)
+        target= Target.new(:name => feature.name)
+        add_target(target)
+      end
+    end
+
+
+    # Obtiene una caracteristica, que a la vez es un objetivo, por su nombre
+    def get_feature_by_target_name
+      target @targets.detect { |f| f.name==feature_name }
+
+      return unless target
+
+      return get_feature_by_name(target.name)
+    end
+
+    # Obtiene una caracteristica, que a la vez es un objetivo, por su tipo
+    def get_features_in_targets_by_type(target_types= [])
+      features= []
+
+      @targets.each do |t|
+        feature= get_feature_by_name(t.feature_name)
+        next unless feature
+        next unless t.enable
+        features<<feature if target_types.blank? or feature.is_any_type?(target_types)
+      end
+
+      return features
+
+    end
+
+
+    # Obtiene una caracteristica, que a la vez es un objetivo, por su tipo
+    def get_features_in_targets
+      return get_features_in_targets_by_type
+    end
+
+    # Genera todos las caracteristicas
+    def generate
+
+      @start_time   = Time.now
+
+      # Reviso argumentos
+      argv          =ARGV.clone
+      @argv_options =parse_command_line(argv)
+
+      return if @argv_options.exit
+
+      if @argv_options.clean
+        clean
+      end
+
+      return unless @argv_options.generate
+
+      @targets.each do |t|
+
+        # configuro todas las asignaciones de generador
+
+        feature          = get_feature_by_name(t.feature_name)
+        feature.generator= self
+
+      end
+
+      # Clono los objetivos
+      targets= [] + @targets
+      retries= @retries + 1
+
+      # Posibles reintentos
+      retries.times do
+
+        # Realizo las generaciones
+        @targets.each do |t|
+
+          next unless targets.include?(t)
+
+          next unless t.enable_generation and t.enable
+
+          feature= get_feature_by_name(t.feature_name)
+
+          next if @argv_options.ignore_features.include? feature.name
+
+          begin
+            feature.generate
+            targets.delete(t)
+          rescue => e
+            $stderr.puts e
+            $stderr.puts e.backtrace
+          end
+        end
+
+      end
+
+      @end_time=Time.now
+
+      puts
+      message_helper.puts_end_generate(@start_time, @end_time)
+
+    end
+
+
+    # Genera todos las caracteristicas
+    def clean
+
+      @start_time   = Time.now
+
+      # Reviso argumentos
+      argv          =ARGV.clone
+      @argv_options =parse_command_line(argv)
+
+      return if @argv_options.exit
+
+      @targets.each do |t|
+
+        # configuro todas las asignaciones de generador
+
+        feature          = get_feature_by_name(t.feature_name)
+        feature.generator= self
+
+      end
+
+      # Clono los objetivos
+      targets= [] + @targets
+      retries= @retries + 1
+
+      # Posibles reintentos
+      retries.times do
+
+        # Realizo las generaciones
+        @targets.each do |t|
+
+          next unless targets.include?(t)
+
+          next unless t.enable_generation and t.enable
+
+          feature= get_feature_by_name(t.feature_name)
+
+          next if @argv_options.ignore_features.include? feature.name
+
+          begin
+            feature.clean
+            targets.delete(t)
+          rescue => e
+            $stderr.puts e
+            $stderr.puts e.backtrace
+          end
+        end
+
+      end
+
+      @end_time=Time.now
+
+      puts
+      message_helper.puts_end_generate(@start_time, @end_time)
+
+    end
+
+  end
+end