table_structure 0.3.16 → 0.3.17

data/lib/table_structure/schema/row_builders.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class RowBuilders
+      DEFAULT_BUILDERS = {
+        _to_hash_: ::TableStructure::Schema::Definition::RowBuilder.new(
+          lambda { |values, keys, *|
+            keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
+          },
+          enabled_row_types: [:hash]
+        )
+      }.freeze
+
+      def initialize(builders)
+        @builders = builders
+      end
+
+      def extend_methods_for(table, row_type: :array)
+        builders =
+          DEFAULT_BUILDERS
+          .merge(@builders)
+          .select { |_k, v| v.enabled?(row_type) }
+
+        return if builders.empty?
+
+        table_context = table.instance_variable_get(:@context)
+        table_keys = table.send(:keys)
+
+        table.extend ResultBuildable.new(
+          header: create_method(builders, table_keys, table_context),
+          data: create_method(builders, table_keys, table_context)
+        )
+      end
+
+      private
+
+      def create_method(builders, table_keys, table_context)
+        return if builders.empty?
+
+        proc do |context: nil|
+          builders
+            .reduce(super(context: context)) do |vals, (_, builder)|
+              builder.call(vals, table_keys, context, table_context)
+            end
+        end
+      end
+    end
+
+    class ResultBuildable < Module
+      def initialize(methods)
+        methods.each do |name, method|
+          define_method(name, &method)
+        end
+      end
+    end
+  end
+end

data/lib/table_structure/schema/table.rb

@@ -4,50 +4,58 @@ module TableStructure
   module Schema
     class Table
       def initialize(
-        columns,
-        context,
-        options
+        columns:,
+        context:,
+        keys_generator:
       )
         @columns = columns
         @context = context
-        @options = options
+        @keys_generator = keys_generator
       end
 
       def header(context: nil)
-        values(:names, context)
+        row_values(:names, context)
       end
 
       def row(context: nil)
-        values(:values, context)
+        warn '[TableStructure] `TableStructure::Schema::Table#row(context:)` has been deprecated. Use `TableStructure::Schema::Table#body(items)` instead.'
+        data(context: context)
       end
 
-      def rows(items)
+      def body(items)
         Enumerator.new do |y|
-          items.each { |item| y << row(context: item) }
+          items.each { |item| y << data(context: item) }
         end
       end
 
+      def rows(items)
+        warn '[TableStructure] `TableStructure::Schema::Table#rows(items)` has been deprecated. Use `TableStructure::Schema::Table#body(items)` instead.'
+        body(items)
+      end
+
       private
 
+      def data(context: nil)
+        row_values(:values, context)
+      end
+
       def keys
-        @keys ||= begin
-          keys = @columns.map(&:keys).flatten
-          KeyDecorator.new(
-            prefix: @options[:key_prefix],
-            suffix: @options[:key_suffix]
-          ).decorate(keys)
-        end
+        @keys ||= @keys_generator.generate(@columns.map(&:keys).flatten)
       end
 
       def size
         @size ||= @columns.map(&:size).reduce(0, &:+)
       end
 
-      def values(method, context)
+      def row_values(method, context)
         @columns
           .map { |column| column.send(method, context, @context) }
           .flatten
       end
+
+      def contain_callable?(attribute)
+        @columns.any? { |column| column.contain_callable?(attribute) }
+      end
     end
   end
 end

data/lib/table_structure/schema/utils.rb

@@ -4,7 +4,11 @@ module TableStructure
   module Schema
     module Utils
       def self.evaluate_callable(val, *params)
-        val.respond_to?(:call) ? val.call(*params) : val
+        callable?(val) ? val.call(*params) : val
+      end
+
+      def self.callable?(val)
+        val.respond_to?(:call)
       end
 
       def self.schema_class?(val)

data/lib/table_structure/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TableStructure
-  VERSION = '0.3.16'
+  VERSION = '0.3.17'
 end

data/lib/table_structure/writer.rb

@@ -23,7 +23,7 @@ module TableStructure
           header = yield header if block_given?
           to.send(options[:method], header)
         end
-        table.rows(enumerize(items)).each do |row|
+        table.body(enumerize(items)).each do |row|
           row = yield row if block_given?
           to.send(options[:method], row)
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.16
+  version: 0.3.17
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-31 00:00:00.000000000 Z
+date: 2020-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,22 +75,27 @@ files:
 - lib/table_structure/iterator.rb
 - lib/table_structure/schema.rb
 - lib/table_structure/schema/class_methods.rb
-- lib/table_structure/schema/column/attrs.rb
-- lib/table_structure/schema/column/definition/compiler.rb
-- lib/table_structure/schema/column/definition/error.rb
-- lib/table_structure/schema/column/definition/validator.rb
-- lib/table_structure/schema/column/factory.rb
-- lib/table_structure/schema/column/schema.rb
 - lib/table_structure/schema/column_converters.rb
+- lib/table_structure/schema/columns/attributes.rb
+- lib/table_structure/schema/columns/schema.rb
 - lib/table_structure/schema/context_builders.rb
+- lib/table_structure/schema/definition/column_converter.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_definition.rb
 - lib/table_structure/schema/dsl/context_builder.rb
 - lib/table_structure/schema/dsl/option.rb
-- lib/table_structure/schema/dsl/result_builder.rb
-- lib/table_structure/schema/result_builders.rb
+- lib/table_structure/schema/dsl/row_builder.rb
+- lib/table_structure/schema/keys_generator.rb
+- lib/table_structure/schema/row_builders.rb
 - lib/table_structure/schema/table.rb
-- lib/table_structure/schema/table/key_decorator.rb
 - lib/table_structure/schema/utils.rb
 - lib/table_structure/version.rb
 - lib/table_structure/writer.rb

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Column
-      module Definition
-        class Compiler
-          DEFAULT_ATTRS = {
-            name: nil,
-            key: nil,
-            value: nil,
-            size: nil,
-            omitted: false
-          }.freeze
-
-          DEFAULT_SIZE = 1
-
-          def initialize(name, definitions, options)
-            @name = name
-            @definitions = definitions
-            @options = options
-          end
-
-          def compile(context = nil)
-            @definitions
-              .map { |definition| Utils.evaluate_callable(definition, context) }
-              .map.with_index do |definition, i|
-                validator = Validator.new(@name, i)
-
-                [definition]
-                  .flatten
-                  .map do |definition|
-                    if definition.is_a?(Hash)
-                      definition = DEFAULT_ATTRS.merge(definition)
-                      omitted = definition.delete(:omitted)
-                      next if Utils.evaluate_callable(omitted, context)
-
-                      definition = evaluate_attrs(definition, context)
-                      validator.validate(**definition)
-                      definition[:size] = determine_size(**definition)
-                      definition
-                    elsif Utils.schema_instance?(definition)
-                      definition
-                    elsif Utils.schema_class?(definition)
-                      definition.new(context: context)
-                    elsif definition.nil? && @options[:nil_definitions_ignored]
-                      next
-                    else
-                      raise Error.new('Invalid definition.', @name, i)
-                    end
-                  end
-              end
-              .flatten
-              .compact
-          end
-
-          private
-
-          def evaluate_attrs(definition, context)
-            size = Utils.evaluate_callable(definition[:size], context)
-            definition.merge(size: size)
-          end
-
-          def determine_size(name:, key:, size:, **)
-            return size if size
-
-            [calculate_size(name), calculate_size(key)].max
-          end
-
-          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/column/factory.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module Column
-      module Factory
-        def self.create(name, definitions, context, options)
-          Definition::Compiler
-            .new(name, definitions, options)
-            .compile(context)
-            .map do |definition|
-              if definition.is_a?(Hash)
-                Attrs.new(**definition)
-              else
-                Schema.new(definition)
-              end
-            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    module DSL
-      module ResultBuilder
-        DEFAULT_OPTIONS = {
-          enabled_result_types: %i[array hash]
-        }.freeze
-
-        def result_builder(name, callable, **options)
-          options = DEFAULT_OPTIONS.merge(options)
-          options[:enabled_result_types] = [options[:enabled_result_types]].flatten
-          result_builders[name] = {
-            callable: callable,
-            options: options
-          }
-          nil
-        end
-
-        def result_builders
-          @__result_builders__ ||= {}
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/result_builders.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module TableStructure
-  module Schema
-    class ResultBuilders
-      DEFAULT_BUILDERS = {
-        _to_hash_: {
-          callable: lambda { |values, keys, *|
-            keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
-          },
-          options: {
-            enabled_result_types: [:hash]
-          }
-        }
-      }.freeze
-
-      def initialize(builders)
-        @builders = builders
-      end
-
-      def extend_methods_for(table, result_type: :array)
-        builders = select_builders(result_type)
-
-        methods = {}
-        unless builders.empty?
-          table_context = table.instance_variable_get(:@context)
-          table_keys = table.send(:keys)
-
-          methods[:header] = create_method(builders, table_keys, table_context)
-          methods[:row] = create_method(builders, table_keys, table_context)
-        end
-
-        return if methods.empty?
-
-        table.extend ResultBuilder.new(methods)
-      end
-
-      private
-
-      def select_builders(result_type)
-        DEFAULT_BUILDERS
-          .merge(@builders)
-          .select { |_k, v| v[:options][:enabled_result_types].include?(result_type) }
-          .map { |k, v| [k, v[:callable]] }
-          .to_h
-      end
-
-      def create_method(builders, table_keys, table_context)
-        proc do |context: nil|
-          values = super(context: context)
-          builders
-            .reduce(values) do |vals, (_, builder)|
-              builder.call(vals, table_keys, context, table_context)
-            end
-        end
-      end
-    end
-
-    class ResultBuilder < Module
-      def initialize(methods)
-        methods.each do |name, method|
-          define_method(name, &method)
-        end
-      end
-    end
-  end
-end

data/lib/table_structure/schema/table/key_decorator.rb

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