table_structure 0.3.20 → 0.3.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6070401fcd9287249b329ea8f2af80cd6a4f7bd3b758d983fa5aa7582344ece9
-  data.tar.gz: 717a02a0ed5146dae1054d8b606528c0673e1c5704c7825d0de6bf6385289791
+  metadata.gz: c8d52660a94da1c1fbcc8a14a8332214c32ba1627a50239ee72f9916e12c8502
+  data.tar.gz: 2156f6ebaa0ee6fd88dfb282a3c339e20101da8bf33cd250355eff7557915921
 SHA512:
-  metadata.gz: 3b07692b723c4c70363e93f91a680f8c0e1fd0d0d53e4925ffc758f11afe19a2134fcadae500fab54d6019ef0f92fb35c8a7f1b3c60923037628221c5816a2d2
-  data.tar.gz: b2b577a2052191f607c9f87c16606650fc565176207a13adf639a6b1b456d8d9acb053ec2788f4fcf523c82e360b28e9d00c2c30e529fa9bfafaefe5e367f5bc
+  metadata.gz: 9e5091c8a9c362a09b563e608cf78b74fddb53526ebd53ef30700f4c975429689c5ab8e27f72918d7c4fbdcd798b7911f20dd70593a313fe59bdb88d5deb8e35
+  data.tar.gz: 6ae2d481a839d63271009435173250f929009bd2273a59f3aaa974cc14e7612d7cb55258c82c2fe189f304277249d298e0eaaa7d15d1d20b6acc53cee3bb02f9

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.3.21
+Changes:
+- Add `TableStructure::Table`
+  - This provides methods for converting data with the schema.
+  - Use `TableStructure::Table.new` instead of `TableStructure::Schema#create_table`.
+- `TableStructure::Schema`
+  - `TableStructure::Schema#create_table` has been deprecated. Use `TableStructure::Table.new` instead.
+
 # 0.3.20
 Changes:
 - `TableStructure::Schema`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    table_structure (0.3.20)
+    table_structure (0.3.21)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -8,6 +8,8 @@
   - Converts data with the schema, and outputs table structured data.
 - `TableStructure::Iterator`
   - Converts data with the schema, and enumerates table structured data.
+- `TableStructure::Table`
+  - Provides methods for converting data with the schema.
 
 ## Installation
 
@@ -127,7 +129,6 @@ response_body = Enumerator.new do |y|
   writer.write(items, to: CSV.new(y))
 end
 ```
-[Sample with docker](https://github.com/jsmmr/ruby_table_structure_sample)
 
 You can also convert CSV character code:
 ```ruby
@@ -147,27 +148,31 @@ end
 ```
 
 #### TableStructure::Iterator
-Specifying `row_type: :hash` option works well.
-To use this option, define `column(s)` with `:key`.
+If you want to convert the item to row as Hash instead of Array, specify `row_type: :hash`.
+To use this option, define `:key` on `column(s)`.
 
 Define a schema:
 ```ruby
 class SampleTableSchema
   include TableStructure::Schema
 
-  # If header is required, :name must also be defined.
-  column  key: :id,
+  # If `:header` is set to `false`, `:name` is optional.
+  column  name: 'ID',
+          key: :id,
           value: ->(row, *) { row[:id] }
 
-  column  key: :name,
+  column  name: 'Name',
+          key: :name,
           value: ->(row, *) { row[:name] }
 
-  columns key: %i[pet1 pet2 pet3],
+  columns name: ['Pet 1', 'Pet 2', 'Pet 3'],
+          key: %i[pet1 pet2 pet3],
           value: ->(row, *) { row[:pets] }
 
   columns ->(table) {
     table[:questions].map do |question|
       {
+        name: question[:id],
         key: question[:id].downcase.to_sym,
         value: ->(row, *) { row[:answers][question[:id]] }
       }
@@ -175,7 +180,7 @@ class SampleTableSchema
   }
 
   ## 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.
+  ## This can also be avoided by using :key_prefix or :key_suffix option.
   # columns ->(table) { NestedTableSchema.new(context: table, key_prefix: 'foo_', key_suffix: '_bar') }
 end
 ```
@@ -191,7 +196,7 @@ context = {
 }
 
 schema = SampleTableSchema.new(context: context)
-iterator = TableStructure::Iterator.new(schema, row_type: :hash, header: false)
+iterator = TableStructure::Iterator.new(schema, header: false, row_type: :hash)
 ```
 
 Enumerate the items converted by the schema:
@@ -225,6 +230,33 @@ enum.lazy.select { |item| item[:q1] == '⭕️' }.take(1).force
 # => [{:id=>1, :name=>"Taro", :pet1=>"🐱", :pet2=>"🐶", :pet3=>nil, :q1=>"⭕️", :q2=>"❌", :q3=>"⭕️"}]
 ```
 
+#### TableStructure::Table
+
+Initialize a table with the schema and render the table:
+```erb
+<% TableStructure::Table.new(schema, row_type: :hash) do |table| %>
+  <table>
+    <thead>
+      <tr>
+        <% table.header.each do |key, value| %>
+          <th class="<%= key %>"><%= value %></th>
+        <% end %>
+      </tr>
+    </thead>
+
+    <tbody>
+      <% table.body(@items).each do |row| %>
+        <tr>
+          <% row.each do |key, value| %>
+            <td class="<%= key %>"><%= value %></td>
+          <% end %>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>
+```
+
 ### Advanced
 
 You can add definitions when initializing the schema.
@@ -244,7 +276,7 @@ schema = UserTableSchema.new do
 end
 ```
 
-You can also omit columns by defining `:omitted`.
+You can also omit columns by using `:omitted`.
 ```ruby
 class UserTableSchema
   include TableStructure::Schema
@@ -265,7 +297,7 @@ context = { admin: true }
 schema = UserTableSchema.new(context: context)
 ```
 
-You can also omit columns by specifying `nil_definitions_ignored: true`.
+You can also omit columns by using `:nil_definitions_ignored` option.
 If this option is set to `true` and `column(s)` difinition returns `nil`, the difinition is ignored.
 ```ruby
 class SampleTableSchema
@@ -327,37 +359,27 @@ end
 class SampleTableSchema
   include TableStructure::Schema
 
-  columns ->(table) { UserTableSchema.new(context: table) }
+  columns UserTableSchema
   ## or
-  # columns UserTableSchema
+  # columns ->(table) { UserTableSchema.new(context: table) }
 
-  columns ->(table) { PetTableSchema.new(context: table) }
+  columns PetTableSchema
   ## or
-  # columns PetTableSchema
+  # columns ->(table) { PetTableSchema.new(context: table) }
 
-  columns ->(table) { QuestionTableSchema.new(context: table) }
+  columns QuestionTableSchema
   ## or
-  # columns QuestionTableSchema
+  # columns ->(table) { QuestionTableSchema.new(context: table) }
 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 = SampleTableSchema.new(context: context)
 ```
 
 You can also concatenate or merge the schema classes.
 Both create a schema class, with a few differences.
 - `+`
   - Similar to nesting the schemas.
-    `column_converter` or `context_builder` works only to columns in the schema that they was defined.
+    `column_converter` works only to columns in the schema that they was defined.
 - `merge`
-  - If there are some definitions of `column_converter` or `context_builder` with the same name in the schemas to be merged, the one in the schema that is merged last will work to all columns.
+  - If there are some definitions of `column_converter` with the same name in the schemas to be merged, the one in the schema that is merged last will work to all columns.
 
 ```ruby
 class UserTableSchema
@@ -444,30 +466,9 @@ class SampleTableSchema
 end
 ```
 
-You can also use only `TableStructure::Schema` instance.
-```erb
-<% @schema.create_table(row_type: :hash) do |table| %>
-  <table>
-    <thead>
-      <tr>
-        <% table.header.each do |key, value| %>
-          <th class="<%= key %>"><%= value %></th>
-        <% end %>
-      </tr>
-    </thead>
+## Sample with docker
 
-    <tbody>
-      <% table.body(@items).each do |row| %>
-        <tr>
-          <% row.each do |key, value| %>
-            <td class="<%= key %>"><%= value %></td>
-          <% end %>
-        </tr>
-      <% end %>
-    </tbody>
-  </table>
-<% end %>
-```
+https://github.com/jsmmr/ruby_table_structure_sample
 
 ## Contributing
 

data/lib/table_structure.rb

@@ -21,14 +21,16 @@ module TableStructure
   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_converters'
-  require 'table_structure/schema/context_builders'
-  require 'table_structure/schema/row_builders'
-  require 'table_structure/schema/keys_generator'
-  require 'table_structure/schema/table'
+  require 'table_structure/schema/column_converter'
+  require 'table_structure/schema/row_builder'
+  require 'table_structure/schema/key_converter'
   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/table/iterator'
   require 'table_structure/writer'
   require 'table_structure/csv/writer'

data/lib/table_structure/iterator.rb

@@ -2,21 +2,106 @@
 
 module TableStructure
   class Iterator
-    def initialize(schema_or_writer, **options)
-      if schema_or_writer.is_a?(Schema)
-        schema = schema_or_writer
-        @writer = Writer.new(schema, **options)
-      elsif schema_or_writer.is_a?(Writer)
-        warn "[TableStructure] Pass Writer as an argument has been deprecated. Pass Schema instead. #{caller_locations(1, 1)}"
-        @writer = schema_or_writer
-      else
-        raise ::TableStructure::Error, "Must be either Schema or Writer. #{schema_or_writer}"
+    def initialize(
+      schema,
+      header: { context: nil },
+      row_type: :array,
+      **deprecated_options
+    )
+      if deprecated_options.key?(:header_omitted)
+        header_omitted = deprecated_options[:header_omitted]
+        warn "[TableStructure] `header_omitted: #{!!header_omitted}` option has been deprecated. Use `header: #{!header_omitted}` option instead."
+        header = !header_omitted
+      end
+
+      if deprecated_options.key?(:header_context)
+        header_context = deprecated_options[:header_context]
+        warn '[TableStructure] `:header_context` option has been deprecated. Use `header: { context: ... }` option instead.'
+        header = { context: header_context }
+      end
+
+      if deprecated_options.key?(:result_type)
+        warn '[TableStructure] `:result_type` option has been deprecated. Use `:row_type` option instead.'
+        row_type = deprecated_options[:result_type]
+      end
+
+      unless schema.is_a?(Schema)
+        raise ::TableStructure::Error, "Must be use Schema. #{schema}"
+      end
+
+      @schema = schema
+      @options = {
+        header: header,
+        row_type: row_type
+      }
+    end
+
+    def iterate(
+      items,
+      **deprecated_options,
+      &block
+    )
+      header = @options[:header]
+      row_type = @options[:row_type]
+
+      if deprecated_options.key?(:header)
+        header = deprecated_options[:header]
+        warn '[TableStructure] Use :header option on initialize method.'
+      end
+
+      if deprecated_options.key?(:header_omitted)
+        header_omitted = deprecated_options[:header_omitted]
+        warn "[TableStructure] `header_omitted: #{!!header_omitted}` option has been deprecated. Use `header: #{!header_omitted}` option instead."
+        header = !header_omitted
       end
+
+      if deprecated_options.key?(:header_context)
+        header_context = deprecated_options[:header_context]
+        warn '[TableStructure] `:header_context` option has been deprecated. Use `header: { context: ... }` option instead.'
+        header = { context: header_context }
+      end
+
+      if deprecated_options.key?(:row_type)
+        row_type = deprecated_options[:row_type]
+        warn '[TableStructure] Use :row_type option on initialize method.'
+      end
+
+      if deprecated_options.key?(:result_type)
+        warn '[TableStructure] `:result_type` option has been deprecated. Use `:row_type` option instead.'
+        row_type = deprecated_options[:result_type]
+      end
+
+      items = enumerize(items)
+
+      enum =
+        Table::Iterator
+        .new(
+          Table.new(@schema, row_type: row_type),
+          header: header
+        )
+        .iterate(items)
+
+      if block_given?
+        enum =
+          enum
+          .lazy
+          .map { |row| block.call(row) }
+      end
+
+      enum
     end
 
-    def iterate(items, **options, &block)
-      # TODO: Change not to use Writer.
-      Enumerator.new { |y| @writer.write(items, to: y, **options, &block) }
+    private
+
+    def enumerize(items)
+      if items.respond_to?(:each)
+        items
+      elsif items.respond_to?(:call)
+        warn "[TableStructure] Use `Enumerator` to wrap items instead of `lambda`. The use of `lambda` has been deprecated. #{items}"
+        Enumerator.new { |y| items.call(y) }
+      else
+        raise ::TableStructure::Error, "Must be enumerable. #{items}"
+      end
     end
   end
 end

data/lib/table_structure/schema.rb

@@ -21,15 +21,12 @@ module TableStructure
       end
     end
 
-    MyDefinition = Struct.new(
-      :name,
-      :columns,
-      :context_builders,
-      :column_converters,
-      :row_builders,
-      :context,
-      :options
-    )
+    attr_reader :columns,
+                :context_builders,
+                :column_converters,
+                :key_converter,
+                :row_builders,
+                :context
 
     def initialize(
       name: self.class.name,
@@ -42,20 +39,27 @@ module TableStructure
       **deprecated_options,
       &block
     )
-      unless deprecated_options.empty?
-        caller_location = caller_locations(1, 1)
-        deprecated_options.keys.each do |k|
-          warn "[TableStructure] Specify :#{k} option on Writer or Iterator. #{caller_location}"
-        end
+      if deprecated_options.key?(:row_type)
+        raise ::TableStructure::Error, 'Use :row_type option with Table, Writer or Iterator.'
+      end
+
+      if deprecated_options.key?(:result_type)
+        raise ::TableStructure::Error, ':result_type option has been deprecated. Use :row_type option instead.'
       end
 
-      options = {
-        name_prefix: name_prefix,
-        name_suffix: name_suffix,
-        key_prefix: key_prefix,
-        key_suffix: key_suffix,
-        nil_definitions_ignored: nil_definitions_ignored
-      }.merge!(self.class.options).merge!(deprecated_options)
+      options =
+        [
+          self.class.options,
+          {
+            name_prefix: name_prefix,
+            name_suffix: name_suffix,
+            key_prefix: key_prefix,
+            key_suffix: key_suffix,
+            nil_definitions_ignored: nil_definitions_ignored
+          },
+          deprecated_options
+        ]
+        .reduce({}, &:merge!)
 
       schema_classes = [self.class]
 
@@ -63,90 +67,65 @@ module TableStructure
         schema_classes << ::TableStructure::Schema.create_class(&block)
       end
 
-      context_builders = ContextBuilders.new(
-        schema_classes.map(&:context_builders).reduce({}, &:merge!)
-      )
+      @context_builders =
+        schema_classes
+        .map(&:context_builders)
+        .reduce({}, &:merge!)
 
-      column_converters = ColumnConverters.new(
-        schema_classes.map(&:column_converters).reduce({}, &:merge!)
-      )
+      table_context_builder = @context_builders.delete(:table)
+
+      @context = table_context_builder ? table_context_builder.call(context) : context
 
-      row_builders = RowBuilders.new(
-        schema_classes.map(&:row_builders).reduce({}, &:merge!)
+      @column_converters =
+        schema_classes
+        .map(&:column_converters)
+        .reduce({}, &:merge!)
+        .merge(
+          ColumnConverter.create_optional_converters(
+            name_prefix: options.delete(:name_prefix),
+            name_suffix: options.delete(:name_suffix)
+          )
+        )
+
+      @key_converter = KeyConverter.new(
+        prefix: options.delete(:key_prefix),
+        suffix: options.delete(:key_suffix)
       )
 
-      table_context = context_builders.build_for_table(context)
+      @row_builders =
+        RowBuilder.prepend_default_builders(
+          schema_classes
+            .map(&:row_builders)
+            .reduce({}, &:merge!)
+        )
 
-      columns =
+      @columns =
         Definition::Columns::Compiler
         .new(
           name,
           schema_classes.map(&:column_definitions).reduce([], &:concat),
-          options
+          { nil_definitions_ignored: options.delete(:nil_definitions_ignored) }
         )
-        .compile(table_context)
+        .compile(@context)
 
-      @_definition_ =
-        MyDefinition.new(
-          name,
-          columns,
-          context_builders,
-          column_converters,
-          row_builders,
-          table_context,
-          options
-        )
+      @options = options
     end
 
-    def create_table(row_type: :array, **deprecated_options)
-      options = @_definition_.options.merge(deprecated_options)
+    def create_table(row_type: :array, **deprecated_options, &block)
+      warn '[TableStructure] `TableStructure::Schema#create_table` has been deprecated. Use `TableStructure::Table.new` instead.'
+
+      options = @options.merge(deprecated_options)
 
       if options.key?(:result_type)
         warn '[TableStructure] `:result_type` option has been deprecated. Use `:row_type` option instead.'
         options[:row_type] = options[:result_type]
       end
 
-      keys_generator_options = {
-        prefix: options[:key_prefix],
-        suffix: options[:key_suffix]
-      }
-
-      keys_generator = KeysGenerator.new(
-        **keys_generator_options
-      )
-
-      table = Table.new(
-        columns: @_definition_.columns,
-        context: @_definition_.context,
-        keys_generator: keys_generator
-      )
-
-      @_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)
-
-      row_builders_options = {
-        row_type: options[:row_type] || row_type
-      }
-
-      @_definition_
-        .row_builders
-        .extend_methods_for(table, **row_builders_options)
+      ::TableStructure::Table.new(self, row_type: options[:row_type] || row_type, &block)
+    end
 
-      if block_given?
-        yield table
-      else
-        table
-      end
+    def contain_callable?(attribute)
+      @columns.any? { |column| column.contain_callable?(attribute) }
     end
   end
 end

data/lib/table_structure/schema/column_converter.rb

@@ -0,0 +1,48 @@
+# 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(
+            lambda { |val, *|
+              val.nil? ? val : "#{string}#{val}"
+            },
+            **options
+          )
+        end
+
+        def create_appender(string, **options)
+          Definition::ColumnConverter.new(
+            lambda { |val, *|
+              val.nil? ? val : "#{val}#{string}"
+            },
+            **options
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,8 @@ module TableStructure
     module Columns
       class Schema
         def initialize(schema)
-          @table = schema.create_table
+          @schema = schema
+          @table = ::TableStructure::Table.new(schema)
         end
 
         def names(header_context, _table_context)
@@ -25,7 +26,7 @@ module TableStructure
         end
 
         def contain_callable?(attribute)
-          @table.send(:contain_callable?, attribute)
+          @schema.contain_callable?(attribute)
         end
       end
     end

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

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

data/lib/table_structure/schema/row_builder.rb

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

data/lib/table_structure/table.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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 }
+
+      RowBuilder.create_module(
+        schema.row_builders,
+        row_type: row_type,
+        keys: keys,
+        context: schema.context
+      ) { |mod| extend mod }
+
+      yield self if block_given?
+    end
+
+    def header(context: nil)
+      row_values(:names, context)
+    end
+
+    def body(items)
+      Enumerator.new do |y|
+        items.each { |item| y << data(context: item) }
+      end
+    end
+
+    def rows(items)
+      warn '[TableStructure] `TableStructure::Table#rows(items)` has been deprecated. Use `TableStructure::Table#body(items)` instead.'
+      body(items)
+    end
+
+    def row(context: nil)
+      warn '[TableStructure] `TableStructure::Table#row(context: ...)` has been deprecated. Use `TableStructure::Table#body(items)` instead.'
+      data(context: context)
+    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/table/column_converter.rb

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,49 @@
+# 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] # will remove
+        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/iterator.rb

@@ -1,23 +1,21 @@
 # frozen_string_literal: true
 
 module TableStructure
-  module Table
-    class Iterator
-      def initialize(table, header: { context: nil })
-        @table = table
-        @header_options = header
-      end
+  class Table::Iterator
+    def initialize(table, header: { context: nil })
+      @table = table
+      @header_options = header
+    end
 
-      def iterate(items)
-        ::Enumerator.new do |y|
-          if @header_options
-            header_context = @header_options.is_a?(Hash) ? @header_options[:context] : nil
-            y << @table.header(context: header_context)
-          end
-          @table
-            .body(items)
-            .each { |row| y << row }
+    def iterate(items)
+      ::Enumerator.new do |y|
+        if @header_options
+          header_context = @header_options.is_a?(Hash) ? @header_options[:context] : nil
+          y << @table.header(context: header_context)
         end
+        @table
+          .body(items)
+          .each { |row| y << row }
       end
     end
   end

data/lib/table_structure/table/row_builder.rb

@@ -0,0 +1,38 @@
+# 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

data/lib/table_structure/version.rb

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

data/lib/table_structure/writer.rb

@@ -46,7 +46,7 @@ module TableStructure
 
       if deprecated_options.key?(:header)
         header = deprecated_options[:header]
-        warn '[TableStructure] Specify :header option as an argument for initialize method.'
+        warn '[TableStructure] Use :header option on initialize method.'
       end
 
       if deprecated_options.key?(:header_omitted)
@@ -63,7 +63,7 @@ module TableStructure
 
       if deprecated_options.key?(:row_type)
         row_type = deprecated_options[:row_type]
-        warn '[TableStructure] Specify :row_type option as an argument for initialize method.'
+        warn '[TableStructure] Use :row_type option on initialize method.'
       end
 
       if deprecated_options.key?(:result_type)
@@ -71,28 +71,13 @@ module TableStructure
         row_type = deprecated_options[:result_type]
       end
 
-      items = enumerize(items)
+      output = Output.new(to, method: method)
 
-      @schema.create_table(row_type: row_type) do |table|
-        output = Output.new(to, method: method)
+      Iterator
+        .new(@schema, header: header, row_type: row_type)
+        .iterate(items, &block)
+        .each { |row| output.write(row) }
 
-        enum =
-          Table::Iterator
-          .new(
-            table,
-            header: header
-          )
-          .iterate(items)
-
-        if block_given?
-          enum =
-            enum
-            .lazy
-            .map { |row| block.call(row) }
-        end
-
-        enum.each { |row| output.write(row) }
-      end
       nil
     end
 
@@ -108,16 +93,5 @@ module TableStructure
         @output.send(@method, values)
       end
     end
-
-    def enumerize(items)
-      if items.respond_to?(:each)
-        items
-      elsif items.respond_to?(:call)
-        warn "[TableStructure] Use `Enumerator` to wrap items instead of `lambda`. The use of `lambda` has been deprecated. #{items}"
-        Enumerator.new { |y| items.call(y) }
-      else
-        raise ::TableStructure::Error, "Must be enumerable. #{items}"
-      end
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.20
+  version: 0.3.21
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,10 +75,9 @@ files:
 - lib/table_structure/iterator.rb
 - lib/table_structure/schema.rb
 - lib/table_structure/schema/class_methods.rb
-- lib/table_structure/schema/column_converters.rb
+- lib/table_structure/schema/column_converter.rb
 - lib/table_structure/schema/columns/attributes.rb
 - lib/table_structure/schema/columns/schema.rb
-- lib/table_structure/schema/context_builders.rb
 - lib/table_structure/schema/definition/column_converter.rb
 - lib/table_structure/schema/definition/columns/attributes.rb
 - lib/table_structure/schema/definition/columns/compiler.rb
@@ -93,11 +92,14 @@ files:
 - lib/table_structure/schema/dsl/context_builder.rb
 - lib/table_structure/schema/dsl/option.rb
 - lib/table_structure/schema/dsl/row_builder.rb
-- lib/table_structure/schema/keys_generator.rb
-- lib/table_structure/schema/row_builders.rb
-- lib/table_structure/schema/table.rb
+- lib/table_structure/schema/key_converter.rb
+- lib/table_structure/schema/row_builder.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/iterator.rb
+- lib/table_structure/table/row_builder.rb
 - lib/table_structure/version.rb
 - lib/table_structure/writer.rb
 - table_structure.gemspec

data/lib/table_structure/schema/column_converters.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class ColumnConverters
-      def initialize(converters)
-        @header_converters = converters.select { |_k, v| v.applicable_to_header? }
-        @body_converterss = converters.select { |_k, v| v.applicable_to_body? }
-      end
-
-      def extend_methods_for(table, name_prefix:, name_suffix:)
-        table_context = table.instance_variable_get(:@context)
-
-        header_converters =
-          @header_converters
-          .merge(
-            _prepend_prefix_: create_prepender(name_prefix),
-            _append_suffix_: create_appender(name_suffix)
-          )
-          .reject { |_k, v| v.nil? }
-
-        body_converterss = @body_converterss
-
-        methods =
-          {
-            header: create_method(header_converters, table_context),
-            data: create_method(body_converterss, table_context)
-          }
-          .reject { |_k, v| v.nil? }
-
-        return if methods.empty?
-
-        table.extend ColumnConvertible.new(methods)
-      end
-
-      private
-
-      def create_prepender(prefix)
-        return unless prefix
-
-        Definition::ColumnConverter.new(
-          lambda { |val, *|
-            val.nil? ? val : "#{prefix}#{val}"
-          },
-          header: true,
-          body: false
-        )
-      end
-
-      def create_appender(suffix)
-        return unless suffix
-
-        Definition::ColumnConverter.new(
-          lambda { |val, *|
-            val.nil? ? val : "#{val}#{suffix}"
-          },
-          header: true,
-          body: false
-        )
-      end
-
-      def create_method(converters, table_context)
-        return if converters.empty?
-
-        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
-
-    class ColumnConvertible < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/context_builders.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class ContextBuilders
-      def initialize(builders)
-        @table_builder = builders[:table]
-        @header_builder = builders[:header]
-        @row_builder = builders[:row]
-      end
-
-      def build_for_table(context)
-        if @table_builder
-          @table_builder.call(context)
-        else
-          context
-        end
-      end
-
-      def extend_methods_for(table)
-        methods = {}
-
-        if table.send(:contain_callable?, :name)
-          methods[:header] = create_method(@header_builder)
-        end
-        if table.send(:contain_callable?, :value)
-          methods[:data] = create_method(@row_builder)
-        end
-
-        methods.reject! { |_k, v| v.nil? }
-        return if methods.empty?
-
-        table.extend 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
-
-    class ContextBuildable < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/row_builders.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class RowBuilders
-      DEFAULT_BUILDERS = {
-        _to_hash_: ::TableStructure::Schema::Definition::RowBuilder.new(
-          lambda { |values, keys, *|
-            keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
-          },
-          enabled_row_types: [:hash]
-        )
-      }.freeze
-
-      def initialize(builders)
-        @builders = builders
-      end
-
-      def extend_methods_for(table, row_type: :array)
-        builders =
-          DEFAULT_BUILDERS
-          .merge(@builders)
-          .select { |_k, v| v.enabled?(row_type) }
-
-        return if builders.empty?
-
-        table_context = table.instance_variable_get(:@context)
-        table_keys = table.send(:keys)
-
-        table.extend ResultBuildable.new(
-          header: create_method(builders, table_keys, table_context),
-          data: create_method(builders, table_keys, table_context)
-        )
-      end
-
-      private
-
-      def create_method(builders, table_keys, table_context)
-        return if builders.empty?
-
-        proc do |context: nil|
-          builders
-            .reduce(super(context: context)) do |vals, (_, builder)|
-              builder.call(vals, table_keys, context, table_context)
-            end
-        end
-      end
-    end
-
-    class ResultBuildable < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/table.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Table
-      def initialize(
-        columns:,
-        context:,
-        keys_generator:
-      )
-        @columns = columns
-        @context = context
-        @keys_generator = keys_generator
-      end
-
-      def header(context: nil)
-        row_values(:names, context)
-      end
-
-      def row(context: nil)
-        warn '[TableStructure] `TableStructure::Schema::Table#row(context:)` has been deprecated. Use `TableStructure::Schema::Table#body(items)` instead.'
-        data(context: context)
-      end
-
-      def body(items)
-        Enumerator.new do |y|
-          items.each { |item| y << data(context: item) }
-        end
-      end
-
-      def rows(items)
-        warn '[TableStructure] `TableStructure::Schema::Table#rows(items)` has been deprecated. Use `TableStructure::Schema::Table#body(items)` instead.'
-        body(items)
-      end
-
-      private
-
-      def data(context: nil)
-        row_values(:values, context)
-      end
-
-      def keys
-        @keys ||= @keys_generator.generate(@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
-
-      def contain_callable?(attribute)
-        @columns.any? { |column| column.contain_callable?(attribute) }
-      end
-    end
-  end
-end