table_structure 0.3.22 → 0.4.3

data/lib/table_structure/schema.rb

@@ -3,29 +3,25 @@
 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::Option)
       klass.extend(DSL::RowBuilder)
       klass.extend(ClassMethods)
     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(
@@ -36,96 +32,87 @@ module TableStructure
       key_prefix: nil,
       key_suffix: nil,
       nil_definitions_ignored: false,
-      **deprecated_options,
       &block
     )
-      if deprecated_options.key?(:row_type)
-        raise ::TableStructure::Error, 'Use :row_type option with Table, Writer or Iterator.'
-      end
+      schema_class = CompositeClass.new.compose(self.class)
+      schema_class.compose(Schema.create_class(&block)) if block
 
-      if deprecated_options.key?(:result_type)
-        raise ::TableStructure::Error, ':result_type option has been deprecated. Use :row_type option instead.'
-      end
-
-      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]
-
-      if block_given?
-        schema_classes << ::TableStructure::Schema.create_class(&block)
-      end
+      context_builders = schema_class.context_builders
 
-      @context_builders =
-        schema_classes
-        .map(&:context_builders)
-        .reduce({}, &:merge!)
-
-      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: options.delete(:name_prefix),
-            name_suffix: options.delete(:name_suffix)
-          )
-        )
+      @row_context_builder_factory = RowContextBuilderFactory.new(self, context_builders)
 
-      @key_converter = KeyConverter.new(
-        prefix: options.delete(:key_prefix),
-        suffix: options.delete(:key_suffix)
+      @column_builder_factory = ColumnBuilderFactory.new(
+        schema_class.column_builders,
+        context: @context,
+        name_prefix: name_prefix,
+        name_suffix: name_suffix
       )
 
-      @row_builders =
-        RowBuilder.prepend_default_builders(
-          schema_classes
-            .map(&:row_builders)
-            .reduce({}, &:merge!)
-        )
+      @keys_builder = KeysBuilder.new(
+        prefix: key_prefix,
+        suffix: key_suffix
+      )
+
+      @row_builders = schema_class.row_builders
 
       @columns =
         Definition::Columns::Compiler
         .new(
           name,
-          schema_classes.map(&:column_definitions).reduce([], &:concat),
-          { nil_definitions_ignored: options.delete(:nil_definitions_ignored) }
+          schema_class.column_definitions,
+          nil_definitions_ignored: nil_definitions_ignored
         )
         .compile(@context)
+    end
 
-      @options = options
+    def columns_keys
+      @columns_keys ||= @keys_builder.build(@columns.map(&:keys).flatten)
     end
 
-    def create_table(row_type: :array, **deprecated_options, &block)
-      warn '[TableStructure] `TableStructure::Schema#create_table` has been deprecated. Use `TableStructure::Table.new` instead.'
+    def columns_size
+      @columns.map(&:size).reduce(0, &:+)
+    end
 
-      options = @options.merge(deprecated_options)
+    def contain_name_callable?
+      @columns.any? { |column| column.name_callable? }
+    end
 
-      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
+    def contain_value_callable?
+      @columns.any? { |column| column.value_callable? }
+    end
 
-      ::TableStructure::Table.new(self, row_type: options[:row_type] || row_type, &block)
+    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 contain_callable?(attribute)
-      @columns.any? { |column| column.contain_callable?(attribute) }
+    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

@@ -4,13 +4,11 @@ module TableStructure
   module Schema
     module ClassMethods
       def +(other)
-        unless ::TableStructure::Schema::Utils.schema_class?(other)
-          raise ::TableStructure::Error, "Must be a schema class. #{other}"
-        end
+        raise ::TableStructure::Error, "Must be a schema class. [#{other}]" unless Utils.schema_class?(other)
 
         self_class = self
 
-        ::TableStructure::Schema.create_class do
+        Schema.create_class do
           columns self_class
           columns other
         end
@@ -18,33 +16,16 @@ module TableStructure
 
       def merge(*others)
         others.each do |other|
-          unless ::TableStructure::Schema::Utils.schema_class?(other)
-            raise ::TableStructure::Error, "Must be a schema class. #{other}"
-          end
+          raise ::TableStructure::Error, "Must be a schema class. [#{other}]" unless Utils.schema_class?(other)
         end
 
-        schema_classes = [self, *others]
-
-        ::TableStructure::Schema.create_class do
-          @__column_definitions__ =
-            schema_classes
-            .map(&:column_definitions)
-            .flatten
-
-          @__context_builders__ =
-            schema_classes
-            .map(&:context_builders)
-            .reduce({}, &:merge!)
-
-          @__column_converters__ =
-            schema_classes
-            .map(&:column_converters)
-            .reduce({}, &:merge!)
+        schema_class = CompositeClass.new.compose(self, *others)
 
-          @__row_builders__ =
-            schema_classes
-            .map(&:row_builders)
-            .reduce({}, &:merge!)
+        Schema.create_class do
+          @__column_definitions__ = schema_class.column_definitions
+          @__context_builders__ = schema_class.context_builders
+          @__column_builders__ = schema_class.column_builders
+          @__row_builders__ = schema_class.row_builders
         end
       end
     end

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)
+          .flatten
+      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)