table_structure 0.3.22 → 0.4.3

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 callable.', @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/column_definition.rb

@@ -5,12 +5,22 @@ module TableStructure
     module DSL
       module ColumnDefinition
         def column(definition)
+          unless definition.is_a?(Hash)
+            warn "[TableStructure] Use `columns` instead of `column`.", uplevel: 1
+          end
           column_definitions << definition
           nil
         end
 
-        def columns(definition)
-          column(definition)
+        def columns(definition = nil, &block)
+          if definition.is_a?(Hash)
+            warn "[TableStructure] Use `column` instead of `columns`.", uplevel: 1
+          end
+          if Utils.callable?(definition)
+            warn "[TableStructure] Use `block` instead of `lambda` or `proc`.", uplevel: 1
+          end
+          column_definitions << (block || definition)
+          nil
         end
 
         def column_definitions

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

@@ -5,17 +5,8 @@ module TableStructure
     module DSL
       module ContextBuilder
         # TODO: Change definition style
-        def context_builder(name, callable = nil, &block)
-          if callable
-            warn "[TableStructure] Use `block` instead of #{callable}."
-          end
-
-          block ||= callable
-
-          context_builders[name] =
-            ::TableStructure::Schema::Definition::ContextBuilder.new(
-              &block
-            )
+        def context_builder(name, &block)
+          context_builders[name] = block
           nil
         end
 

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

@@ -6,19 +6,12 @@ module TableStructure
       module RowBuilder
         def row_builder(
           name,
-          callable = nil,
           enabled_row_types: %i[array hash],
           &block
         )
-          if callable
-            warn "[TableStructure] Use `block` instead of #{callable}."
-          end
-
-          block ||= callable
-
           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,26 @@
+# 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 { |context| @builders[:header].call(context) }
+      end
+
+      def create_data_builder
+        return unless @schema.contain_value_callable?
+        return unless @builders.key?(:row)
+
+        proc { |context| @builders[:row].call(context) }
+      end
+    end
+  end
+end

data/lib/table_structure/table.rb

@@ -2,71 +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
-
-    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/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.3.22'
+  VERSION = '0.4.3'
 end

data/lib/table_structure/writer.rb

@@ -4,28 +4,10 @@ module TableStructure
   class Writer
     def initialize(
       schema,
-      header: { context: nil },
+      header: { context: nil, step: nil },
       method: :<<,
-      row_type: :array,
-      **deprecated_options
+      row_type: :array
     )
-      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
-
       @schema = schema
       @options = {
         header: header,
@@ -38,51 +20,22 @@ module TableStructure
       items,
       to:,
       method: @options[:method],
-      **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
-
       output = Output.new(to, method: method)
 
       Iterator
-        .new(@schema, header: header, row_type: row_type)
+        .new(
+          @schema,
+          header: @options[:header],
+          row_type: @options[:row_type]
+        )
         .iterate(items, &block)
         .each { |row| output.write(row) }
 
       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.3.22
+  version: 0.4.3
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2020-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,31 +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/option.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/iterator.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