table_structure 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bffa1aa49a812a2f4c1998aac9a297eeabe871a0c49376da090546da3a47a2d
-  data.tar.gz: 8bd2243648e9c2768339813f407e81cf2a94bd5e858349f9de0eaeb52acb6bfc
+  metadata.gz: 06f36abaa1bc4478901ea51a27e0e22b00ecf70ecbfd18b4c785c2e86e08ca1d
+  data.tar.gz: 26990e2f8ac30764a3d571dbf8a35e422ce163989f9eda5e92aa3c2b9e5cf498
 SHA512:
-  metadata.gz: 523e57f201c4aad11b038156676fa3c0c8835248366a7bb49929dc580265001f73c4a858049e972a782bf99d7f0a664407a6e258bdf94c616225b633c5d3461c
-  data.tar.gz: e3620fdee15c2bdb77d22224426d31c83349ba469f386681926d58963d5ee986b50b98b527cbc7d23e74edd8fba0891d8db2dd9ec7e256e7421cfdae890bf224
+  metadata.gz: 288ea6944e5efa303a3c39e4502dce7b0d2994504796a7de0b69b28d8b0cd91f878670db9846a51cbb57d16797bb8124e50f2162db00ec89b49d83de3a345030
+  data.tar.gz: 72d983aef1de40282befe38d230806b1fb3deec4ecf08801822867d43ea656a6a307ad53c46ae87f2661bcc90ef5c6f0b3d8c5ea515eb80ddeb78e559b552585

data/.travis.yml

@@ -8,4 +8,4 @@ rvm:
   - 2.5
   - 2.4
   - 2.3
-before_install: gem install bundler:2.1.2
+before_install: gem install bundler:2.1.4

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.4.2
+Changes:
+- `TableStructure::Schema`
+  - Improve performance.
+- `TableStructure::Iterator`
+- `TableStructure::Writer`
+- `TableStructure::CSV::Writer`
+  - Add validation for `header: { step: n }` option.
+    - `n` is allowed positive number or `nil`(default).
+
 # 0.4.1
 Changes:
 - `TableStructure::Iterator`

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    table_structure (0.4.1)
+    table_structure (0.4.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.3)
+    diff-lcs (1.4.4)
     rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.1)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
+    rspec-support (3.9.3)
 
 PLATFORMS
   ruby
@@ -32,4 +32,4 @@ DEPENDENCIES
   table_structure!
 
 BUNDLED WITH
-   2.1.2
+   2.1.4

data/README.md

@@ -106,10 +106,10 @@ items = [
 ## or
 # items = Enumerator.new { |y| Item.find_each { |item| y << item } }
 
-table = []
-writer.write(items, to: table)
+array = []
+writer.write(items, to: array)
 
-# table
+# array
 # => [["ID", "Name", "Pet 1", "Pet 2", "Pet 3", "Q1", "Q2", "Q3"], ["1", "Taro", "🐱", "🐶", "", "⭕️", "❌", "⭕️"], ["2", "Hanako", "🐇", "🐢", "🐿", "⭕️", "⭕️", "❌"]]
 ```
 

data/lib/table_structure.rb

@@ -5,31 +5,27 @@ module TableStructure
 
   require 'table_structure/version'
   require 'forwardable'
+  require 'table_structure/utils'
   require 'table_structure/schema'
   require 'table_structure/schema/class_methods'
-  require 'table_structure/schema/dsl/column_converter'
+  require 'table_structure/schema/composite_class'
+  require 'table_structure/schema/dsl/column_builder'
   require 'table_structure/schema/dsl/column_definition'
   require 'table_structure/schema/dsl/context_builder'
   require 'table_structure/schema/dsl/row_builder'
-  require 'table_structure/schema/definition/column_converter'
-  require 'table_structure/schema/definition/context_builder'
-  require 'table_structure/schema/definition/row_builder'
   require 'table_structure/schema/definition/columns/compiler'
   require 'table_structure/schema/definition/columns/error'
   require 'table_structure/schema/definition/columns/validator'
   require 'table_structure/schema/definition/columns/attributes'
   require 'table_structure/schema/definition/columns/schema_class'
   require 'table_structure/schema/definition/columns/schema_instance'
-  require 'table_structure/schema/column_converter'
-  require 'table_structure/schema/row_builder'
-  require 'table_structure/schema/key_converter'
+  require 'table_structure/schema/column_builder_factory'
+  require 'table_structure/schema/keys_builder'
+  require 'table_structure/schema/row_context_builder_factory'
   require 'table_structure/schema/columns/attributes'
   require 'table_structure/schema/columns/schema'
   require 'table_structure/schema/utils'
   require 'table_structure/table'
-  require 'table_structure/table/column_converter'
-  require 'table_structure/table/context_builder'
-  require 'table_structure/table/row_builder'
   require 'table_structure/writer'
   require 'table_structure/csv/writer'
   require 'table_structure/iterator'

data/lib/table_structure/iterator.rb

@@ -12,6 +12,17 @@ module TableStructure
           @context = options[:context]
           @step = options[:step]
         end
+
+        validate
+      end
+
+      private
+
+      def validate
+        if @step
+          raise ::TableStructure::Error, ':step must be numeric.' unless @step.is_a?(Numeric)
+          raise ::TableStructure::Error, ':step must be positive number.' unless @step.positive?
+        end
       end
     end
 
@@ -25,9 +36,7 @@ module TableStructure
     end
 
     def iterate(items, &block)
-      unless items.respond_to?(:each)
-        raise ::TableStructure::Error, "Must be enumerable. #{items}"
-      end
+      raise ::TableStructure::Error, "Must be enumerable. #{items}" unless items.respond_to?(:each)
 
       table_enum = ::Enumerator.new do |y|
         body_enum = @table.body(items)
@@ -36,7 +45,7 @@ module TableStructure
           header_row = @table.header(context: @header_options.context)
           y << header_row
 
-          if @header_options.step&.positive?
+          if @header_options.step
             loop do
               @header_options.step.times { y << body_enum.next }
               y << header_row

data/lib/table_structure/schema.rb

@@ -3,7 +3,7 @@
 module TableStructure
   module Schema
     def self.included(klass)
-      klass.extend(DSL::ColumnConverter)
+      klass.extend(DSL::ColumnBuilder)
       klass.extend(DSL::ColumnDefinition)
       klass.extend(DSL::ContextBuilder)
       klass.extend(DSL::RowBuilder)
@@ -11,20 +11,17 @@ module TableStructure
     end
 
     def self.create_class(&block)
-      raise ::TableStructure::Error, 'No block given.' unless block
+      raise ::TableStructure::Error, 'No block has been given.' unless block
 
-      schema_module = self
-      Class.new do
-        include schema_module
+      ::Class.new do
+        include Schema
         class_eval(&block)
       end
     end
 
-    attr_reader :columns,
-                :context_builders,
-                :column_converters,
-                :key_converter,
-                :row_builders,
+    Row = ::Struct.new(:keys, :values, :context)
+
+    attr_reader :row_builders,
                 :context
 
     def initialize(
@@ -37,56 +34,85 @@ module TableStructure
       nil_definitions_ignored: false,
       &block
     )
-      schema_classes = [self.class]
-
-      if block_given?
-        schema_classes << ::TableStructure::Schema.create_class(&block)
-      end
+      schema_class = CompositeClass.new.compose(self.class)
+      schema_class.compose(Schema.create_class(&block)) if block
 
-      @context_builders =
-        schema_classes
-        .map(&:context_builders)
-        .reduce({}, &:merge!)
+      context_builders = schema_class.context_builders
 
-      table_context_builder = @context_builders.delete(:table)
+      table_context_builder = context_builders.delete(:table)
 
       @context = table_context_builder ? table_context_builder.call(context) : context
 
-      @column_converters =
-        schema_classes
-        .map(&:column_converters)
-        .reduce({}, &:merge!)
-        .merge(
-          ColumnConverter.create_optional_converters(
-            name_prefix: name_prefix,
-            name_suffix: name_suffix
-          )
-        )
+      @row_context_builder_factory = RowContextBuilderFactory.new(self, context_builders)
+
+      @column_builder_factory = ColumnBuilderFactory.new(
+        schema_class.column_builders,
+        context: @context,
+        name_prefix: name_prefix,
+        name_suffix: name_suffix
+      )
 
-      @key_converter = KeyConverter.new(
+      @keys_builder = KeysBuilder.new(
         prefix: key_prefix,
         suffix: key_suffix
       )
 
-      @row_builders =
-        RowBuilder.prepend_default_builders(
-          schema_classes
-            .map(&:row_builders)
-            .reduce({}, &:merge!)
-        )
+      @row_builders = schema_class.row_builders
 
       @columns =
         Definition::Columns::Compiler
         .new(
           name,
-          schema_classes.map(&:column_definitions).reduce([], &:concat),
-          { nil_definitions_ignored: nil_definitions_ignored }
+          schema_class.column_definitions,
+          nil_definitions_ignored: nil_definitions_ignored
         )
         .compile(@context)
     end
 
-    def contain_callable?(attribute)
-      @columns.any? { |column| column.contain_callable?(attribute) }
+    def columns_keys
+      @columns_keys ||= @keys_builder.build(@columns.map(&:keys).flatten)
+    end
+
+    def columns_size
+      @columns.map(&:size).reduce(0, &:+)
+    end
+
+    def contain_name_callable?
+      @columns.any? { |column| column.name_callable? }
+    end
+
+    def contain_value_callable?
+      @columns.any? { |column| column.value_callable? }
+    end
+
+    def create_header_row_generator
+      ::TableStructure::Utils::CompositeCallable.new.compose(
+        @row_context_builder_factory.create_header_builder,
+        proc do |context|
+          values =
+            @columns
+            .map { |column| column.names(context, @context) }
+            .flatten
+
+          Row.new(columns_keys, values, context)
+        end,
+        @column_builder_factory.create_header_builder
+      )
+    end
+
+    def create_data_row_generator
+      ::TableStructure::Utils::CompositeCallable.new.compose(
+        @row_context_builder_factory.create_data_builder,
+        proc do |context|
+          values =
+            @columns
+            .map { |column| column.values(context, @context) }
+            .flatten
+
+          Row.new(columns_keys, values, context)
+        end,
+        @column_builder_factory.create_data_builder
+      )
     end
   end
 end

data/lib/table_structure/schema/class_methods.rb

@@ -36,9 +36,9 @@ module TableStructure
             .map(&:context_builders)
             .reduce({}, &:merge!)
 
-          @__column_converters__ =
+          @__column_builders__ =
             schema_classes
-            .map(&:column_converters)
+            .map(&:column_builders)
             .reduce({}, &:merge!)
 
           @__row_builders__ =

data/lib/table_structure/schema/column_builder_factory.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class ColumnBuilderFactory
+      def initialize(
+        builders,
+        context: nil,
+        name_prefix: nil,
+        name_suffix: nil
+      )
+        @builders = builders
+        @context = context
+
+        optional_builders = {}
+
+        if name_prefix
+          optional_builders[:_name_prepender_] =
+            ::TableStructure::Utils::TypedProc.new(
+              types: :header
+            ) do |val, *|
+              val.nil? ? val : "#{name_prefix}#{val}"
+            end
+        end
+
+        if name_suffix
+          optional_builders[:_name_appender_] =
+            ::TableStructure::Utils::TypedProc.new(
+              types: :header
+            ) do |val, *|
+              val.nil? ? val : "#{val}#{name_suffix}"
+            end
+        end
+
+        @builders.merge!(optional_builders) unless optional_builders.empty?
+      end
+
+      def create_header_builder
+        builders =
+          @builders
+          .select { |_k, v| v.typed?(:header) }
+          .values
+
+        return if builders.empty?
+
+        proc do |row|
+          row.values = row.values.map do |value|
+            builders.reduce(value) do |value, builder|
+              builder.call(value, row.context, @context)
+            end
+          end
+          row
+        end
+      end
+
+      def create_data_builder
+        builders =
+          @builders
+          .select { |_k, v| v.typed?(:body) }
+          .values
+
+        return if builders.empty?
+
+        proc do |row|
+          row.values = row.values.map do |value|
+            builders.reduce(value) do |value, builder|
+              builder.call(value, row.context, @context)
+            end
+          end
+          row
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/columns/attributes.rb

@@ -7,25 +7,30 @@ module TableStructure
         attr_reader :keys, :size
 
         def initialize(name:, key:, value:, size:)
-          @name = name
+          @name_callable = Utils.callable?(name)
+          @name = @name_callable ? name : proc { name }
           @keys = optimize_size([key].flatten, size)
-          @value = value
+          @value_callable = Utils.callable?(value)
+          @value = @value_callable ? value : proc { value }
           @size = size
         end
 
         def names(context, table_context)
-          name = Utils.evaluate_callable(@name, context, table_context)
-          optimize_size(name, @size)
+          names = @name.call(context, table_context)
+          optimize_size(names, @size)
         end
 
         def values(context, table_context)
-          value = Utils.evaluate_callable(@value, context, table_context)
-          optimize_size(value, @size)
+          values = @value.call(context, table_context)
+          optimize_size(values, @size)
         end
 
-        def contain_callable?(attribute)
-          val = instance_variable_get("@#{attribute}")
-          Utils.callable?(val)
+        def name_callable?
+          @name_callable
+        end
+
+        def value_callable?
+          @value_callable
         end
 
         private

data/lib/table_structure/schema/columns/schema.rb

@@ -6,27 +6,32 @@ module TableStructure
       class Schema
         def initialize(schema)
           @schema = schema
-          @table = ::TableStructure::Table.new(schema)
+          @header_row_generator = schema.create_header_row_generator
+          @data_row_generator = schema.create_data_row_generator
         end
 
-        def names(header_context, _table_context)
-          @table.header(context: header_context)
+        def names(row_context, *)
+          @header_row_generator.call(row_context).values
         end
 
         def keys
-          @table.send(:keys)
+          @schema.columns_keys
         end
 
-        def values(row_context, _table_context)
-          @table.send(:data, context: row_context)
+        def values(row_context, *)
+          @data_row_generator.call(row_context).values
         end
 
         def size
-          @table.send(:size)
+          @schema.columns_size
         end
 
-        def contain_callable?(attribute)
-          @schema.contain_callable?(attribute)
+        def name_callable?
+          @schema.contain_name_callable?
+        end
+
+        def value_callable?
+          @schema.contain_value_callable?
         end
       end
     end

data/lib/table_structure/schema/composite_class.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class CompositeClass
+      def initialize
+        @classes = []
+      end
+
+      def compose(*classes)
+        @classes.concat(classes.flatten.compact)
+        self
+      end
+
+      def column_definitions
+        @classes
+          .map(&:column_definitions)
+          .reduce([], &:concat)
+      end
+
+      def context_builders
+        @classes
+          .map(&:context_builders)
+          .reduce({}, &:merge!)
+      end
+
+      def column_builders
+        @classes
+          .map(&:column_builders)
+          .reduce({}, &:merge!)
+      end
+
+      def row_builders
+        @classes
+          .map(&:row_builders)
+          .reduce({}, &:merge!)
+      end
+    end
+  end
+end

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

@@ -5,10 +5,14 @@ module TableStructure
     module Definition
       module Columns
         class Compiler
-          def initialize(schema_name, definitions, options)
+          def initialize(
+            schema_name,
+            definitions,
+            nil_definitions_ignored: false
+          )
             @schema_name = schema_name
             @definitions = definitions
-            @options = options
+            @nil_definitions_ignored = !!nil_definitions_ignored
           end
 
           def compile(context = nil)
@@ -26,7 +30,7 @@ module TableStructure
                       SchemaInstance.new(definition)
                     elsif Utils.schema_class?(definition)
                       SchemaClass.new(definition)
-                    elsif definition.nil? && @options[:nil_definitions_ignored]
+                    elsif definition.nil? && @nil_definitions_ignored
                       next
                     else
                       raise Error.new('Invalid definition.', @schema_name, i)

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

@@ -13,15 +13,11 @@ module TableStructure
           end
 
           def validate(name:, key:, size:, **)
-            if key.respond_to?(:call)
-              raise Error.new('"key" must not be lambda.', @name, @index)
-            end
+            raise Error.new('"key" must not be lambda.', @name, @index) if key.respond_to?(:call)
             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
+            raise Error.new('"size" must be positive.', @name, @index) if size && size < DEFAULT_SIZE
             if key && size && [key].flatten.size < size
               raise Error.new('"key" size must not be less than specified "size".', @name, @index)
             end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module DSL
+      module ColumnBuilder
+        def column_builder(
+          name,
+          header: true,
+          body: true,
+          &block
+        )
+          column_builders[name] =
+            ::TableStructure::Utils::TypedProc.new(
+              types: { header: !!header, body: !!body }.select { |_k, v| v }.keys,
+              &block
+            )
+          nil
+        end
+
+        def column_builders
+          @__column_builders__ ||= {}
+        end
+
+        alias column_converter column_builder
+      end
+    end
+  end
+end

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

@@ -6,10 +6,7 @@ module TableStructure
       module ContextBuilder
         # TODO: Change definition style
         def context_builder(name, &block)
-          context_builders[name] =
-            ::TableStructure::Schema::Definition::ContextBuilder.new(
-              &block
-            )
+          context_builders[name] = block
           nil
         end
 

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

@@ -10,8 +10,8 @@ module TableStructure
           &block
         )
           row_builders[name] =
-            ::TableStructure::Schema::Definition::RowBuilder.new(
-              enabled_row_types: enabled_row_types,
+            ::TableStructure::Utils::TypedProc.new(
+              types: enabled_row_types,
               &block
             )
           nil

data/lib/table_structure/schema/{key_converter.rb → keys_builder.rb}

@@ -2,13 +2,13 @@
 
 module TableStructure
   module Schema
-    class KeyConverter
+    class KeysBuilder
       def initialize(prefix: nil, suffix: nil)
         @prefix = prefix
         @suffix = suffix
       end
 
-      def convert(keys)
+      def build(keys)
         return keys unless has_any_options?
 
         keys.map do |key|

data/lib/table_structure/schema/row_context_builder_factory.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class RowContextBuilderFactory
+      def initialize(schema, builders)
+        @schema = schema
+        @builders = builders
+      end
+
+      def create_header_builder
+        return unless @schema.contain_name_callable?
+        return unless @builders.key?(:header)
+
+        proc do |context|
+          @builders[:header].call(context)
+        end
+      end
+
+      def create_data_builder
+        return unless @schema.contain_value_callable?
+        return unless @builders.key?(:row)
+
+        proc do |context|
+          @builders[:row].call(context)
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/table.rb

@@ -2,61 +2,46 @@
 
 module TableStructure
   class Table
-    def initialize(schema, row_type: :array)
-      @columns = schema.columns
-      @context = schema.context
-      @key_converter = schema.key_converter
-
-      ContextBuilder.create_module(
-        schema.context_builders,
-        apply_to_name: schema.contain_callable?(:name),
-        apply_to_value: schema.contain_callable?(:value),
-        context: schema.context
-      ) { |mod| extend mod }
-
-      ColumnConverter.create_module(
-        schema.column_converters,
-        context: schema.context
-      ) { |mod| extend mod }
+    DEFAULT_ROW_BUILDERS = {
+      _to_hash_: Utils::TypedProc.new(
+        types: :hash
+      ) do |values, keys, *|
+        keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
+      end
+    }.freeze
 
-      RowBuilder.create_module(
-        schema.row_builders,
-        row_type: row_type,
-        keys: keys,
-        context: schema.context
-      ) { |mod| extend mod }
+    def initialize(schema, row_type: :array)
+      @header_row_generator = schema.create_header_row_generator
+      @data_row_generator = schema.create_data_row_generator
+
+      row_builders =
+        DEFAULT_ROW_BUILDERS
+        .merge(schema.row_builders)
+        .select { |_k, v| v.typed?(row_type) }
+        .values
+
+      unless row_builders.empty?
+        row_build_task = proc do |row|
+          row.values = row_builders.reduce(row.values) do |values, builder|
+            builder.call(values, row.keys, row.context, schema.context)
+          end
+          row
+        end
+        @header_row_generator.compose(row_build_task)
+        @data_row_generator.compose(row_build_task)
+      end
 
       yield self if block_given?
     end
 
     def header(context: nil)
-      row_values(:names, context)
+      @header_row_generator.call(context).values
     end
 
-    def body(items)
-      Enumerator.new do |y|
-        items.each { |item| y << data(context: item) }
+    def body(contexts)
+      ::Enumerator.new do |y|
+        contexts.each { |context| y << @data_row_generator.call(context).values }
       end
     end
-
-    private
-
-    def data(context: nil)
-      row_values(:values, context)
-    end
-
-    def keys
-      @keys ||= @key_converter.convert(@columns.map(&:keys).flatten)
-    end
-
-    def size
-      @size ||= @columns.map(&:size).reduce(0, &:+)
-    end
-
-    def row_values(method, context)
-      @columns
-        .map { |column| column.send(method, context, @context) }
-        .flatten
-    end
   end
 end

data/lib/table_structure/utils.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Utils
+    class Proc < ::Proc
+      attr_reader :options
+
+      def initialize(**options, &block)
+        @options = options
+        super(&block)
+      end
+    end
+
+    class TypedProc < Proc
+      def initialize(types:, **options, &block)
+        @types = [types].flatten.compact
+        super(**options, &block)
+      end
+
+      def typed?(type)
+        @types.include?(type)
+      end
+    end
+
+    class CompositeCallable
+      def initialize
+        @callables = []
+      end
+
+      def compose(*callables)
+        @callables.concat(callables.flatten.compact)
+        self
+      end
+
+      def call(source)
+        @callables.reduce(source) { |memo, callable| callable.call(memo) }
+      end
+    end
+  end
+end

data/lib/table_structure/version.rb

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

data/lib/table_structure/writer.rb

@@ -36,8 +36,6 @@ module TableStructure
       nil
     end
 
-    private
-
     class Output
       def initialize(output, method: :<<)
         @output = output

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,29 +75,25 @@ files:
 - lib/table_structure/iterator.rb
 - lib/table_structure/schema.rb
 - lib/table_structure/schema/class_methods.rb
-- lib/table_structure/schema/column_converter.rb
+- lib/table_structure/schema/column_builder_factory.rb
 - lib/table_structure/schema/columns/attributes.rb
 - lib/table_structure/schema/columns/schema.rb
-- lib/table_structure/schema/definition/column_converter.rb
+- lib/table_structure/schema/composite_class.rb
 - lib/table_structure/schema/definition/columns/attributes.rb
 - lib/table_structure/schema/definition/columns/compiler.rb
 - lib/table_structure/schema/definition/columns/error.rb
 - lib/table_structure/schema/definition/columns/schema_class.rb
 - lib/table_structure/schema/definition/columns/schema_instance.rb
 - lib/table_structure/schema/definition/columns/validator.rb
-- lib/table_structure/schema/definition/context_builder.rb
-- lib/table_structure/schema/definition/row_builder.rb
-- lib/table_structure/schema/dsl/column_converter.rb
+- lib/table_structure/schema/dsl/column_builder.rb
 - lib/table_structure/schema/dsl/column_definition.rb
 - lib/table_structure/schema/dsl/context_builder.rb
 - lib/table_structure/schema/dsl/row_builder.rb
-- lib/table_structure/schema/key_converter.rb
-- lib/table_structure/schema/row_builder.rb
+- lib/table_structure/schema/keys_builder.rb
+- lib/table_structure/schema/row_context_builder_factory.rb
 - lib/table_structure/schema/utils.rb
 - lib/table_structure/table.rb
-- lib/table_structure/table/column_converter.rb
-- lib/table_structure/table/context_builder.rb
-- lib/table_structure/table/row_builder.rb
+- lib/table_structure/utils.rb
 - lib/table_structure/version.rb
 - lib/table_structure/writer.rb
 - table_structure.gemspec

data/lib/table_structure/schema/column_converter.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module ColumnConverter
-      class << self
-        def create_optional_converters(
-          name_prefix: nil,
-          name_suffix: nil
-        )
-          column_converters = {}
-
-          if name_prefix
-            column_converters[:_name_prepender_] =
-              create_prepender(name_prefix, header: true, body: false)
-          end
-
-          if name_suffix
-            column_converters[:_name_appender_] =
-              create_appender(name_suffix, header: true, body: false)
-          end
-
-          column_converters
-        end
-
-        private
-
-        def create_prepender(string, **options)
-          Definition::ColumnConverter.new(
-            **options
-          ) do |val, *|
-            val.nil? ? val : "#{string}#{val}"
-          end
-        end
-
-        def create_appender(string, **options)
-          Definition::ColumnConverter.new(
-            **options
-          ) do |val, *|
-            val.nil? ? val : "#{val}#{string}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Definition
-      class ColumnConverter
-        extend Forwardable
-
-        def_delegator :@callable, :call
-
-        def initialize(
-          header: true,
-          body: true,
-          &block
-        )
-          @applicable_to_header = header
-          @applicable_to_body = body
-          @callable = block
-        end
-
-        def applicable_to_header?
-          !!@applicable_to_header
-        end
-
-        def applicable_to_body?
-          !!@applicable_to_body
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Definition
-      class ContextBuilder
-        extend Forwardable
-
-        def_delegator :@callable, :call
-
-        def initialize(&block)
-          @callable = block
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Definition
-      class RowBuilder
-        extend Forwardable
-
-        def_delegator :@callable, :call
-
-        def initialize(
-          enabled_row_types: %i[array hash],
-          &block
-        )
-          @enabled_row_types = [enabled_row_types].flatten
-          @callable = block
-        end
-
-        def enabled?(row_type)
-          @enabled_row_types.include?(row_type)
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module DSL
-      module ColumnConverter
-        def column_converter(
-          name,
-          header: true,
-          body: true,
-          &block
-        )
-          column_converters[name] =
-            ::TableStructure::Schema::Definition::ColumnConverter.new(
-              header: header,
-              body: body,
-              &block
-            )
-          nil
-        end
-
-        def column_converters
-          @__column_converters__ ||= {}
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/row_builder.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module RowBuilder
-      DEFAULT_ROW_BUILDERS = {
-        _to_hash_: Definition::RowBuilder.new(
-          enabled_row_types: [:hash]
-        ) do |values, keys, *|
-          keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
-        end
-      }.freeze
-
-      class << self
-        def prepend_default_builders(builders)
-          DEFAULT_ROW_BUILDERS.merge(builders)
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/table/column_converter.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  class Table::ColumnConverter
-    class ColumnConvertible < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-
-    class << self
-      def create_module(converters, context:)
-        return if converters.empty?
-
-        header_converters = converters.select { |_k, v| v.applicable_to_header? }
-        body_converters = converters.select { |_k, v| v.applicable_to_body? }
-
-        methods = {}
-
-        unless header_converters.empty?
-          methods[:header] = create_method(header_converters, context)
-        end
-
-        unless body_converters.empty?
-          methods[:data] = create_method(body_converters, context)
-        end
-
-        yield ColumnConvertible.new(methods)
-      end
-
-      private
-
-      def create_method(converters, table_context)
-        proc do |context: nil|
-          super(context: context).map do |val|
-            converters.reduce(val) do |val, (_, converter)|
-              converter.call(val, context, table_context)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/table/context_builder.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  class Table::ContextBuilder
-    class ContextBuildable < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-
-    class << self
-      def create_module(
-        builders,
-        apply_to_name: true,
-        apply_to_value: true,
-        context:
-      )
-        return if builders.empty?
-
-        header_builder = builders[:header] # TODO: Change not to use keyword of `header`
-        row_builder = builders[:row]
-
-        methods = {}
-
-        if apply_to_name && builders.key?(:header)
-          methods[:header] = create_method(builders[:header])
-        end
-
-        if apply_to_value && builders.key?(:row)
-          methods[:data] = create_method(builders[:row])
-        end
-
-        yield ContextBuildable.new(methods)
-      end
-
-      private
-
-      def create_method(builder)
-        return if builder.nil?
-
-        proc do |context: nil|
-          super(context: builder.call(context))
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/table/row_builder.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  class Table::RowBuilder
-    class ResultBuildable < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-
-    class << self
-      def create_module(builders, row_type:, keys:, context:)
-        return if builders.empty?
-
-        builders = builders.select { |_k, v| v.enabled?(row_type) }
-        return if builders.empty?
-
-        yield ResultBuildable.new(
-          header: create_method(builders, keys, context),
-          data: create_method(builders, keys, context)
-        )
-      end
-
-      private
-
-      def create_method(builders, table_keys, table_context)
-        proc do |context: nil|
-          builders
-            .reduce(super(context: context)) do |vals, (_, builder)|
-              builder.call(vals, table_keys, context, table_context)
-            end
-        end
-      end
-    end
-  end
-end