table_structure 0.3.14 → 0.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de3f99fed2d954963668ab10f28a330023e28e8a8c41039544c6f961bb3ab539
-  data.tar.gz: 0e012e4fbcb5fff523418b6c3bfd3762fb3ee53460d4ddefc8ae91cf3a68a950
+  metadata.gz: 77197fdbfa164e9f532b190b4e94750354595f9e51d155b91ed36ea2f43aeef2
+  data.tar.gz: 52ab0ab962584d0d7e8e10788a6c949369926ec8869577e797a462e90eb76487
 SHA512:
-  metadata.gz: b913207c2199fe5436fca4e4b894443fe6aa0d07f9b78d7c76da11ad752a45432340baed1feb07176088e95ebc56f2ac8917e2a66f4523dfcb45fbbd6fd91dd6
-  data.tar.gz: c96ad294ebc1f7f0e8d23ef3de3b17cdb9fd4546792ce3b8bba80d9d9ae1305c00155cf9f19623efa4b40b2723f71d01a0575c60cc1fbd42d4842a29c7c9256c
+  metadata.gz: 99774b00f0260b64ed8a3ea670cf24d79e222c8b75fab7545932fbb248516561078f2908a081bae925e7baf44502d115711974d5b7458937e6db1e0961be0152
+  data.tar.gz: ca70303e5f5ec9ae437e9dccd9554b027c48aa68b7cb9c0f0239f6fa1ca0259321c9ea942310ac7a320e8d80ef6b996ef02a1cfb5ac0afa3a317534b351ecd85

data/.travis.yml

@@ -8,4 +8,4 @@ rvm:
   - 2.5
   - 2.4
   - 2.3
-before_install: gem install bundler:2.0.2
+before_install: gem install bundler:2.1.1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.3.15
+Changes:
+- `TableStructure::Schema`
+  - Add `+` as class method. this method concatenates the schemas.
+
 # 0.3.14
 Changes:
   - Support Ruby 2.7.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    table_structure (0.3.14)
+    table_structure (0.3.15)
 
 GEM
   remote: https://rubygems.org/
@@ -32,4 +32,4 @@ DEPENDENCIES
   table_structure!
 
 BUNDLED WITH
-   2.0.2
+   2.1.1

data/README.md

@@ -76,7 +76,7 @@ schema = SampleTableSchema.new(context: context)
 Initialize a writer with the schema:
 ```ruby
 writer = TableStructure::Writer.new(schema)
-## When omitting header line
+## To omit header, write:
 # writer = TableStructure::Writer.new(schema, header_omitted: true)
 ```
 
@@ -97,8 +97,9 @@ items = [
   }
 ]
 
-## When using `find_each` method of Rails
+## To use Rails `find_each` method, write:
 # items = Item.enum_for(:find_each)
+## or
 # items = Enumerator.new { |y| Item.find_each { |item| y << item } }
 
 table = []
@@ -117,7 +118,7 @@ end
 
 Writes the items converted by the schema to stream as CSV with Rails:
 ```ruby
-# response.headers['X-Accel-Buffering'] = 'no' # When using Nginx for reverse proxy
+# response.headers['X-Accel-Buffering'] = 'no' # Required if Nginx is used for reverse proxy
 response.headers['Cache-Control'] = 'no-cache'
 response.headers['Content-Type'] = 'text/csv'
 response.headers['Content-Disposition'] = 'attachment; filename="sample.csv"'
@@ -164,7 +165,7 @@ class SampleTableSchema
     end
   }
 
-  ## When nesting schemas, :key must be unique in parent and child schemas.
+  ## If the schemas are nested, :key must be unique in parent and child schemas.
   ## This can also be avoided by specifying :key_prefix or :key_suffix option.
   # columns ->(table) { NestedSchema.new(context: table, key_prefix: 'foo_', key_suffix: '_bar') }
 
@@ -318,8 +319,56 @@ context = {
 schema = SampleTableSchema.new(context: context)
 ```
 
+You can also concatenate schemas.
+If there are some definitions of `column_converter` with the same name in the schemas to be concatenated, the one in the schema that is concatenated last will be used.
+```ruby
+class UserTableSchema
+  include TableStructure::Schema
+
+  column  name: 'ID',
+          value: ->(row, _table) { row[:id] }
+
+  column  name: 'Name',
+          value: ->(row, *) { row[:name] }
+end
+
+class PetTableSchema
+  include TableStructure::Schema
+
+  columns name: ['Pet 1', 'Pet 2', 'Pet 3'],
+          value: ->(row, *) { row[:pets] }
+
+  column_converter :same_name, ->(val, *) { 'This definition will not be used.' }
+end
+
+class QuestionTableSchema
+  include TableStructure::Schema
+
+  columns ->(table) {
+    table[:questions].map do |question|
+      {
+        name: question[:id],
+        value: ->(row, *) { row[:answers][question[:id]] }
+      }
+    end
+  }
+
+  column_converter :same_name, ->(val, *) { 'This definition will be used.' }
+end
+
+context = {
+  questions: [
+    { id: 'Q1', text: 'Do you like sushi?' },
+    { id: 'Q2', text: 'Do you like yakiniku?' },
+    { id: 'Q3', text: 'Do you like ramen?' }
+  ]
+}
+
+schema = (UserTableSchema + PetTableSchema + QuestionTableSchema).new(context: context)
+```
+
 You can also use `context_builder`.
-This may be useful when `column(s)` lambda is complicated.
+This may be useful if `column(s)` lambda is complicated.
 ```ruby
 class SampleTableSchema
   include TableStructure::Schema
@@ -359,7 +408,7 @@ If you want to convert CSV character code, you can do so within block of `write`
 ```ruby
 File.open('sample.csv', 'w') do |f|
   writer.write(items, to: CSV.new(f)) do |row_values|
-    row_values.map { |val| val&.to_s&.encode('Shift_JIS', invalid: :replace, undef: :replace) }
+    row_values.map { |val| val.to_s.encode('Shift_JIS', invalid: :replace, undef: :replace) }
   end
 end
 ```

data/lib/table_structure/csv/writer.rb

@@ -3,53 +3,47 @@
 module TableStructure
   module CSV
     class Writer
-      DEFAULT_OPTIONS = {
-        bom: false,
-        csv_options: {}
-      }.freeze
-
-      INNER_WRITER_DEFAULT_OPTIONS = ::TableStructure::Writer::DEFAULT_OPTIONS
-      INNER_WRITER_IGNORED_OPTION_KEYS = %i[
-        result_type
-        method
-      ].freeze
-
       BOM = "\uFEFF"
 
-      def initialize(schema, **options)
+      def initialize(
+        schema,
+        bom: false,
+        csv_options: {},
+        header_omitted: false,
+        header_context: nil
+      )
         require 'csv'
-        @options = DEFAULT_OPTIONS.merge(select_csv_writer_options(options))
-        inner_writer_options = select_inner_writer_options(options)
-        @writer = ::TableStructure::Writer.new(schema, **inner_writer_options)
-      end
-
-      def write(items, to:, **options, &block)
-        csv_writer_options = @options.merge(select_csv_writer_options(options))
-        inner_writer_options = select_inner_writer_options(options)
-        if csv_writer_options[:bom]
-          to.send(INNER_WRITER_DEFAULT_OPTIONS[:method], BOM)
-        end
-        csv = ::CSV.new(to, **csv_writer_options[:csv_options])
-        @writer.write(items, to: csv, **inner_writer_options, &block)
-      end
 
-      private
+        @options = {
+          bom: bom,
+          csv_options: csv_options
+        }
+        @inner_options = {
+          header_omitted: header_omitted,
+          header_context: header_context
+        }
 
-      def select_csv_writer_options(options)
-        options
-          .select { |k, _v| DEFAULT_OPTIONS.include?(k) }
+        @writer = ::TableStructure::Writer.new(schema, **@inner_options)
       end
 
-      def select_inner_writer_options(options)
-        options
-          .select { |k, _v| INNER_WRITER_DEFAULT_OPTIONS.include?(k) }
-          .reject do |k, v|
-            ignored = INNER_WRITER_IGNORED_OPTION_KEYS.include?(k)
-            if ignored
-              warn "[TableStructure] #{self.class.name} ignores `#{k}:#{v}` option."
-            end
-            ignored
-          end
+      def write(
+        items,
+        to:,
+        bom: @options[:bom],
+        csv_options: @options[:csv_options],
+        header_omitted: @inner_options[:header_omitted],
+        header_context: @inner_options[:header_context],
+        &block
+      )
+        inner_options = {
+          header_omitted: header_omitted,
+          header_context: header_context
+        }
+
+        to << BOM if bom
+
+        csv = ::CSV.new(to, **csv_options)
+        @writer.write(items, to: csv, **inner_options, &block)
       end
     end
   end

data/lib/table_structure/schema/class_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module ClassMethods
+      def +(schema)
+        self_schema = self
+        Class.new do
+          include ::TableStructure::Schema
+
+          @__column_definitions__ = [
+            self_schema.column_definitions,
+            schema.column_definitions
+          ].flatten
+
+          @__context_builders__ =
+            {}
+            .merge!(self_schema.context_builders)
+            .merge!(schema.context_builders)
+
+          @__column_converters__ =
+            {}
+            .merge!(self_schema.column_converters)
+            .merge!(schema.column_converters)
+
+          @__result_builders__ =
+            {}
+            .merge!(self_schema.result_builders)
+            .merge!(schema.result_builders)
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/column/attrs.rb

@@ -6,19 +6,19 @@ module TableStructure
       class Attrs
         attr_reader :keys, :size
 
-        def initialize(definition)
-          @name = definition[:name]
-          @keys = optimize_size([definition[:key]].flatten, definition[:size])
-          @value = definition[:value]
-          @size = definition[:size]
+        def initialize(name:, key:, value:, size:)
+          @name = name
+          @keys = optimize_size([key].flatten, size)
+          @value = value
+          @size = size
         end
 
-        def name(context, table_context)
+        def names(context, table_context)
           name = Utils.evaluate_callable(@name, context, table_context)
           optimize_size(name, @size)
         end
 
-        def value(context, table_context)
+        def values(context, table_context)
           value = Utils.evaluate_callable(@value, context, table_context)
           optimize_size(value, @size)
         end

data/lib/table_structure/schema/column/definition/compiler.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Column
+      module Definition
+        class Compiler
+          DEFAULT_ATTRS = {
+            name: nil,
+            key: nil,
+            value: nil,
+            size: nil,
+            omitted: false
+          }.freeze
+
+          DEFAULT_SIZE = 1
+
+          def initialize(name, definitions, options)
+            @name = name
+            @definitions = definitions
+            @options = options
+          end
+
+          def compile(context = nil)
+            @definitions
+              .map { |definition| Utils.evaluate_callable(definition, context) }
+              .map.with_index do |definition, i|
+                validator = Validator.new(@name, i)
+
+                [definition]
+                  .flatten
+                  .map do |definition|
+                    if definition.is_a?(Hash)
+                      definition = DEFAULT_ATTRS.merge(definition)
+                      omitted = definition.delete(:omitted)
+                      next if Utils.evaluate_callable(omitted, context)
+
+                      definition = evaluate_attrs(definition, context)
+                      validator.validate(**definition)
+                      definition[:size] = determine_size(**definition)
+                      definition
+                    elsif Utils.schema_instance?(definition)
+                      definition
+                    elsif Utils.schema_class?(definition)
+                      definition.new(context: context)
+                    elsif definition.nil? && @options[:nil_definitions_ignored]
+                      next
+                    else
+                      raise Error.new('Invalid definition.', @name, i)
+                    end
+                  end
+              end
+              .flatten
+              .compact
+          end
+
+          private
+
+          def evaluate_attrs(definition, context)
+            size = Utils.evaluate_callable(definition[:size], context)
+            definition.merge(size: size)
+          end
+
+          def determine_size(name:, key:, size:, **)
+            return size if size
+
+            [calculate_size(name), calculate_size(key)].max
+          end
+
+          def calculate_size(val)
+            if val.is_a?(Array)
+              return val.empty? ? DEFAULT_SIZE : val.size
+            end
+
+            DEFAULT_SIZE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/column/definition/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Column
+      module Definition
+        class Error < ::TableStructure::Error
+          attr_reader :schema_name, :definition_index
+
+          def initialize(error_message, schema_name, definition_index)
+            @schema_name = schema_name
+            @definition_index = definition_index
+            super("#{error_message} [#{schema_name}] defined position of column(s): #{definition_index + 1}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/column/definition/validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Column
+      module Definition
+        class Validator
+          DEFAULT_SIZE = 1
+
+          def initialize(name, index)
+            @name = name
+            @index = index
+          end
+
+          def validate(name:, key:, size:, **)
+            if key.respond_to?(:call)
+              raise Error.new('"key" must not be lambda.', @name, @index)
+            end
+            if !key && name.respond_to?(:call) && !size
+              raise Error.new('"size" must be defined, because column size cannot be determined.', @name, @index)
+            end
+            if size && size < DEFAULT_SIZE
+              raise Error.new('"size" must be positive.', @name, @index)
+            end
+            if key && size && [key].flatten.size < size
+              raise Error.new('"key" size must not be less than specified "size".', @name, @index)
+            end
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/column/factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Column
+      module Factory
+        def self.create(name, definitions, context, options)
+          Definition::Compiler
+            .new(name, definitions, options)
+            .compile(context)
+            .map do |definition|
+              if definition.is_a?(Hash)
+                Attrs.new(**definition)
+              else
+                Schema.new(definition)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/column/schema.rb

@@ -10,7 +10,7 @@ module TableStructure
           @table = schema.create_table
         end
 
-        def name(header_context, _table_context)
+        def names(header_context, _table_context)
           @table.header(context: header_context)
         end
 
@@ -18,7 +18,7 @@ module TableStructure
           @table.send(:keys)
         end
 
-        def value(row_context, _table_context)
+        def values(row_context, _table_context)
           @table.row(context: row_context)
         end
 

data/lib/table_structure/schema/column_converters.rb

@@ -8,11 +8,12 @@ module TableStructure
         @row_converters = select_converters_for(:row, converters)
       end
 
-      def extend_methods_for(table)
+      def extend_methods_for(table, name_prefix:, name_suffix:)
         table_context = table.instance_variable_get(:@context)
-        table_options = table.instance_variable_get(:@options)
 
-        header_converters = @header_converters.merge(optional_header_converters(table_options))
+        header_converters = @header_converters.merge(
+          optional_header_converters(name_prefix: name_prefix, name_suffix: name_suffix)
+        )
         row_converters = @row_converters
 
         methods = {}
@@ -37,15 +38,15 @@ module TableStructure
           .to_h
       end
 
-      def optional_header_converters(options)
+      def optional_header_converters(name_prefix:, name_suffix:)
         converters = {}
-        if options[:name_prefix]
+        if name_prefix
           converters[:_prepend_prefix_] =
-            create_prefix_converter(options[:name_prefix])
+            create_prefix_converter(name_prefix)
         end
-        if options[:name_suffix]
+        if name_suffix
           converters[:_append_suffix_] =
-            create_suffix_converter(options[:name_suffix])
+            create_suffix_converter(name_suffix)
         end
 
         converters

data/lib/table_structure/schema/dsl/column_converter.rb

@@ -19,7 +19,7 @@ module TableStructure
         end
 
         def column_converters
-          @table_structure_schema_column_converters__ ||= {}
+          @__column_converters__ ||= {}
         end
       end
     end

data/lib/table_structure/schema/dsl/column_definition.rb

@@ -14,7 +14,7 @@ module TableStructure
         end
 
         def column_definitions
-          @table_structure_schema_column_definitions__ ||= []
+          @__column_definitions__ ||= []
         end
       end
     end

data/lib/table_structure/schema/dsl/context_builder.rb

@@ -10,7 +10,7 @@ module TableStructure
         end
 
         def context_builders
-          @table_structure_schema_context_builders__ ||= {}
+          @__context_builders__ ||= {}
         end
       end
     end

data/lib/table_structure/schema/dsl/option.rb

@@ -11,7 +11,7 @@ module TableStructure
         end
 
         def options
-          @table_structure_schema_options__ ||= {}
+          @__options__ ||= {}
         end
       end
     end

data/lib/table_structure/schema/dsl/result_builder.rb

@@ -19,7 +19,7 @@ module TableStructure
         end
 
         def result_builders
-          @table_structure_schema_result_builders__ ||= {}
+          @__result_builders__ ||= {}
         end
       end
     end

data/lib/table_structure/schema/result_builders.rb

@@ -18,15 +18,14 @@ module TableStructure
         @builders = builders
       end
 
-      def extend_methods_for(table)
-        table_context = table.instance_variable_get(:@context)
-        table_options = table.instance_variable_get(:@options)
-        table_keys = table.send(:keys)
-
-        builders = select_builders(table_options[:result_type])
+      def extend_methods_for(table, result_type: :array)
+        builders = select_builders(result_type)
 
         methods = {}
         unless builders.empty?
+          table_context = table.instance_variable_get(:@context)
+          table_keys = table.send(:keys)
+
           methods[:header] = create_method(builders, table_keys, table_context)
           methods[:row] = create_method(builders, table_keys, table_context)
         end

data/lib/table_structure/schema/table.rb

@@ -3,10 +3,6 @@
 module TableStructure
   module Schema
     class Table
-      DEFAULT_OPTIONS = {
-        result_type: :array
-      }.freeze
-
       def initialize(
         columns,
         context,
@@ -14,15 +10,15 @@ module TableStructure
       )
         @columns = columns
         @context = context
-        @options = DEFAULT_OPTIONS.merge(options)
+        @options = options
       end
 
       def header(context: nil)
-        values(:name, context)
+        values(:names, context)
       end
 
       def row(context: nil)
-        values(:value, context)
+        values(:values, context)
       end
 
       def rows(items)

data/lib/table_structure/schema.rb

@@ -8,8 +8,20 @@ module TableStructure
       klass.extend(DSL::ContextBuilder)
       klass.extend(DSL::Option)
       klass.extend(DSL::ResultBuilder)
+      klass.extend(ClassMethods)
     end
 
+    Definition = Struct.new(
+      'Definition',
+      :name,
+      :columns,
+      :context_builders,
+      :column_converters,
+      :result_builders,
+      :context,
+      :options
+    )
+
     def initialize(
       name: self.class.name,
       context: nil,
@@ -23,14 +35,10 @@ module TableStructure
       unless deprecated_options.empty?
         caller_location = caller_locations(1, 1)
         deprecated_options.keys.each do |k|
-          warn "[TableStructure] Specify #{k} option on the writer or the iterator. #{caller_location}"
+          warn "[TableStructure] Specify :#{k} option on the writer or the iterator. #{caller_location}"
         end
       end
 
-      column_definitions = [].concat(self.class.column_definitions)
-      context_builders = {}.merge!(self.class.context_builders)
-      column_converters = {}.merge!(self.class.column_converters)
-      result_builders = {}.merge!(self.class.result_builders)
       options = {
         name_prefix: name_prefix,
         name_suffix: name_suffix,
@@ -39,10 +47,17 @@ module TableStructure
         nil_definitions_ignored: nil_definitions_ignored
       }.merge!(self.class.options).merge!(deprecated_options)
 
-      @table_structure_schema_definition_ =
+      context_builders = ContextBuilders.new({}.merge!(self.class.context_builders))
+      column_converters = ColumnConverters.new({}.merge!(self.class.column_converters))
+      result_builders = ResultBuilders.new({}.merge!(self.class.result_builders))
+
+      context = context_builders.build_for_table(context)
+      columns = Column::Factory.create(name, self.class.column_definitions, context, options)
+
+      @_definition_ =
         Definition.new(
           name,
-          column_definitions,
+          columns,
           context_builders,
           column_converters,
           result_builders,
@@ -51,8 +66,36 @@ module TableStructure
         )
     end
 
-    def create_table(**options, &block)
-      @table_structure_schema_definition_.create_table(**options, &block)
+    # TODO: Specify options using keyword arguments.
+    def create_table(**options)
+      options = @_definition_.options.merge(options)
+
+      table = Table.new(
+        @_definition_.columns,
+        @_definition_.context,
+        options
+      )
+
+      @_definition_.context_builders.extend_methods_for(table)
+
+      column_converters_options = {
+        name_prefix: options[:name_prefix],
+        name_suffix: options[:name_suffix]
+      }
+
+      @_definition_.column_converters.extend_methods_for(table, **column_converters_options)
+
+      result_builders_options = {
+        result_type: options[:result_type]
+      }
+
+      @_definition_.result_builders.extend_methods_for(table, **result_builders_options)
+
+      if block_given?
+        yield table
+      else
+        table
+      end
     end
   end
 end

data/lib/table_structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TableStructure
-  VERSION = '0.3.14'
+  VERSION = '0.3.15'
 end

data/lib/table_structure.rb

@@ -6,15 +6,12 @@ module TableStructure
   require 'table_structure/version'
 
   require 'table_structure/schema'
+  require 'table_structure/schema/class_methods'
   require 'table_structure/schema/dsl/column_converter'
   require 'table_structure/schema/dsl/column_definition'
   require 'table_structure/schema/dsl/context_builder'
   require 'table_structure/schema/dsl/option'
   require 'table_structure/schema/dsl/result_builder'
-  require 'table_structure/schema/definition'
-  require 'table_structure/schema/definition/compiler'
-  require 'table_structure/schema/definition/error'
-  require 'table_structure/schema/definition/validator'
   require 'table_structure/schema/column_converters'
   require 'table_structure/schema/context_builders'
   require 'table_structure/schema/result_builders'
@@ -22,6 +19,10 @@ module TableStructure
   require 'table_structure/schema/table/key_decorator'
   require 'table_structure/schema/column/attrs'
   require 'table_structure/schema/column/schema'
+  require 'table_structure/schema/column/factory'
+  require 'table_structure/schema/column/definition/compiler'
+  require 'table_structure/schema/column/definition/error'
+  require 'table_structure/schema/column/definition/validator'
   require 'table_structure/schema/utils'
   require 'table_structure/writer'
   require 'table_structure/csv/writer'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.3.15
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-15 00:00:00.000000000 Z
+date: 2019-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,14 +74,15 @@ files:
 - lib/table_structure/csv/writer.rb
 - lib/table_structure/iterator.rb
 - lib/table_structure/schema.rb
+- lib/table_structure/schema/class_methods.rb
 - lib/table_structure/schema/column/attrs.rb
+- lib/table_structure/schema/column/definition/compiler.rb
+- lib/table_structure/schema/column/definition/error.rb
+- lib/table_structure/schema/column/definition/validator.rb
+- lib/table_structure/schema/column/factory.rb
 - lib/table_structure/schema/column/schema.rb
 - lib/table_structure/schema/column_converters.rb
 - lib/table_structure/schema/context_builders.rb
-- lib/table_structure/schema/definition.rb
-- lib/table_structure/schema/definition/compiler.rb
-- lib/table_structure/schema/definition/error.rb
-- lib/table_structure/schema/definition/validator.rb
 - lib/table_structure/schema/dsl/column_converter.rb
 - lib/table_structure/schema/dsl/column_definition.rb
 - lib/table_structure/schema/dsl/context_builder.rb
@@ -113,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Generates and outputs table structured data.

data/lib/table_structure/schema/definition/compiler.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Definition
-      class Compiler
-        DEFAULT_ATTRS = {
-          name: nil,
-          key: nil,
-          value: nil,
-          size: nil,
-          omitted: false
-        }.freeze
-
-        DEFAULT_SIZE = 1
-
-        def initialize(name, definitions, options)
-          @name = name
-          @definitions = definitions
-          @options = options
-        end
-
-        def compile(context = nil)
-          @definitions
-            .map { |definition| Utils.evaluate_callable(definition, context) }
-            .map.with_index do |definition, i|
-              validator = Validator.new(@name, i)
-
-              [definition]
-                .flatten
-                .map do |definition|
-                  if definition.is_a?(Hash)
-                    definition = DEFAULT_ATTRS.merge(definition)
-                    omitted = definition.delete(:omitted)
-                    next if Utils.evaluate_callable(omitted, context)
-
-                    definition = evaluate_attrs(definition, context)
-                    validator.validate(**definition)
-                    definition[:size] = determine_size(**definition)
-                    definition
-                  elsif Utils.schema_instance?(definition)
-                    definition
-                  elsif Utils.schema_class?(definition)
-                    definition.new(context: context)
-                  elsif definition.nil? && @options[:nil_definitions_ignored]
-                    next
-                  else
-                    raise Error.new('Invalid definition.', @name, i)
-                  end
-                end
-            end
-            .flatten
-            .compact
-        end
-
-        private
-
-        def evaluate_attrs(definition, context)
-          size = Utils.evaluate_callable(definition[:size], context)
-          definition.merge(size: size)
-        end
-
-        def determine_size(name:, key:, size:, **)
-          return size if size
-
-          [calculate_size(name), calculate_size(key)].max
-        end
-
-        def calculate_size(val)
-          if val.is_a?(Array)
-            return val.empty? ? DEFAULT_SIZE : val.size
-          end
-
-          DEFAULT_SIZE
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/definition/error.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Definition
-      class Error < ::TableStructure::Error
-        attr_reader :schema_name, :definition_index
-
-        def initialize(error_message, schema_name, definition_index)
-          @schema_name = schema_name
-          @definition_index = definition_index
-          super("#{error_message} [#{schema_name}] defined position of column(s): #{definition_index + 1}")
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/definition/validator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Definition
-      class Validator
-        DEFAULT_SIZE = 1
-
-        def initialize(name, index)
-          @name = name
-          @index = index
-        end
-
-        def validate(name:, key:, size:, **)
-          if key.respond_to?(:call)
-            raise Error.new('"key" must not be lambda.', @name, @index)
-          end
-          if !key && name.respond_to?(:call) && !size
-            raise Error.new('"size" must be defined, because column size cannot be determined.', @name, @index)
-          end
-          if size && size < DEFAULT_SIZE
-            raise Error.new('"size" must be positive.', @name, @index)
-          end
-          if key && size && [key].flatten.size < size
-            raise Error.new('"key" size must not be less than specified "size".', @name, @index)
-          end
-
-          true
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/definition.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Definition
-      attr_reader :options
-
-      def initialize(
-        name,
-        column_definitions,
-        context_builders,
-        column_converters,
-        result_builders,
-        context,
-        options
-      )
-        @name = name
-        @context_builders = ContextBuilders.new(context_builders)
-        @column_converters = ColumnConverters.new(column_converters)
-        @result_builders = ResultBuilders.new(result_builders)
-        @context = @context_builders.build_for_table(context)
-        @options = options
-
-        @columns = create_columns(@name, column_definitions, @context, @options)
-      end
-
-      def create_table(**options)
-        options = @options.merge(options)
-
-        table = Table.new(
-          @columns,
-          @context,
-          options
-        )
-
-        @context_builders.extend_methods_for(table)
-        @column_converters.extend_methods_for(table)
-        @result_builders.extend_methods_for(table)
-
-        if block_given?
-          yield table
-        else
-          table
-        end
-      end
-
-      private
-
-      def create_columns(name, definitions, context, options)
-        Compiler
-          .new(name, definitions, options)
-          .compile(context)
-          .map do |definition|
-            if definition.is_a?(Hash)
-              Column::Attrs.new(definition)
-            else
-              Column::Schema.new(definition)
-            end
-          end
-      end
-    end
-  end
-end