rggen 0.8.2 → 0.9.0

data/lib/rggen/input_base/item_factory.rb

@@ -1,13 +0,0 @@
-module RgGen
-  module InputBase
-    class ItemFactory < Base::ItemFactory
-      def active_item_factory?
-        !passive_item_factory?
-      end
-
-      def passive_item_factory?
-        @target_items.nil? && @target_item.passive_item?
-      end
-    end
-  end
-end

data/lib/rggen/input_base/loader.rb

@@ -1,23 +0,0 @@
-module RgGen
-  module InputBase
-    class Loader
-      class << self
-        attr_writer :supported_types
-
-        def acceptable?(file)
-          ext = File.ext(file).to_sym
-          @supported_types.any? { |type| type.casecmp(ext).zero? }
-        end
-
-        def load(file)
-          new.load(file)
-        end
-      end
-
-      def load(file)
-        return load_file(file) if File.exist?(file)
-        raise RgGen::LoadError, "cannot load such file -- #{file}"
-      end
-    end
-  end
-end

data/lib/rggen/input_base/regexp_patterns.rb

@@ -1,29 +0,0 @@
-module RgGen
-  module InputBase
-    module RegxpPatterns
-      BIN_REGEXP  = /0b(?:[01][01_]*)?[01]/i
-      OCT_REGEXP  = /0o(?:[0-7][0-7_]*)?[0-7]/i
-      DEC_REGEXP  = /(?:[1-9][\d_]*)?\d/
-      HEX_REGEXP  = /0x(?:\h[\h_]*)?\h/i
-
-      UNSIGNED_NUMBER_REGEXP  = (
-        /\b/ + (BIN_REGEXP | OCT_REGEXP | DEC_REGEXP | HEX_REGEXP) + /\b/
-      ).freeze
-      VARIABLE_NAME_REGEXP    = /\b[a-z_][a-z0-9_]*\b/i
-
-      def self.included(klass)
-        klass.extend(self)
-      end
-
-      private
-
-      def number
-        UNSIGNED_NUMBER_REGEXP
-      end
-
-      def variable_name
-        VARIABLE_NAME_REGEXP
-      end
-    end
-  end
-end

data/lib/rggen/option_switches.rb

@@ -1,60 +0,0 @@
-module RgGen
-  Options.add_option_switch :setup do
-    long        '--setup FILE'
-    description 'Specify a setup file to set up RgGen tool'
-    default { ENV['RGGEN_DEFAULT_SETUP_FILE'] || default_setup }
-
-    def default_setup
-      File.join(RgGen::RGGEN_HOME, 'setup', 'default.rb')
-    end
-  end
-
-  Options.add_option_switch :configuration do
-    short       '-c'
-    long        '--configuration FILE'
-    description 'Specify a configuration file for generated source code'
-    default { ENV['RGGEN_DEFAULT_CONFIGURATION_FILE'] }
-  end
-
-  Options.add_option_switch :output do
-    short       '-o'
-    long        '--output DIR'
-    description 'Specify output directory'
-    default     '.'
-  end
-
-  Options.add_option_switch :load_only do
-    long          '--load-only'
-    option_class  TrueClass
-    description   'Load input files only if specified'
-    default       false
-  end
-
-  Options.add_option_switch :disable do
-    long          '--disable TYPE1[,TYPE2,...]'
-    option_class  Array
-    description   'Disable the given output file type(s)'
-    default { [] }
-    body { |v, o, k| o[k].concat(v.map(&:to_sym)) }
-  end
-
-  Options.add_option_switch :show_home do
-    long        '--show-home'
-    description 'Display the path of RgGen tool home directory'
-    body { puts RgGen::RGGEN_HOME; exit }
-  end
-
-  Options.add_option_switch :version do
-    short       '-v'
-    long        '--version'
-    description 'Display the version'
-    body { puts ver; exit }
-  end
-
-  Options.add_option_switch :help do
-    short       '-h'
-    long        '--help'
-    description 'Display this message'
-    body  { puts help; exit }
-  end
-end

data/lib/rggen/options.rb

@@ -1,97 +0,0 @@
-module RgGen
-  class Options
-    extend Forwardable
-
-    class OptionSwitch
-      def initialize(kind)
-        @kind = kind
-      end
-
-      def on(parser, options)
-        parser.on(*args) do |value|
-          parser.instance_exec(value, options, @kind, &body)
-        end
-      end
-
-      attr_setter :short
-      attr_setter :long
-      attr_setter :option_class
-
-      def default(value = nil, &block)
-        if block_given?
-          @default  = block
-        elsif value
-          @default  = proc { value }
-        else
-          @default && @default.call
-        end
-      end
-
-      def description(value = nil)
-        if value
-          @description  = value
-        elsif @description || @default
-          ''.tap do |d|
-            d << @description if @description
-            d << "(default: #{default})" if default
-          end
-        end
-      end
-
-      def body(&block)
-        if block_given?
-          @body = block
-        else
-          @body || proc { |v, o, k| o[k] = v }
-        end
-      end
-
-      private
-
-      def args
-        [@short, @long, @option_class, description].compact
-      end
-    end
-
-    class << self
-      def parse(args)
-        new.tap { |options| options.parse(args) }
-      end
-
-      def option_switches
-        @option_switches ||= {}
-      end
-
-      def add_option_switch(kind, &block)
-        option_switches[kind] = OptionSwitch.new(kind)
-        option_switches[kind].instance_exec(&block)
-      end
-    end
-
-    def_class_delegator :option_switches
-    def_delegator :@options, :[]
-
-    def initialize
-      @options  = Hash.new { |h, k| h[k]  = option_switches[k].default }
-    end
-
-    def parse(args)
-      option_parser.parse!(args)
-    end
-
-    private
-
-    def option_parser
-      OptionParser.new do |parser|
-        parser.version      = RgGen::VERSION
-        parser.program_name = 'rggen'
-        parser.banner       = 'Usage: rggen [options] REGISTER_MAP'
-        define_option_switches(parser)
-      end
-    end
-
-    def define_option_switches(parser)
-      option_switches.each_value { |switch| switch.on(parser, @options) }
-    end
-  end
-end

data/lib/rggen/output_base/code_generator.rb

@@ -1,36 +0,0 @@
-module RgGen
-  module OutputBase
-    class CodeGenerator
-      def []=(kind, body)
-        (@bodies ||= {})[kind]  = body
-      end
-
-      def generate_code(context, kind, code)
-        return code unless body?(kind)
-        (code || context.create_blank_code).tap do |c|
-          execute_body(context, kind, c)
-        end
-      end
-
-      def copy
-        CodeGenerator.new.tap do |g|
-          g.instance_variable_set(:@bodies, Hash[@bodies]) if @bodies
-        end
-      end
-
-      private
-
-      def body?(kind)
-        @bodies && @bodies.key?(kind)
-      end
-
-      def execute_body(context, kind, code)
-        if @bodies[kind].arity.zero?
-          code << context.instance_exec(&@bodies[kind])
-        else
-          context.instance_exec(code, &@bodies[kind])
-        end
-      end
-    end
-  end
-end

data/lib/rggen/output_base/component.rb

@@ -1,78 +0,0 @@
-module RgGen
-  module OutputBase
-    class Component < Base::Component
-      include Base::HierarchicalAccessors
-
-      def initialize(parent, configuration, source)
-        super(parent)
-        define_hierarchical_accessors
-        @configuration  = configuration
-        @source         = source
-        @need_children  = source.need_children?
-        def_delegators(:source, *source.fields)
-      end
-
-      attr_reader :configuration
-      attr_reader :source
-      attr_writer :output_directory
-
-      def add_item(item)
-        super(item)
-        def_object_delegators(@items.last, *item.exported_methods)
-      end
-
-      def build
-        items.each(&:build)
-        children.each(&:build)
-      end
-
-      def generate_code(kind, mode, code = nil)
-        [
-          pre_code_generator, *main_code_generator(mode), post_code_generator
-        ].inject(code) { |c, g| g.call(kind, mode, c) }
-      end
-
-      def write_file(output_directory)
-        directoris  = [*Array(output_directory), @output_directory].compact
-        [*items, *children].each do |item_or_child|
-          item_or_child.write_file(directoris)
-        end
-      end
-
-      private
-
-      def generate_item_code(method_name, kind, _, code)
-        items.inject(code) do |c, item|
-          item.send(method_name, kind, c)
-        end
-      end
-
-      def generate_child_code(kind, mode, code)
-        children.inject(code) do |c, child|
-          child.generate_code(kind, mode, c)
-        end
-      end
-
-      def pre_code_generator
-        method(:generate_item_code).curry[:generate_pre_code]
-      end
-
-      def main_code_generator(mode)
-        {
-          top_down: [
-            method(:generate_item_code ).curry[:generate_code],
-            method(:generate_child_code)
-          ],
-          bottom_up: [
-            method(:generate_child_code),
-            method(:generate_item_code ).curry[:generate_code]
-          ]
-        }[mode]
-      end
-
-      def post_code_generator
-        method(:generate_item_code).curry[:generate_post_code]
-      end
-    end
-  end
-end

data/lib/rggen/output_base/component_factory.rb

@@ -1,32 +0,0 @@
-module RgGen
-  module OutputBase
-    class ComponentFactory < Base::ComponentFactory
-      attr_writer :output_directory
-
-      def create(*args)
-        component = super(*args)
-        if @root_factory
-          component.build
-          component.output_directory  = @output_directory
-        end
-        component
-      end
-
-      def create_component(parent, configuration, register_map)
-        @target_component.new(parent, configuration, register_map)
-      end
-
-      def create_items(generator, configuration, soruce)
-        @item_factories.each_value do |item_factory|
-          create_item(item_factory, generator, configuration, soruce)
-        end
-      end
-
-      def create_children(generator, configuration, source)
-        source.children.each do |child_source|
-          create_child(generator, configuration, child_source)
-        end
-      end
-    end
-  end
-end

data/lib/rggen/output_base/file_writer.rb

@@ -1,36 +0,0 @@
-module RgGen
-  module OutputBase
-    class FileWriter
-      def initialize(pattern, body)
-        @pattern  = Erubi::Engine.new(pattern)
-        @body     = body
-      end
-
-      def write_file(context, output_directory = nil)
-        path  = generate_path(context, output_directory)
-        code  = generate_code(context, path)
-        create_output_directory(path)
-        File.binwrite(path, code)
-      end
-
-      private
-
-      def generate_path(context, output_directory)
-        [
-          *Array(output_directory), context.instance_eval(@pattern.src)
-        ].map(&:to_s).reject(&:empty?).to_path
-      end
-
-      def generate_code(context, path)
-        context.create_blank_file(path).tap do |file|
-          context.instance_exec(file, &@body)
-        end
-      end
-
-      def create_output_directory(path)
-        dirname = path.dirname
-        dirname.directory? || dirname.mkpath
-      end
-    end
-  end
-end

data/lib/rggen/output_base/item.rb

@@ -1,110 +0,0 @@
-module RgGen
-  module OutputBase
-    class Item < Base::Item
-      include Base::HierarchicalItemAccessors
-
-      CODE_GENERATION_METHODS = {
-        pre:  :generate_pre_code,
-        main: :generate_code,
-        post: :generate_post_code
-      }
-
-      define_helpers do
-        attr_reader :builders
-        attr_reader :file_writer
-
-        def build(&body)
-          @builders ||= []
-          @builders << body
-        end
-
-        def template_engine(engine)
-          define_method(:template_engine) { engine.instance }
-        end
-
-        def code_generators
-          @code_generators ||= {}
-        end
-
-        CODE_GENERATION_METHODS.each do |type, method_name|
-          define_method(method_name) do |kind, &body|
-            (code_generators[type] ||= CodeGenerator.new)[kind] = body
-          end
-        end
-
-        def generate_code_from_template(kind, path = nil)
-          call_info = caller.first
-          generate_code(kind) do
-            template_engine.process_template(self, path, call_info)
-          end
-        end
-
-        def write_file(name_pattern, &body)
-          @file_writer  ||= FileWriter.new(name_pattern, body)
-        end
-
-        def export(*exporting_methods)
-          exported_methods.concat(
-            exporting_methods.reject(&exported_methods.method(:include?))
-          )
-        end
-
-        def exported_methods
-          @exported_methods ||= []
-        end
-      end
-
-      def self.inherited(subclass)
-        super(subclass)
-        [:@builders, :@exported_methods].each do |v|
-          subclass.inherit_class_instance_variable(v, self, &:dup)
-        end
-        if @code_generators && @code_generators.size > 0
-          subclass.instance_variable_set(
-            :@code_generators,
-            Hash[*@code_generators.flat_map { |k, g| [k, g.copy] }]
-          )
-        end
-      end
-
-      def initialize(owner)
-        super(owner)
-        define_hierarchical_item_accessors
-      end
-
-      class_delegator :builders
-      class_delegator :code_generators
-      class_delegator :file_writer
-      class_delegator :exported_methods
-
-      def build
-        return if builders.nil?
-        builders.each do |builder|
-          instance_exec(&builder)
-        end
-      end
-
-      CODE_GENERATION_METHODS.each do |type, method_name|
-        define_method(method_name) do |kind, code|
-          return code unless code_generators.key?(type)
-          code_generators[type].generate_code(self, kind, code)
-        end
-      end
-
-      def write_file(output_directory = nil)
-        return if file_writer.nil?
-        file_writer.write_file(self, output_directory)
-      end
-
-      private
-
-      def process_template(path = nil)
-        template_engine.process_template(self, path, caller.first)
-      end
-
-      def configuration
-        @owner.configuration
-      end
-    end
-  end
-end