CapicuaGen 0.0.2

data/lib/CapicuaGen/generator_command_line.rb

@@ -0,0 +1,216 @@
+=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 'optparse'
+require 'optparse/time'
+require 'ostruct'
+require 'pp'
+
+require_relative 'Mixins/reflection_mixin'
+
+
+module CapicuaGen
+
+  class Generator
+    include CapicuaGen
+
+    # Parsea un linea de comamdos
+    def parse_command_line(args)
+
+      options = OpenStruct.new
+
+      options.ignore_features=[]
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Uso: <Script generador> [comandos] [opciones]"
+
+        opts.separator ""
+        subtext = <<HELP
+Comandos:
+   generate          :     Genera las caracteriticas configuradas.
+   clean             :     Limpia los archivos generados.
+   cleanAndGenerate  :     Limpia los archivos generados y luego los vuelve a crear.
+   example           :     Genera un ejemplo
+
+
+Ejecute 'opt.rb COMMAND --help' para obtener mas
+HELP
+        opts.separator ""
+        opts.separator subtext
+        opts.separator ""
+
+        # No argument, shows at tail.  This will print an options summary.
+        # Try it and see!
+        opts.on_tail("-h", "--help", "Muestra este mensaje") do
+          puts opts
+          options.help=true
+          options.exit=true
+        end
+
+        # Another typical switch to print the version.
+        opts.on_tail("--version", "Muestra la versión") do
+          puts ::Version.join('.')
+          options.version=true
+          options.exit   =true
+        end
+
+      end
+
+      subcommands = {
+
+          'generate'         => OptionParser.new do |opts|
+
+            opts.banner = "Uso: generate [options]"
+            opts.separator ""
+
+            # List of arguments.
+            opts.on("--ignore featurename1, featurename2, featurename2", Array, "Lista de caracteristicas que sera omitidas") do |ignore_features|
+              options.ignore_features = ignore_features
+            end
+
+            opts.on("-f", "--force", "Fuerza que se sobreescriban las carateristicas generadas") do
+              options.force= true
+            end
+
+            opts.on_tail("-h", "--help", "Muestra este mensaje") do
+              puts opts
+              options.help=true
+              options.exit=true
+            end
+          end,
+
+
+          'clean'            => OptionParser.new do |opts|
+
+            opts.banner = "Uso: clean [options]"
+            opts.separator ""
+
+            # List of arguments.
+            opts.on("--ignore featurename1, featurename2, featurename2", Array, "Lista de caracteristicas que sera omitidas") do |ignore_features|
+              options.ignore_features = ignore_features
+            end
+
+            opts.on_tail("-h", "--help", "Muestra este mensaje") do
+              puts opts
+              options.help=true
+              options.exit=true
+            end
+          end,
+
+
+          'cleanAndGenerate' => OptionParser.new do |opts|
+            opts.banner = "Uso: example [options]"
+            opts.separator ""
+            opts.separator "Opciones:"
+            opts.separator ""
+
+            # List of arguments.
+            opts.on("--ignore featurename1, featurename2, featurename2", Array, "Lista de caracteristicas que sera omitidas") do |ignore_features|
+              options.ignore_features = ignore_features
+            end
+
+            opts.on("-f", "--force", "Fuerza que se sobreescriban las carateristicas generadas") do
+              options.force= true
+            end
+
+            opts.on_tail("-h", "--help", "Muestra este mensaje") do
+              puts opts
+              options.help=true
+              options.exit=true
+            end
+
+            opts.separator ""
+          end,
+
+
+          'example'          => OptionParser.new do |opts|
+            opts.banner = "Uso: cleanAndGenerate [options]"
+            opts.separator ""
+            opts.separator "Opciones:"
+            opts.separator ""
+
+            # List of arguments.
+            opts.on("-o", "--out directorio", "") do |directorio|
+              options.out = directorio
+            end
+
+            opts.on_tail("-h", "--help", "Muestra este mensaje") do
+              puts opts
+              options.help=true
+              options.exit=true
+            end
+
+            opts.separator ""
+          end
+
+      }
+
+
+      begin
+        internal_args=args.clone
+        opt_parser.order!(internal_args)
+        command = internal_args.shift
+
+        if command
+
+          case command
+
+            when 'generate'
+              options.generate=true
+
+            when 'clean'
+              options.clean   =true
+              options.generate=false
+
+            when 'cleanAndGenerate'
+              options.clean   =true
+              options.generate=true
+
+            when 'example'
+              options.clean   =false
+              options.generate=false
+              options.example =true
+              options.out     ='.'
+
+          end
+
+          subcommands[command].order! internal_args
+
+
+        else
+          options.generate=true
+        end
+
+      rescue => e
+        $stderr.puts e
+        puts
+        puts opt_parser
+        puts
+        options.exit=true
+      end
+
+
+      return options
+    end
+
+  end
+end

data/lib/CapicuaGen/target.rb

@@ -0,0 +1,49 @@
+=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
+
+  # Define un objtivo a contruir
+  class Target
+    include CapicuaGen
+
+
+    public
+
+    attr_accessor :name, :feature_name, :enable, :enable_generation, :group
+
+
+    def initialize(attributes= {})
+      @enable= true
+      @enable_generation= true
+
+      # Inicializo propiedades
+      initialize_properties(attributes, false)
+
+      @feature_name= @name unless @feature_name
+
+    end
+
+
+  end
+end

data/lib/CapicuaGen/template.rb

@@ -0,0 +1,39 @@
+=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
+
+  # Define una plantilla para generar codigo
+  class Template
+
+
+
+    public
+    attr_accessor :name, :file
+
+    def initialize(atributes= {})
+      @name= atributes[:name] if atributes[:name]
+      @file= atributes[:file] if atributes[:file]
+    end
+
+
+  end
+end

data/lib/CapicuaGen/template_feature.rb

@@ -0,0 +1,331 @@
+=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 'feature'
+
+module CapicuaGen
+
+  # Es un tipo de caracteristica especial que se basa en generación de codigo a travez de plantillas
+  class TemplateFeature < Feature
+
+
+    private
+
+    # Plantillas (archivos *.erb)
+    attr_accessor :templates
+
+    # Relacion de las Template con los objetivos
+    attr_accessor :template_targets
+
+    protected
+
+    attr_accessor :template_directories
+
+
+    public
+
+    # Inicializo el objeto
+    def initialize(atributes= {})
+      super(atributes)
+
+
+      # Define las interfaces del proyectowh
+      @templates           = []
+
+      # Define los objetivos concretos de los templates
+      @template_targets    = []
+
+      # Directorios donde conseguir los templates
+      @template_directories= []
+
+    end
+
+
+    # Coleccion de caracteristicas del generador
+    def templates
+      return @templates
+    end
+
+    # Agrega una caracteristica en el generador
+    def add_template(template)
+      @templates<<template
+    end
+
+    # Agrega una caracteristica en el generador
+    def set_template(name, template)
+      remove_template_by_name(name)
+      template.name= name
+      @templates<<template
+    end
+
+    # Quita la caracteristica
+    def remove_template(template)
+      @templates.delete(template)
+    end
+
+    # Quita la caracterisitca en base al nombre
+    def remove_template_by_name(template_name)
+      @templates.delete_if { |f| f.name==template_name }
+    end
+
+    # Obtiene la caracteristica en base al nombre
+    def get_template_by_name(template_name)
+      return @templates.detect { |f| f.name==template_name }
+    end
+
+    # Coleccion de template_targets del generador
+    def template_targets
+      return @template_targets
+    end
+
+    # Agrega una template_target en el generador
+    def add_template_target(template_target)
+      @template_targets<<template_target
+    end
+
+    # Agrega una template_target en el generador
+    def set_template_target(name, template_target)
+      remove_template_target_by_name(name)
+      template_target.name= name
+      if name=~ /^([^\/]+)\//
+        template_target.template_name= $1
+      else
+        template_target.template_name= name unless template_target.template_name
+      end
+
+      @template_targets<<template_target
+
+      # Devuelve el template recien configurado
+      return template_target
+
+    end
+
+    # Quita la template_target
+    def remove_template_target(template_target)
+      @template_targets.delete(template_target)
+    end
+
+    # Quita la caracterisitca en base al nombre
+    def remove_template_target_by_name(template_target_name)
+      @template_targets.delete_if { |f| f.name==template_target_name }
+    end
+
+    # Obtiene la template_target en base al nombre
+    def get_template_target_by_name(template_target_name)
+      return @template_targets.detect { |f| f.name==template_target_name }
+    end
+
+    # Configura el generador y se
+    def generator= (value)
+      super(value)
+
+      if @generator
+        configure_template_directories()
+        configure_template_targets()
+      end
+
+    end
+
+
+    def configure_template_directories
+      # Configuro las rutas de los templates
+      self.template_directories << get_template_local_dir(get_class_file)
+      self.template_directories << File.join(File.dirname(get_class_file), '../template')
+
+    end
+
+	# Configura los objetivos de las platillas (despues de establecer el generador)
+    def configure_template_targets
+
+    end
+
+    # Genero el codigo, usando todas las plantillas configuradas
+    def generate
+      super()
+
+      message_helper.add_indent
+
+      # Genera una a una todas los objetivos de los templates
+      self.template_targets.each do |t|
+        generate_template_target(t)
+      end
+
+      message_helper.remove_indent
+      puts
+    end
+
+    def clean
+      super()
+
+      message_helper.add_indent
+
+      # Genera una a una todas los objetivos de los templates
+      self.template_targets.each do |t|
+        clean_template_target(t)
+      end
+
+      message_helper.remove_indent
+      puts
+    end
+
+
+    protected
+
+    # Genero una plantilla en particular
+    def generate_template_target(template_target, current_binding= nil)
+
+      # Localizo la plantilla
+      template     = self.get_template_by_name(template_target.template_name)
+
+      # Obtengo el archivo del template
+      template_file= ''
+      @template_directories.each do |template_directory|
+        template_file= File.join(template_directory, template.file)
+        break if File.exist?(template_file)
+      end
+
+
+      # Obtengo la salida
+      if template_target.out_file.blank?
+        out_file= nil
+      else
+        out_file= File.join(self.generation_attributes[:out_dir], template_target.out_file)
+      end
+
+      current_binding= binding unless current_binding
+
+      if template_target.copy_only
+
+        exists= File.exist?(out_file)
+
+        FileUtils.cp template_file, out_file
+
+        if exists
+          message_helper.puts_created_template(File.basename(out_file), out_file, :override)
+        else
+          message_helper.puts_created_template(File.basename(out_file), out_file, :new)
+        end
+
+
+      else
+        # Creo la salida
+        return TemplateHelper.generate_template(template_file, current_binding, :out_file => out_file, :feature => self, :force => argv_options.force)
+      end
+
+
+    end
+
+
+    # Limpio el resultado de una plantilla (borro archivos)
+    def clean_template_target(template_target, current_binding= nil)
+
+      # Localizo la plantilla
+      template= self.get_template_by_name(template_target.template_name)
+
+      # Obtengo la salida
+      if template_target.out_file.blank?
+        return
+      else
+        out_file= File.join(self.generation_attributes[:out_dir], template_target.out_file)
+      end
+
+      return if !File.exist?(out_file)
+
+      # Elimino el archivo
+      File.delete(out_file)
+
+      message_helper.puts_created_template(File.basename(template.file), out_file, :delete)
+
+
+    end
+
+
+    # Devuelve los archivos generados por esta caracteristicas
+    def get_out_file_information(values= {})
+
+      # Recupero los parametros
+      types = values[:types]
+      types = [types] if types and not types.instance_of?(Array)
+
+      #recupero los archivos pertinentes
+      result= []
+
+      self.template_targets.each do |t|
+        # si no hay tipos definidos o los tipos tienen algo en común, lo agrego a los resultados
+        next unless types.blank? or t.is_any_type?(types)
+        next unless t.respond_to?('out_file')
+        next if t.out_file.blank?
+
+
+        file_information= FileInformation.new(:file_name => File.join(self.generation_attributes[:out_dir], t.out_file))
+
+        result << file_information
+
+      end
+
+      return result
+
+    end
+
+
+    protected
+    # Directorio local para obtener los templates
+    def get_template_local_dir(file)
+      feacture_directory= File.dirname(file).split('/')
+      feacture_name     = feacture_directory[feacture_directory.count-2]
+      package_name      = feacture_directory[feacture_directory.count-3]
+      return File.join(@generator.local_feature_directory, package_name, feacture_name, 'Template')
+    end
+
+
+    # For instances of class A only, we use the __FILE__ keyword.
+    # This method is overwritten by the #get_file method defined above.
+    def get_class_file
+      __FILE__
+    end
+
+    private
+    # Called from b.rb at `class A < B`. `subclass` is the Class object B.
+    # This method makes sure every subclass (class B, class C...)
+    # has #get_file defined correctly for instances of the subclass.
+    def self.inherited (subclass)
+      subclass.instance_eval do
+        # This array contains strings like "/path/to/a.rb:3:in `instance_eval'".
+        strings_ary   = caller
+
+        # We look for the last string containing "<top (required)>".
+        require_index = strings_ary.index { |x| x.include?("<top (required)>") }
+        require_string= strings_ary[require_index]
+
+        # We use a regex to extract the filepath from require_string.
+        filepath      = require_string[/^(.*):\d+:in `<top \(required\)>'/, 1]
+
+        # This defines the method #get_file for instances of `subclass`.
+        define_method(:get_class_file) { filepath }
+      end
+    end
+
+
+  end
+
+
+end
+