rggen 0.8.2 → 0.9.0

data/lib/rggen/core_extensions/array.rb

@@ -1,9 +0,0 @@
-class Array
-  def find_by(conditions)
-    find do |i|
-      conditions.all? do |key, value|
-        i.respond_to?(key) && (i.__send__(key) == value)
-      end
-    end
-  end
-end

data/lib/rggen/core_extensions/facets.rb

@@ -1,22 +0,0 @@
-require 'facets/enumerable/exclude'
-require 'facets/enumerable/find_yield'
-require 'facets/enumerable/sum' if RUBY_VERSION < '2.4'
-require 'facets/file/ext'
-require 'facets/hash/symbolize_keys'
-require 'facets/integer/multiple'
-require 'facets/kernel/attr_singleton'
-require 'facets/kernel/not'
-require 'facets/kernel/not_nil'
-require 'facets/module/attr_class_accessor'
-require 'facets/module/attr_setter'
-require 'facets/module/lastname'
-require 'facets/numeric/positive'
-require 'facets/pathname/to_path'
-require 'facets/pathname/to_str'
-require 'facets/range/overlap'
-require 'facets/regexp/op_add'
-require 'facets/regexp/op_or'
-require 'facets/string/indent'
-require 'facets/string/quote'
-require 'facets/string/variablize'
-require 'facets/symbol/variablize'

data/lib/rggen/core_extensions/forwardable.rb

@@ -1,49 +0,0 @@
-module Forwardable
-  def def_class_delegator(method, ali = method)
-    def_delegator('self.class', method, ali)
-  end
-
-  def def_class_delegators(*methods)
-    def_instance_delegators('self.class', *methods)
-  end
-
-  alias_method :class_delegator , :def_class_delegator
-  alias_method :class_delegators, :def_class_delegators
-end
-
-module SingleForwardable
-  def def_object_delegator(target, method, ali = method)
-    define_singleton_method(ali) do |*args, &block|
-      target.__send__(method, *args, &block)
-    end
-  end
-
-  def def_object_delegators(target, *methods)
-    methods.each do |method|
-      def_object_delegator(target, method)
-    end
-  end
-
-  if ['2.3.1', '2.3.2', '2.3.3'].include?(RUBY_VERSION)
-    # https://bugs.ruby-lang.org/issues/12478
-    def def_single_delegator(accessor, method, ali = method)
-      accessor = accessor.to_s
-      if method_defined?(accessor) || private_method_defined?(accessor)
-        accessor = "#{accessor}()"
-      end if self.class === Module
-
-      line_no = __LINE__; str = %{
-        def #{ali}(*args, &block)
-          begin
-            #{accessor}.__send__(:#{method}, *args, &block)
-          rescue ::Exception
-            $@.delete_if{|s| ::Forwardable::FILE_REGEXP =~ s} unless ::Forwardable::debug
-            ::Kernel::raise
-          end
-        end
-      }
-
-      instance_eval(str, __FILE__, line_no)
-    end
-  end
-end

data/lib/rggen/core_extensions/integer.rb

@@ -1,5 +0,0 @@
-class Integer
-  def pow2?
-    positive? && (ord & pred).zero?
-  end
-end

data/lib/rggen/core_extensions/math.rb

@@ -1,7 +0,0 @@
-module Math
-  module_function
-
-  def clog2(value)
-    Math.log2(value).ceil
-  end
-end

data/lib/rggen/core_extensions/roo.rb

@@ -1,17 +0,0 @@
-module Roo
-  module TableFormatter
-    def to_table(sheet = default_sheet, **options)
-      from_row    = options[:from_row]    || first_row(sheet)
-      to_row      = options[:to_row]      || last_row(sheet)
-      from_column = options[:from_column] || first_column(sheet)
-      to_column   = options[:to_column]   || last_column(sheet)
-      from_row.upto(to_row).map do |row|
-        from_column.upto(to_column).map { |column| cell(row, column, sheet) }
-      end
-    end
-  end
-
-  class Base
-    include TableFormatter
-  end
-end

data/lib/rggen/exceptions.rb

@@ -1,28 +0,0 @@
-module RgGen
-  class RgGenError < StandardError
-  end
-
-  class BuilderError < RgGenError
-  end
-
-  class RuntimeError < RgGenError
-  end
-
-  class LoadError < RgGen::RuntimeError
-  end
-
-  class ConfigurationError < RgGen::RuntimeError
-  end
-
-  class RegisterMapError < RgGen::RuntimeError
-    def initialize(message, position = nil)
-      super(message)
-      @position = position
-    end
-
-    def to_s
-      return super.to_s unless @position
-      "#{super.to_s} -- #{@position}"
-    end
-  end
-end

data/lib/rggen/generator.rb

@@ -1,67 +0,0 @@
-module RgGen
-  class Generator
-    Context = Struct.new(:options, :configuration, :register_map)
-
-    def run(argv)
-      Context.new.tap do |context|
-        parse_options(argv, context)
-        load_setup(context)
-        load_configuration(context)
-        load_register_map(context, argv)
-        write_files(context)
-      end
-    rescue RgGen::RuntimeError, OptionParser::ParseError => e
-      abort "[#{e.class.lastname}] #{e.message}"
-    end
-
-    private
-
-    def parse_options(argv, context)
-      context.options = Options.parse(argv)
-    end
-
-    def load_setup(context)
-      context.options[:setup].tap do |setup|
-        File.exist?(setup) || (
-          raise RgGen::LoadError, "cannot load such file -- #{setup}"
-        )
-        load(setup)
-      end
-    end
-
-    def build_factory(component_name)
-      RgGen.builder.build_factory(component_name)
-    end
-
-    def load_configuration(context)
-      context.configuration =
-        build_factory(:configuration).create(context.options[:configuration])
-    end
-
-    def load_register_map(context, argv)
-      raise RgGen::LoadError, 'no register map is specified' if argv.empty?
-      context.register_map  =
-        build_factory(:register_map).create(context.configuration, argv.first)
-    end
-
-    def write_files(context)
-      file_generators(context).each do |generator|
-        generator.write_file(context.options[:output])
-      end unless context.options[:load_only]
-    end
-
-    def file_generators(context)
-      available_output_components(context).map do |component|
-        build_factory(component).create(
-          context.configuration, context.register_map
-        )
-      end
-    end
-
-    def available_output_components(context)
-      RgGen.builder.stored_output_components.reject do |component|
-        context.options[:disable].include?(component)
-      end
-    end
-  end
-end

data/lib/rggen/input_base/component.rb

@@ -1,28 +0,0 @@
-module RgGen
-  module InputBase
-    class Component < Base::Component
-      def initialize(parent)
-        super(parent)
-        @need_children  = true
-      end
-
-      def need_no_children
-        @need_children  = false
-      end
-
-      def add_item(item)
-        super(item)
-        def_object_delegators(@items.last, *item.fields)
-      end
-
-      def fields
-        items.flat_map(&:fields)
-      end
-
-      def validate
-        items.each(&:validate)
-        children.each(&:validate)
-      end
-    end
-  end
-end

data/lib/rggen/input_base/component_factory.rb

@@ -1,58 +0,0 @@
-module RgGen
-  module InputBase
-    class ComponentFactory < Base::ComponentFactory
-      attr_writer :loaders
-
-      def create(*args)
-        if @root_factory
-          file    = args.pop
-          source  = load(file)
-          args    << source
-
-          component = super(*args)
-          component.validate
-        else
-          component = super(*args)
-        end
-        component
-      end
-
-      private
-
-      def create_items(component, *sources)
-        create_active_items(component, sources.last)
-        create_passive_items(component)
-      end
-
-      def create_passive_items(component)
-        passive_item_factories.each do |factory|
-          create_item(factory, component)
-        end
-      end
-
-      def active_item_factories
-        @item_factories.each_with_object({}) do |(name, factory), factories|
-          factories[name] = factory if factory.active_item_factory?
-        end
-      end
-
-      def passive_item_factories
-        @item_factories.each_value.select(&:passive_item_factory?)
-      end
-
-      def load(file)
-        load_file(file)
-      end
-
-      def load_file(file)
-        find_loader(file).load(file)
-      end
-
-      def find_loader(file)
-        @loaders.find { |l| l.acceptable?(file) } || (
-          raise RgGen::LoadError, "unsupported file type -- #{file}"
-        )
-      end
-    end
-  end
-end

data/lib/rggen/input_base/item.rb

@@ -1,171 +0,0 @@
-module RgGen
-  module InputBase
-    class Item < Base::Item
-      include RegxpPatterns
-
-      class InputMatcher
-        def initialize(pattern, options)
-          @options  = options
-          @pattern  =
-            if @options.fetch(:match_wholly, true)
-              /\A#{pattern}\z/
-            else
-              pattern
-            end
-        end
-
-        attr_reader :match_data
-
-        def match_automatically?
-          @options.fetch(:match_automatically, true)
-        end
-
-        def match(rhs)
-          rhs = rhs.to_s if @options[:convert_to_string]
-          rhs = delete_blanks(rhs) if @options.fetch(:ignore_blank, true)
-          @match_data =
-            case rhs
-            when @pattern
-              Regexp.last_match
-            end
-        end
-
-        private
-
-        BLANK_REGEXP  = [
-          /\A[ \t]+/,
-          /(?<=\w)[ \t]+(?=[[:punct:]])/,
-          /(?<=[[:punct:]])[ \t]+(?=\w)/,
-          /[ \t]+\z/
-        ].inject(&:|).freeze
-
-        def delete_blanks(rhs)
-          return rhs unless rhs.respond_to?(:gsub)
-          rhs.gsub(BLANK_REGEXP, '')
-        end
-      end
-
-      define_helpers do
-        attr_reader :builders
-        attr_reader :validators
-        attr_reader :input_matcher
-
-        def field(field_name, options = {}, &body)
-          return if fields.include?(field_name)
-
-          define_method(field_name) do |*args, &block|
-            field_method(field_name, options, body, args, block)
-          end
-
-          fields  << field_name
-        end
-
-        def fields
-          @fields ||= []
-        end
-
-        def build(&body)
-          @builders ||= []
-          @builders << body
-        end
-
-        def validate(&body)
-          @validators ||= []
-          @validators << body
-        end
-
-        def input_pattern(pattern, options = {})
-          @input_matcher  = InputMatcher.new(pattern, options)
-        end
-
-        def active_item?
-          !passive_item?
-        end
-
-        def passive_item?
-          @builders.nil? || @builders.empty?
-        end
-      end
-
-      def self.inherited(subclass)
-        super(subclass)
-        [:@fields, :@builders, :@validators].each do |v|
-          subclass.inherit_class_instance_variable(v, self, &:dup)
-        end
-        subclass.inherit_class_instance_variable(:@input_matcher, self)
-      end
-
-      class_delegator :fields
-      class_delegator :builders
-      class_delegator :validators
-      class_delegator :input_matcher
-
-      def build(*sources)
-        return unless builders
-        pattern_match(sources.last) if match_automatically?
-        builders.each do |builder|
-          instance_exec(*sources, &builder)
-        end
-      end
-
-      def validate
-        return if @validated
-        return unless validators
-        validators.each do |validator|
-          instance_exec(&validator)
-        end
-        @validated  = true
-      end
-
-      private
-
-      def pattern_match(rhs)
-        input_matcher && input_matcher.match(rhs)
-      end
-
-      def match_data
-        input_matcher && input_matcher.match_data
-      end
-
-      def pattern_matched?
-        match_data.not_nil?
-      end
-
-      def captures
-        match_data && match_data.captures
-      end
-
-      def match_automatically?
-        input_matcher && input_matcher.match_automatically?
-      end
-
-      def field_method(field_name, options, body, args, block)
-        validate if options[:need_validation]
-        if body
-          instance_exec(*args, &body)
-        elsif options[:forward_to_helper]
-          self.class.__send__(field_name, *args, &block)
-        elsif options.key?(:forward_to)
-          __send__(options[:forward_to], *args, &block)
-        else
-          default_field_method(field_name, options[:default])
-        end
-      end
-
-      def default_field_method(field_name, default_value)
-        variable_name =
-          if field_name =~ /\A([a-zA-Z0-9]\w*)\?\z/
-            Regexp.last_match[1].variablize
-          else
-            field_name.variablize
-          end
-
-        if instance_variable_defined?(variable_name)
-          instance_variable_get(variable_name)
-        else
-          default_value
-        end
-      end
-    end
-  end
-end