table_structure 0.3.11 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccde21d51d86d14d5aba71a9924bcc8d3669032b380005019866699cf5a9fd87
-  data.tar.gz: 31d7f45528e0972886db3a2f07f53cd030671bbabc79dda03e6728262da56d95
+  metadata.gz: 2b675232423fea16fcc7aaaeae505f782fd8db4371065e242eb794eeed07b0c9
+  data.tar.gz: c8f02884ae3ad9e768fde5253f9023299bd9967cb8b49406799a6f467ce1de17
 SHA512:
-  metadata.gz: '04844310bb6ebc8eb89aa78d9ee4f350ffa566d581d3acd555bdef70271326d674cb2e8dad9843b243a46daea29f0fe0ac879eeaa15da7b68b34c5c93dc670e4'
-  data.tar.gz: aebff92798ac40979500d660e4392eb567bcf4f0efbbc825859fc9a60b5b8be52e458776adab3665243706df995314834512335a7e0aa01f0b526b65d6509f6e
+  metadata.gz: 537a05a78c42d4250d5c64d51b839c9abfb16ee0055d2fdc2f59fb36e70d38f0a406d549c6d2ad00634a80812c2f9673064659829263cdb682e84c2ff5456429
+  data.tar.gz: e58886afb4755ef78a6520e7d4e07d941a4c5bc0c419fbe4e9f0bfd0739ed8005278a32bcb958c0284ae1e84d2dfcdca53db9d5b5c826682e367412a33c951ef

data/CHANGELOG.md

@@ -1,14 +1,19 @@
+# 0.3.12
+Changes:
+- `TableStructure::Schema`
+  - Fix `:name_prefix` and `:name_suffix` options so that they are applied after the column converters defined in the schema.
+
 # 0.3.11
 Changes:
 - `TableStructure::CSV::Writer`
-  - Add `:csv_options` option. This option's value is simply passed to `::CSV.new`'s options.
+  - Add `:csv_options` option. This option's value is simply passed to `::CSV.new` as options'.
 
 # 0.3.10
 Changes:
 - `TableStructure::Writer`
   - Fix an issue that objects with both `call` and` each` methods could not be enumerated.
 - `TableStructure::CSV::Writer`
-  - Fix write method's block to work.
+  - Fix `write` method's block to work.
 
 # 0.3.9
 Changes:
@@ -19,7 +24,7 @@ Changes:
 - `TableStructure::Schema`
   - Add `:nil_definitions_ignored` option.
     - This defaults to `false`, which is same behavior as before.
-    - If `true` is set, ignore the column definitions evaluated to `nil`. this behaves like as if to define `omitted: true` in the column definition.
+    - If `true` is set, the column definitions evaluated to `nil` are ignored. this behaves like as if to define `omitted: true` in the column definition.
 
 # 0.3.7
 Changes:
@@ -50,7 +55,7 @@ Changes:
 - `TableStructure::Writer`
   - Fix broken `:result_type` option.
 - `TableStructure::Iterator`
-  - Fix broken `:result_type` option. (Passed to the writer internally.)
+  - Fix broken `:result_type` option.
 
 # 0.3.3
 Changes:
@@ -70,9 +75,7 @@ Changes:
 - `TableStructure::Writer`
   - Make `:result_type` option available.
 - `TableStructure::Iterator`
-  - Make `:result_type` option available. (Passed to the writer internally.)
-- `TableStructure::Schema`
-  - `:result_type` option is deprecated.
+  - Make `:result_type` option available.
 
 # 0.3.0
 Changes:

data/Gemfile.lock

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

data/README.md

@@ -342,11 +342,10 @@ end
 You can also use only `TableStructure::Schema`.
 ```ruby
 schema = SampleTableSchema.new
-table = schema.create_table
+table = schema.create_table(result_type: :hash)
 header = table.header
 items.each do |item|
   row = table.row(context: item)
-  ...
 end
 ```
 

data/lib/table_structure.rb

@@ -15,12 +15,11 @@ module TableStructure
   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'
   require 'table_structure/schema/table'
-  require 'table_structure/schema/table/column_converter'
-  require 'table_structure/schema/table/context_builder'
   require 'table_structure/schema/table/key_decorator'
-  require 'table_structure/schema/table/result_builder'
-  require 'table_structure/schema/column'
   require 'table_structure/schema/column/attrs'
   require 'table_structure/schema/column/schema'
   require 'table_structure/schema/utils'

data/lib/table_structure/schema.rb

@@ -36,9 +36,8 @@ module TableStructure
         )
     end
 
-    def create_table(result_type: :array, **options)
-      options = @table_structure_schema_definition_.options.merge(options)
-      @table_structure_schema_definition_.create_table(result_type: result_type, **options)
+    def create_table(**options)
+      @table_structure_schema_definition_.create_table(options)
     end
   end
 end

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

@@ -6,12 +6,11 @@ module TableStructure
       class Attrs
         attr_reader :keys, :size
 
-        def initialize(definition, options)
+        def initialize(definition)
           @name = definition[:name]
           @keys = optimize_size([definition[:key]].flatten, definition[:size])
           @value = definition[:value]
           @size = definition[:size]
-          @options = options
         end
 
         def name(context, table_context)

data/lib/table_structure/schema/column_converters.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class ColumnConverters
+      def initialize(converters)
+        @header_converters = select_converters_for(:header, converters)
+        @row_converters = select_converters_for(:row, converters)
+      end
+
+      def extend_methods_for(table)
+        table_context = table.instance_variable_get(:@context)
+        table_options = table.instance_variable_get(:@options)
+
+        header_converters = @header_converters.merge(optional_header_converters(table_options))
+        row_converters = @row_converters
+
+        methods = {}
+        unless header_converters.empty?
+          methods[:header] = create_method(header_converters, table_context)
+        end
+        unless row_converters.empty?
+          methods[:row] = create_method(row_converters, table_context)
+        end
+
+        return if methods.empty?
+
+        table.extend ColumnConverter.new(methods)
+      end
+
+      private
+
+      def select_converters_for(method, converters)
+        converters
+          .select { |_k, v| v[:options][method] }
+          .map { |k, v| [k, v[:callable]] }
+          .to_h
+      end
+
+      def optional_header_converters(options)
+        converters = {}
+        if options[:name_prefix]
+          converters[:_prepend_prefix_] =
+            create_prefix_converter(options[:name_prefix])
+        end
+        if options[:name_suffix]
+          converters[:_append_suffix_] =
+            create_suffix_converter(options[:name_suffix])
+        end
+
+        converters
+      end
+
+      def create_prefix_converter(prefix)
+        lambda { |val, *|
+          val.nil? ? val : "#{prefix}#{val}"
+        }
+      end
+
+      def create_suffix_converter(suffix)
+        lambda { |val, *|
+          val.nil? ? val : "#{val}#{suffix}"
+        }
+      end
+
+      def create_method(converters, table_context)
+        proc do |context: nil|
+          values = super(context: context)
+          values.map do |val|
+            converters.reduce(val) do |val, (_, converter)|
+              converter.call(val, context, table_context)
+            end
+          end
+        end
+      end
+    end
+
+    class ColumnConverter < 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

@@ -0,0 +1,47 @@
+# 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 = {}
+        methods[:header] = create_method(@header_builder) if @header_builder
+        methods[:row] = create_method(@row_builder) if @row_builder
+
+        return if methods.empty?
+
+        table.extend ContextBuilder.new(methods)
+      end
+
+      private
+
+      def create_method(builder)
+        proc do |context: nil|
+          super(context: builder.call(context))
+        end
+      end
+    end
+
+    class ContextBuilder < Module
+      def initialize(methods)
+        methods.each do |name, method|
+          define_method(name, &method)
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/definition.rb

@@ -3,17 +3,6 @@
 module TableStructure
   module Schema
     class Definition
-      RESULT_BUILDERS = {
-        to_hash: {
-          callable: lambda { |values, keys, *|
-            keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
-          },
-          options: {
-            enabled_result_types: [:hash]
-          }
-        }
-      }.freeze
-
       attr_reader :options
 
       def initialize(
@@ -25,38 +14,30 @@ module TableStructure
         context,
         options
       )
-        table_context_builder = context_builders.delete(:table)
-        context = table_context_builder.call(context) if table_context_builder
-
         @name = name
-        @columns = create_columns(name, column_definitions, context, options)
-        @header_context_builder = context_builders[:header]
-        @row_context_builder = context_builders[:row]
-        @header_column_converters = select_column_converters(:header, column_converters)
-        @row_column_converters = select_column_converters(:row, column_converters)
-        @result_builders = result_builders
-        @context = context
+        @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(result_type: :array, **options)
+      def create_table(**options)
         options = @options.merge(options)
 
-        header_column_converters =
-          optional_header_column_converters(options).merge(@header_column_converters)
-
-        result_builders = select_result_builders(result_type)
-
-        Table.new(
+        table = Table.new(
           @columns,
-          @header_context_builder,
-          @row_context_builder,
-          header_column_converters,
-          @row_column_converters,
-          result_builders,
           @context,
           options
         )
+
+        @context_builders.extend_methods_for(table)
+        @column_converters.extend_methods_for(table)
+        @result_builders.extend_methods_for(table)
+
+        table
       end
 
       private
@@ -65,38 +46,13 @@ module TableStructure
         Compiler
           .new(name, definitions, options)
           .compile(context)
-          .map { |definition| Column.create(definition, options) }
-      end
-
-      def select_column_converters(method, column_converters)
-        column_converters
-          .select { |_k, v| v[:options][method] }
-          .map { |k, v| [k, v[:callable]] }
-          .to_h
-      end
-
-      def optional_header_column_converters(options)
-        column_converters = {}
-        if options[:name_prefix]
-          column_converters[:_prepend_prefix] = lambda { |val, *|
-            val.nil? ? val : "#{options[:name_prefix]}#{val}"
-          }
-        end
-        if options[:name_suffix]
-          column_converters[:_append_suffix] = lambda { |val, *|
-            val.nil? ? val : "#{val}#{options[:name_suffix]}"
-          }
-        end
-
-        column_converters
-      end
-
-      def select_result_builders(result_type)
-        RESULT_BUILDERS
-          .merge(@result_builders)
-          .select { |_k, v| v[:options][:enabled_result_types].include?(result_type) }
-          .map { |k, v| [k, v[:callable]] }
-          .to_h
+          .map do |definition|
+            if definition.is_a?(Hash)
+              Column::Attrs.new(definition)
+            else
+              Column::Schema.new(definition)
+            end
+          end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module TableStructure
           @definitions
             .map { |definition| Utils.evaluate_callable(definition, context) }
             .map.with_index do |definition, i|
-              validator = Validator.new(@name, i, @options)
+              validator = Validator.new(@name, i)
 
               [definition]
                 .flatten

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

@@ -6,10 +6,9 @@ module TableStructure
       class Validator
         DEFAULT_SIZE = 1
 
-        def initialize(name, index, options)
+        def initialize(name, index)
           @name = name
           @index = index
-          @options = options
         end
 
         def validate(name:, key:, size:, **)

data/lib/table_structure/schema/result_builders.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class ResultBuilders
+      DEFAULT_BUILDERS = {
+        _to_hash_: {
+          callable: lambda { |values, keys, *|
+            keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
+          },
+          options: {
+            enabled_result_types: [:hash]
+          }
+        }
+      }.freeze
+
+      def initialize(builders)
+        @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])
+
+        methods = {}
+        unless builders.empty?
+          methods[:header] = create_method(builders, table_keys, table_context)
+          methods[:row] = create_method(builders, table_keys, table_context)
+        end
+
+        return if methods.empty?
+
+        table.extend ResultBuilder.new(methods)
+      end
+
+      private
+
+      def select_builders(result_type)
+        DEFAULT_BUILDERS
+          .merge(@builders)
+          .select { |_k, v| v[:options][:enabled_result_types].include?(result_type) }
+          .map { |k, v| [k, v[:callable]] }
+          .to_h
+      end
+
+      def create_method(builders, table_keys, table_context)
+        proc do |context: nil|
+          values = super(context: context)
+          builders
+            .reduce(values) do |vals, (_, builder)|
+              builder.call(vals, table_keys, context, table_context)
+            end
+        end
+      end
+    end
+
+    class ResultBuilder < 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

@@ -3,55 +3,18 @@
 module TableStructure
   module Schema
     class Table
-      # TODO: Remove following `attr_reader`.
-      attr_reader :header_column_converters, :row_column_converters, :result_builders
+      DEFAULT_OPTIONS = {
+        result_type: :array
+      }.freeze
 
       def initialize(
         columns,
-        header_context_builder,
-        row_context_builder,
-        header_column_converters,
-        row_column_converters,
-        result_builders,
         context,
         options
       )
         @columns = columns
-        @header_column_converters = header_column_converters
-        @row_column_converters = row_column_converters
-        @result_builders = result_builders
         @context = context
-        @options = options
-
-        if header_context_builder || row_context_builder
-          singleton_class.include ContextBuilder.new(
-            [
-              { method: :header, callable: header_context_builder },
-              { method: :row, callable: row_context_builder }
-            ]
-          )
-        end
-
-        if !header_column_converters.empty? || !row_column_converters.empty?
-          singleton_class.include ColumnConverter.new(
-            [
-              { method: :header, callables: header_column_converters },
-              { method: :row, callables: row_column_converters }
-            ],
-            context: context
-          )
-        end
-
-        unless result_builders.empty?
-          singleton_class.include ResultBuilder.new(
-            [
-              { method: :header, callables: result_builders },
-              { method: :row, callables: result_builders }
-            ],
-            keys: keys,
-            context: context
-          )
-        end
+        @options = DEFAULT_OPTIONS.merge(options)
       end
 
       def header(context: nil)

data/lib/table_structure/version.rb

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

data/lib/table_structure/writer.rb

@@ -5,7 +5,6 @@ module TableStructure
     DEFAULT_OPTIONS = {
       header_omitted: false,
       header_context: nil,
-      result_type: :array,
       method: :<<
     }.freeze
 
@@ -38,7 +37,7 @@ module TableStructure
       if items.respond_to?(:each)
         items
       elsif items.respond_to?(:call)
-        warn "[TableStructure] Use `Enumerator` instead of `lambda` to wrap items. `lambda` has been deprecated. #{items}"
+        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, 'Items is not enumerable.'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.12
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-04 00:00:00.000000000 Z
+date: 2019-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,9 +74,10 @@ files:
 - lib/table_structure/csv/writer.rb
 - lib/table_structure/iterator.rb
 - lib/table_structure/schema.rb
-- lib/table_structure/schema/column.rb
 - lib/table_structure/schema/column/attrs.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
@@ -86,11 +87,9 @@ files:
 - lib/table_structure/schema/dsl/context_builder.rb
 - lib/table_structure/schema/dsl/option.rb
 - lib/table_structure/schema/dsl/result_builder.rb
+- lib/table_structure/schema/result_builders.rb
 - lib/table_structure/schema/table.rb
-- lib/table_structure/schema/table/column_converter.rb
-- lib/table_structure/schema/table/context_builder.rb
 - lib/table_structure/schema/table/key_decorator.rb
-- lib/table_structure/schema/table/result_builder.rb
 - lib/table_structure/schema/utils.rb
 - lib/table_structure/version.rb
 - lib/table_structure/writer.rb

data/lib/table_structure/schema/column.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Column
-      def self.create(definition, options)
-        if definition.is_a?(Hash)
-          Attrs.new(definition, options)
-        else
-          Schema.new(definition)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Table
-      class ColumnConverter < Module
-        def initialize(overrides, context: nil)
-          table_context = context
-          overrides
-            .reject { |callables:, **| callables.nil? || callables.empty? }
-            .each do |method:, callables:|
-              define_method(method) do |context: nil|
-                values = super(context: context)
-                values.map do |val|
-                  callables.reduce(val) do |val, (_, callable)|
-                    callable.call(val, context, table_context)
-                  end
-                end
-              end
-            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Table
-      class ContextBuilder < Module
-        def initialize(overrides)
-          overrides
-            .reject { |callable:, **| callable.nil? }
-            .each do |method:, callable:|
-              define_method(method) do |context: nil|
-                super(context: callable.call(context))
-              end
-            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class Table
-      class ResultBuilder < Module
-        def initialize(overrides, keys:, context: nil)
-          table_context = context
-          overrides
-            .reject { |callables:, **| callables.nil? || callables.empty? }
-            .each do |method:, callables:|
-              define_method(method) do |context: nil|
-                values = super(context: context)
-                callables
-                  .reduce(values) do |vals, (_, callable)|
-                    callable.call(vals, keys, context, table_context)
-                  end
-              end
-            end
-        end
-      end
-    end
-  end
-end