table_structure 0.3.21 → 0.4.2

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

@@ -4,11 +4,9 @@ module TableStructure
   module Schema
     module DSL
       module ContextBuilder
-        def context_builder(name, callable)
-          context_builders[name] =
-            ::TableStructure::Schema::Definition::ContextBuilder.new(
-              callable
-            )
+        # TODO: Change definition style
+        def context_builder(name, &block)
+          context_builders[name] = block
           nil
         end
 

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

@@ -6,13 +6,13 @@ module TableStructure
       module RowBuilder
         def row_builder(
           name,
-          callable,
-          enabled_row_types: %i[array hash]
+          enabled_row_types: %i[array hash],
+          &block
         )
           row_builders[name] =
-            ::TableStructure::Schema::Definition::RowBuilder.new(
-              callable,
-              enabled_row_types: enabled_row_types
+            ::TableStructure::Utils::TypedProc.new(
+              types: enabled_row_types,
+              &block
             )
           nil
         end

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,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.21'
+  VERSION = '0.4.2'
 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