table_structure 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edea213f708a84a4bfaf1a149a7c4fd9a78b2c50e36b72b951f6c0bc2b4d3a14
-  data.tar.gz: 71db859f76a5a55a33772d0764647afcfb0b6fa814705649d26c09f37f3ae35c
+  metadata.gz: d2a01593167aa1e2dd8324ca25696bc5a673214eb9659c5ca4643c62e3172cff
+  data.tar.gz: f374927b3fdb20eb93b3f0ff88344f9ba55fef1238ada8c8d6c577fc5b0d7484
 SHA512:
-  metadata.gz: 72abcf6d37f57322848493cd45e335276dc729524000007385d382dc0cb835fbf6ebe740c970e6de06bd4a78e45b4f63a1858f060bbbbbfc86396a9c2b57d088
-  data.tar.gz: 9332514abe32694295162c5349d5058e57c1bdf37a9c26eafb83e3bf18d9e01c88a128563f74193aece52fa0158adc6c2d2979fbd2663ad3b380aa17c4c3e03b
+  metadata.gz: 69931112fd4a46d250ef0ad1f43a67baebf408dcde70dcc15f153661871a14cb8d91bdec9258ef5ac351af86b40059f35b51ea0c65f1d5e9f4fad19f7529a09b
+  data.tar.gz: e615deb857dc78ab84ee643c5f43a629709917e949872a8147fa2625430f9a7a2872523080f3ebb5e31e29a5038cc9ab91123549cd97683c5726a547208d4f3b

data/CHANGELOG.md

@@ -1,7 +1,15 @@
+# 0.3.3
+Changes:
+- `TableStructure::Schema`
+  - Improve designs and performance. You can ignore the following changes unless you have been using the schema instance method directly.
+    - Add `TableStructure::Schema#create_table` method. It returns `TableStructure::Schema::Table` instance.
+    - Remove `TableStructure::Schema#header` method. Use `TableStructure::Schema::Table#header` method instead.
+    - Remove `TableStructure::Schema#row` method. Use `TableStructure::Schema::Table#row` method instead.
+
 # 0.3.2
 Changes:
-  - `TableStructure::Writer`
-    - When `result_type: :hash` option is specified and `column(s)` key of the schema is undefined, index number is used as the key.
+- `TableStructure::Writer`
+  - When `result_type: :hash` option is specified and `column(s)` key of the schema is undefined, index number is used as the key.
 
 # 0.3.1
 Changes:
@@ -15,7 +23,7 @@ Changes:
 # 0.3.0
 Changes:
 - `TableStructure::Schema`
-  - Add `:omitted` key for column(s) DSL.
+  - Add `:omitted` key for `column(s)` DSL.
   - Support nested schema.
   - Add following options for schema initialization:
     - `:key_prefix`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    table_structure (0.3.2)
+    table_structure (0.3.3)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -305,9 +305,10 @@ end
 You can also use only `TableStructure::Schema`.
 ```ruby
 schema = SampleTableSchema.new
-header = schema.header
+table = schema.create_table
+header = table.header
 items.each do |item|
-  row = schema.row(context: item)
+  row = table.row(context: item)
   ...
 end
 ```

data/lib/table_structure/schema/column/attrs.rb

@@ -4,7 +4,7 @@ module TableStructure
   module Schema
     module Column
       class Attrs
-        attr_reader :name, :key, :vlaue, :size
+        attr_reader :keys, :size
 
         def initialize(definition, options)
           @name = definition[:name]
@@ -19,14 +19,6 @@ module TableStructure
           optimize_size(name, @size)
         end
 
-        def key
-          if @options[:key_prefix] || @options[:key_suffix]
-            decorate_keys
-          else
-            @keys
-          end
-        end
-
         def value(row_context, table_context)
           value = Utils.evaluate_callable(@value, row_context, table_context)
           optimize_size(value, @size)
@@ -47,16 +39,6 @@ module TableStructure
             values
           end
         end
-
-        def decorate_keys
-          @keys.map do |key|
-            next key unless key
-
-            decorated_key = "#{@options[:key_prefix]}#{key}#{@options[:key_suffix]}"
-            decorated_key = decorated_key.to_sym if key.is_a?(Symbol)
-            decorated_key
-          end
-        end
       end
     end
   end

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

@@ -4,32 +4,26 @@ module TableStructure
   module Schema
     module Column
       class Schema
-        attr_reader :schema
+        attr_reader :table
 
         def initialize(schema)
-          @schema = schema
+          @table = schema.create_table
         end
 
         def name(header_context, _table_context)
-          @schema.header(context: header_context)
+          @table.header(context: header_context)
         end
 
-        def key
-          table.send(:keys)
+        def keys
+          @table.send(:keys)
         end
 
         def value(row_context, _table_context)
-          @schema.row(context: row_context)
+          @table.row(context: row_context)
         end
 
         def size
-          table.send(:size)
-        end
-
-        private
-
-        def table
-          @schema.instance_variable_get(:@table_structure_schema_table_)
+          @table.send(:size)
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module TableStructure
+  module Schema
+    class 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, @options)
+
+              [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)
+
+                    validator.validate(definition)
+                    definition[:size] = determine_size(definition)
+                    definition
+                  elsif Utils.schema_instance?(definition)
+                    definition
+                  elsif Utils.schema_class?(definition)
+                    definition.new(context: context)
+                  else
+                    raise Error.new('Invalid definition.', @name, i)
+                  end
+                end
+            end
+            .flatten
+            .compact
+        end
+
+        private
+
+        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

data/lib/table_structure/schema/definition.rb

@@ -3,66 +3,59 @@
 module TableStructure
   module Schema
     class Definition
-      DEFAULT_ATTRS = {
-        name: nil,
-        key: nil,
-        value: nil,
-        size: nil,
-        omitted: false
+      RESULT_BUILDERS = {
+        hash: lambda { |values, keys, *|
+          keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
+        }
       }.freeze
 
-      DEFAULT_SIZE = 1
+      attr_reader :columns, :options
+
+      def initialize(
+        name,
+        column_definitions,
+        context_builders,
+        column_converters,
+        result_builders,
+        context,
+        options
+      )
+        table_context_builder = context_builders.delete(:table)
+        context = table_context_builder.call(context) if table_context_builder
 
-      def initialize(name, definitions, options)
         @name = name
-        @definitions = definitions
+        @columns = create_columns(name, column_definitions, context, options)
+        @context_builders = context_builders
+        @column_converters = column_converters
+        @result_builders = result_builders
+        @context = context
         @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, @options)
-
-            [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)
-
-                  validator.validate(definition)
-                  definition[:size] = determine_size(definition)
-                  definition
-                elsif Utils.schema_instance?(definition)
-                  definition
-                elsif Utils.schema_class?(definition)
-                  definition.new(context: context)
-                else
-                  raise Error.new('Invalid definition.', @name, i)
-                end
-              end
-          end
-          .flatten
-          .compact
+      def create_table(result_type: :array, **options)
+        options = @options.merge(options)
+        result_builders =
+          RESULT_BUILDERS
+          .select { |k, _v| k == result_type }
+          .merge(@result_builders)
+
+        Table.new(
+          @columns,
+          @context_builders,
+          @column_converters,
+          result_builders,
+          @context,
+          options
+        )
       end
 
       private
 
-      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
+      def create_columns(name, definitions, context, options)
+        Compiler
+          .new(name, definitions, options)
+          .compile(context)
+          .map { |definition| Column.create(definition, options) }
       end
     end
   end

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

@@ -10,7 +10,7 @@ module TableStructure
         end
 
         def context_builders
-          @table_structure_schema_context_builders__ ||= Hash.new(->(val) { val })
+          @table_structure_schema_context_builders__ ||= {}
         end
       end
     end

data/lib/table_structure/schema/table.rb

@@ -3,49 +3,67 @@
 module TableStructure
   module Schema
     class Table
-      RESULT_BUILDERS = {
-        hash: lambda { |values, keys, *|
-          keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
-        }
-      }.freeze
+      attr_reader :column_converters, :result_builders
 
-      attr_reader :columns, :column_converters, :result_builders, :options
-
-      def initialize(name, column_definitions, column_converters, result_builders, context, options)
-        @name = name
-        @columns = build_columns(name, column_definitions, context, options)
+      def initialize(
+        columns,
+        context_builders,
+        column_converters,
+        result_builders,
+        context,
+        options
+      )
+        @columns = columns
+        @header_context_builder = context_builders[:header]
+        @row_context_builder = context_builders[:row]
         @column_converters = column_converters
         @result_builders = result_builders
         @context = context
         @options = options
       end
 
-      def header_values(context, result_type = nil) # TODO
-        values(:name, result_type, context)
+      def header(context: nil)
+        if @header_context_builder
+          context = @header_context_builder.call(context)
+        end
+        values(:name, context)
       end
 
-      def row_values(context, result_type = nil) # TODO
-        values(:value, result_type, context)
+      def row(context: nil)
+        context = @row_context_builder.call(context) if @row_context_builder
+        values(:value, context)
       end
 
+      private
+
       def keys
-        @keys ||= @columns.map(&:key).flatten
+        @keys ||= obtain_keys
       end
 
-      def size
-        @size ||= @columns.map(&:size).reduce(0) { |memo, size| memo + size }
+      def obtain_keys
+        keys = @columns.map(&:keys).flatten
+        has_key_options? ? decorate_keys(keys) : keys
       end
 
-      private
+      def has_key_options?
+        @options[:key_prefix] || @options[:key_suffix]
+      end
+
+      def decorate_keys(keys)
+        keys.map do |key|
+          next key unless key
+
+          decorated_key = "#{@options[:key_prefix]}#{key}#{@options[:key_suffix]}"
+          decorated_key = decorated_key.to_sym if key.is_a?(Symbol)
+          decorated_key
+        end
+      end
 
-      def build_columns(name, definitions, context, options)
-        Definition
-          .new(name, definitions, options)
-          .compile(context)
-          .map { |definition| Column.create(definition, options) }
+      def size
+        @size ||= @columns.map(&:size).reduce(0) { |memo, size| memo + size }
       end
 
-      def values(method, result_type, context)
+      def values(method, context)
         columns =
           @columns
           .map { |column| column.send(method, context, @context) }
@@ -56,9 +74,7 @@ module TableStructure
             end
           end
 
-        RESULT_BUILDERS
-          .select { |k, _v| k == result_type }
-          .merge(@result_builders)
+        @result_builders
           .reduce(columns) do |columns, (_, result_builder)|
             result_builder.call(columns, keys, context, @context)
           end

data/lib/table_structure/schema.rb

@@ -17,15 +17,16 @@ module TableStructure
     }.freeze
 
     def initialize(context: nil, name: self.class.name, **options)
-      column_definitions = self.class.column_definitions
-      column_converters = self.class.column_converters
-      result_builders = self.class.result_builders
-      context = self.class.context_builders[:table].call(context)
+      column_definitions = [].concat(self.class.column_definitions)
+      context_builders = {}.merge!(self.class.context_builders)
+      column_converters = {}.merge!(self.class.column_converters)
+      result_builders = {}.merge!(self.class.result_builders)
       options = DEFAULT_OPTIONS.merge(self.class.options).merge(options)
-      @table_structure_schema_table_ =
-        Table.new(
+      @table_structure_schema_definition_ =
+        Definition.new(
           name,
           column_definitions,
+          context_builders,
           column_converters,
           result_builders,
           context,
@@ -33,26 +34,10 @@ module TableStructure
         )
     end
 
-    def header(context: nil, result_type: nil)
-      # TODO
-      result_type ||= @table_structure_schema_table_.options[:result_type]
-      context = self.class.context_builders[:header].call(context)
-      @table_structure_schema_table_.header_values(context, result_type)
-    end
-
-    def row(context: nil, result_type: nil)
-      # TODO
-      result_type ||= @table_structure_schema_table_.options[:result_type]
-      context = self.class.context_builders[:row].call(context)
-      @table_structure_schema_table_.row_values(context, result_type)
-    end
-
-    def column_converters
-      @table_structure_schema_table_.column_converters
-    end
-
-    def result_builders
-      @table_structure_schema_table_.result_builders
+    def create_table(result_type: nil, **options)
+      options = @table_structure_schema_definition_.options.merge(options)
+      result_type ||= options[:result_type] # TODO: remove
+      @table_structure_schema_definition_.create_table(result_type: result_type, **options)
     end
   end
 end

data/lib/table_structure/version.rb

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

data/lib/table_structure/writer.rb

@@ -16,19 +16,16 @@ module TableStructure
 
     def write(items, to:, **options)
       options = @options.merge(options)
+      table = @schema.create_table(options)
       unless options[:header_omitted]
-        header = @schema.header(
-          context: options[:header_context],
-          result_type: options[:result_type]
+        header = table.header(
+          context: options[:header_context]
         )
         header = yield header if block_given?
         to.send(options[:method], header)
       end
       enumerize(items).each do |item|
-        row = @schema.row(
-          context: item,
-          result_type: options[:result_type]
-        )
+        row = table.row(context: item)
         row = yield row if block_given?
         to.send(options[:method], row)
       end

data/lib/table_structure.rb

@@ -12,6 +12,7 @@ module TableStructure
   require 'table_structure/schema/dsl/option'
   require 'table_structure/schema/dsl/result_builder'
   require 'table_structure/schema/definition'
+  require 'table_structure/schema/definition/compiler'
   require 'table_structure/schema/definition/error'
   require 'table_structure/schema/definition/validator'
   require 'table_structure/schema/table'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-02 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,7 @@ files:
 - lib/table_structure/schema/column/attrs.rb
 - lib/table_structure/schema/column/schema.rb
 - lib/table_structure/schema/definition.rb
+- lib/table_structure/schema/definition/compiler.rb
 - lib/table_structure/schema/definition/error.rb
 - lib/table_structure/schema/definition/validator.rb
 - lib/table_structure/schema/dsl/column_converter.rb