table_structure 0.3.21 → 0.4.2

data/lib/table_structure/iterator.rb

@@ -2,106 +2,65 @@
 
 module TableStructure
   class Iterator
-    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
+    class HeaderOptions
+      attr_reader :enabled, :context, :step
+      alias enabled? enabled
+
+      def initialize(options)
+        @enabled = !!options
+        if options.is_a?(Hash)
+          @context = options[:context]
+          @step = options[:step]
+        end
+
+        validate
       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
+      private
 
-      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]
+      def validate
+        if @step
+          raise ::TableStructure::Error, ':step must be numeric.' unless @step.is_a?(Numeric)
+          raise ::TableStructure::Error, ':step must be positive number.' unless @step.positive?
+        end
       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
+    def initialize(
+      schema,
+      header: { context: nil, step: nil },
+      row_type: :array
     )
-      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)
+      @table = Table.new(schema, row_type: row_type)
+      @header_options = HeaderOptions.new(header)
+    end
 
-      if block_given?
-        enum =
-          enum
-          .lazy
-          .map { |row| block.call(row) }
+    def iterate(items, &block)
+      raise ::TableStructure::Error, "Must be enumerable. #{items}" unless items.respond_to?(:each)
+
+      table_enum = ::Enumerator.new do |y|
+        body_enum = @table.body(items)
+
+        if @header_options.enabled?
+          header_row = @table.header(context: @header_options.context)
+          y << header_row
+
+          if @header_options.step
+            loop do
+              @header_options.step.times { y << body_enum.next }
+              y << header_row
+            end
+          else
+            body_enum.each { |row| y << row }
+          end
+        else
+          body_enum.each { |row| y << row }
+        end
       end
 
-      enum
-    end
-
-    private
+      table_enum = table_enum.lazy.map(&block) if block_given?
 
-    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
+      table_enum
     end
   end
 end

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

@@ -36,9 +36,9 @@ module TableStructure
             .map(&:context_builders)
             .reduce({}, &:merge!)
 
-          @__column_converters__ =
+          @__column_builders__ =
             schema_classes
-            .map(&:column_converters)
+            .map(&:column_builders)
             .reduce({}, &:merge!)
 
           @__row_builders__ =

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