table_structure 0.3.16 → 0.3.17

data/lib/table_structure/schema/{column/attrs.rb → columns/attributes.rb}

@@ -2,8 +2,8 @@
 
 module TableStructure
   module Schema
-    module Column
-      class Attrs
+    module Columns
+      class Attributes
         attr_reader :keys, :size
 
         def initialize(name:, key:, value:, size:)
@@ -23,6 +23,11 @@ module TableStructure
           optimize_size(value, @size)
         end
 
+        def contain_callable?(attribute)
+          val = instance_variable_get("@#{attribute}")
+          Utils.callable?(val)
+        end
+
         private
 
         def optimize_size(value, expected_size)

data/lib/table_structure/schema/{column → columns}/schema.rb

@@ -2,10 +2,8 @@
 
 module TableStructure
   module Schema
-    module Column
+    module Columns
       class Schema
-        attr_reader :table
-
         def initialize(schema)
           @table = schema.create_table
         end
@@ -19,12 +17,16 @@ module TableStructure
         end
 
         def values(row_context, _table_context)
-          @table.row(context: row_context)
+          @table.send(:data, context: row_context)
         end
 
         def size
           @table.send(:size)
         end
+
+        def contain_callable?(attribute)
+          @table.send(:contain_callable?, attribute)
+        end
       end
     end
   end

data/lib/table_structure/schema/context_builders.rb

@@ -19,24 +19,32 @@ module TableStructure
 
       def extend_methods_for(table)
         methods = {}
-        methods[:header] = create_method(@header_builder) if @header_builder
-        methods[:row] = create_method(@row_builder) if @row_builder
 
+        if table.send(:contain_callable?, :name)
+          methods[:header] = create_method(@header_builder)
+        end
+        if table.send(:contain_callable?, :value)
+          methods[:data] = create_method(@row_builder)
+        end
+
+        methods.reject! { |_k, v| v.nil? }
         return if methods.empty?
 
-        table.extend ContextBuilder.new(methods)
+        table.extend ContextBuildable.new(methods)
       end
 
       private
 
       def create_method(builder)
+        return if builder.nil?
+
         proc do |context: nil|
           super(context: builder.call(context))
         end
       end
     end
 
-    class ContextBuilder < Module
+    class ContextBuildable < Module
       def initialize(methods)
         methods.each do |name, method|
           define_method(name, &method)

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      class ColumnConverter
+        extend Forwardable
+
+        def_delegator :@callable, :call
+
+        def initialize(
+          callable,
+          header: true,
+          body: true
+        )
+          @callable = callable
+          @applicable_to_header = header
+          @applicable_to_body = body
+        end
+
+        def applicable_to_header?
+          !!@applicable_to_header
+        end
+
+        def applicable_to_body?
+          !!@applicable_to_body
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/definition/columns/attributes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      module Columns
+        class Attributes
+          DEFAULT_SIZE = 1
+
+          def initialize(
+            name: nil,
+            key: nil,
+            value: nil,
+            size: nil,
+            omitted: false,
+            validator:
+          )
+            @name = name
+            @key = key
+            @value = value
+            @size = size
+            @omitted = omitted
+            @validator = validator
+          end
+
+          def omitted?(context:)
+            Utils.evaluate_callable(@omitted, context)
+          end
+
+          def compile(context:)
+            size = Utils.evaluate_callable(@size, context)
+            @validator.validate(name: @name, key: @key, size: size)
+            size ||= [calculate_size(@name), calculate_size(@key)].max
+            ::TableStructure::Schema::Columns::Attributes.new(
+              name: @name,
+              key: @key,
+              value: @value,
+              size: size
+            )
+          end
+
+          private
+
+          def calculate_size(val)
+            if val.is_a?(Array)
+              return val.empty? ? DEFAULT_SIZE : val.size
+            end
+
+            DEFAULT_SIZE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      module Columns
+        class Compiler
+          def initialize(schema_name, definitions, options)
+            @schema_name = schema_name
+            @definitions = definitions
+            @options = options
+          end
+
+          def compile(context = nil)
+            @definitions
+              .map { |definition| Utils.evaluate_callable(definition, context) }
+              .map.with_index do |definitions, i|
+                validator = Validator.new(@schema_name, i)
+
+                [definitions]
+                  .flatten
+                  .map do |definition|
+                    if definition.is_a?(Hash)
+                      Attributes.new(**definition, validator: validator)
+                    elsif Utils.schema_instance?(definition)
+                      SchemaInstance.new(definition)
+                    elsif Utils.schema_class?(definition)
+                      SchemaClass.new(definition)
+                    elsif definition.nil? && @options[:nil_definitions_ignored]
+                      next
+                    else
+                      raise Error.new('Invalid definition.', @schema_name, i)
+                    end
+                  end
+              end
+              .flatten
+              .compact
+              .reject { |column| column.omitted?(context: context) }
+              .map { |column| column.compile(context: context) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/{column/definition → definition/columns}/error.rb

@@ -2,8 +2,8 @@
 
 module TableStructure
   module Schema
-    module Column
-      module Definition
+    module Definition
+      module Columns
         class Error < ::TableStructure::Error
           attr_reader :schema_name, :definition_index
 

data/lib/table_structure/schema/definition/columns/schema_class.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      module Columns
+        class SchemaClass
+          def initialize(definition)
+            @definition = definition
+          end
+
+          def omitted?(**)
+            false
+          end
+
+          def compile(context:)
+            instance = @definition.new(context: context)
+            ::TableStructure::Schema::Columns::Schema.new(instance)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/definition/columns/schema_instance.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      module Columns
+        class SchemaInstance
+          def initialize(definition)
+            @definition = definition
+          end
+
+          def omitted?(**)
+            false
+          end
+
+          def compile(**)
+            ::TableStructure::Schema::Columns::Schema.new(@definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/{column/definition → definition/columns}/validator.rb

@@ -2,8 +2,8 @@
 
 module TableStructure
   module Schema
-    module Column
-      module Definition
+    module Definition
+      module Columns
         class Validator
           DEFAULT_SIZE = 1
 

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      class ContextBuilder
+        extend Forwardable
+
+        def_delegator :@callable, :call
+
+        def initialize(callable)
+          @callable = callable
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module Definition
+      class RowBuilder
+        extend Forwardable
+
+        def_delegator :@callable, :call
+
+        def initialize(
+          callable,
+          enabled_row_types: %i[array hash]
+        )
+          @callable = callable
+          @enabled_row_types = [enabled_row_types].flatten
+        end
+
+        def enabled?(row_type)
+          @enabled_row_types.include?(row_type)
+        end
+      end
+    end
+  end
+end

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

@@ -4,17 +4,24 @@ module TableStructure
   module Schema
     module DSL
       module ColumnConverter
-        DEFAULT_OPTIONS = {
+        def column_converter(
+          name,
+          callable,
           header: true,
-          row: true
-        }.freeze
+          body: true,
+          **deprecated_options
+        )
+          if deprecated_options.key?(:row)
+            warn '[TableStructure] `:row` option has been deprecated. Use `:body` option instead.'
+            body = deprecated_options[:row]
+          end
 
-        def column_converter(name, callable, **options)
-          options = DEFAULT_OPTIONS.merge(options)
-          column_converters[name] = {
-            callable: callable,
-            options: options
-          }
+          column_converters[name] =
+            ::TableStructure::Schema::Definition::ColumnConverter.new(
+              callable,
+              header: header,
+              body: body
+            )
           nil
         end
 

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

@@ -5,7 +5,10 @@ module TableStructure
     module DSL
       module ContextBuilder
         def context_builder(name, callable)
-          context_builders[name] = callable
+          context_builders[name] =
+            ::TableStructure::Schema::Definition::ContextBuilder.new(
+              callable
+            )
           nil
         end
 

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    module DSL
+      module RowBuilder
+        def row_builder(
+          name,
+          callable,
+          enabled_row_types: %i[array hash]
+        )
+          row_builders[name] =
+            ::TableStructure::Schema::Definition::RowBuilder.new(
+              callable,
+              enabled_row_types: enabled_row_types
+            )
+          nil
+        end
+
+        def row_builders
+          @__row_builders__ ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/keys_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class KeysGenerator
+      def initialize(prefix: nil, suffix: nil)
+        @prefix = prefix
+        @suffix = suffix
+      end
+
+      def generate(keys)
+        return keys unless has_any_options?
+
+        keys.map do |key|
+          next key unless key
+
+          decorated_key = "#{@prefix}#{key}#{@suffix}"
+          key.is_a?(Symbol) ? decorated_key.to_sym : decorated_key
+        end
+      end
+
+      private
+
+      def has_any_options?
+        @prefix || @suffix
+      end
+    end
+  end
+end