table_structure 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f880b928161f99c6d4346f06304cb9cfe4a1c44f8ffb307243a70d74ec5e400d
-  data.tar.gz: 9d1a30376429abe0906e3e0879eb230e4daf51c5c7de87cf28b63673433df83e
+  metadata.gz: edea213f708a84a4bfaf1a149a7c4fd9a78b2c50e36b72b951f6c0bc2b4d3a14
+  data.tar.gz: 71db859f76a5a55a33772d0764647afcfb0b6fa814705649d26c09f37f3ae35c
 SHA512:
-  metadata.gz: 3b5ee4c95815cb891a25ac377ec72359d70394da3ea1aaf58ea71f77618ffaaa8a5443fff95366ab0ca8ecccd871aa33bafbbe134ccb8109645146392dcbc4fa
-  data.tar.gz: 422e6db13c3940bdf873535c1f02d3f32211cca6a81ced5d1aebf678504f14daeda50c8de46d47762be33fcad79f90cb924d6d175a3a19c2029406d02d5a5a43
+  metadata.gz: 72abcf6d37f57322848493cd45e335276dc729524000007385d382dc0cb835fbf6ebe740c970e6de06bd4a78e45b4f63a1858f060bbbbbfc86396a9c2b57d088
+  data.tar.gz: 9332514abe32694295162c5349d5058e57c1bdf37a9c26eafb83e3bf18d9e01c88a128563f74193aece52fa0158adc6c2d2979fbd2663ad3b380aa17c4c3e03b

data/CHANGELOG.md

@@ -1,8 +1,16 @@
+# 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.
+
 # 0.3.1
 Changes:
+- `TableStructure::Writer`
+  - Make `:result_type` option available.
+- `TableStructure::Iterator`
+  - Make `:result_type` option available. (Passed to the writer internally.)
 - `TableStructure::Schema`
-  - Make `:result_type` option available for `TableStructure::Write` and `TableStructure::Iterator`.
-    - `:result_type` option for `TableStructure::Schema` is deprecated.
+  - `:result_type` option is deprecated.
 
 # 0.3.0
 Changes:

data/Gemfile.lock

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

data/README.md

@@ -107,7 +107,7 @@ response_body = Enumerator.new { |y| writer.write(items, to: CSV.new(y)) }
 ```
 
 #### TableStructure::Iterator
-Specifying `result_type: :hash` option of `TableStructure::Schema` works well.
+Specifying `result_type: :hash` option works well.
 To use this option, define `column(s)` with `:key`.
 ```ruby
 class SampleTableSchema

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

@@ -8,7 +8,7 @@ module TableStructure
 
         def initialize(definition, options)
           @name = definition[:name]
-          @key = definition[:key]
+          @keys = optimize_size([definition[:key]].flatten, definition[:size])
           @value = definition[:value]
           @size = definition[:size]
           @options = options
@@ -16,27 +16,29 @@ module TableStructure
 
         def name(header_context, table_context)
           name = Utils.evaluate_callable(@name, header_context, table_context)
-          optimize_size(name)
+          optimize_size(name, @size)
         end
 
         def key
-          key = optimize_size(@key)
-          decorate_key(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)
+          optimize_size(value, @size)
         end
 
         private
 
-        def optimize_size(value)
-          return value if @size == 1 && !value.is_a?(Array)
+        def optimize_size(value, expected_size)
+          return value if expected_size == 1 && !value.is_a?(Array)
 
           values = [value].flatten
           actual_size = values.size
-          expected_size = @size
           if actual_size > expected_size
             values[0, expected_size]
           elsif actual_size < expected_size
@@ -46,10 +48,8 @@ module TableStructure
           end
         end
 
-        def decorate_key(key)
-          return key unless @options[:key_prefix] || @options[:key_suffix]
-
-          [key].flatten.map do |key|
+        def decorate_keys
+          @keys.map do |key|
             next key unless key
 
             decorated_key = "#{@options[:key_prefix]}#{key}#{@options[:key_suffix]}"

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

@@ -11,17 +11,25 @@ module TableStructure
         end
 
         def name(header_context, _table_context)
-          schema.header(context: header_context)
+          @schema.header(context: header_context)
         end
 
         def key
-          schema
-            .instance_variable_get(:@table_structure_schema_table_)
-            .send(:keys)
+          table.send(:keys)
         end
 
         def value(row_context, _table_context)
-          schema.row(context: row_context)
+          @schema.row(context: row_context)
+        end
+
+        def size
+          table.send(:size)
+        end
+
+        private
+
+        def table
+          @schema.instance_variable_get(:@table_structure_schema_table_)
         end
       end
     end

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

@@ -4,11 +4,12 @@ module TableStructure
   module Schema
     class Definition
       class Error < ::TableStructure::Error
-        attr_reader :index
+        attr_reader :schema_name, :definition_index
 
-        def initialize(error_message, index)
-          @index = index
-          super("#{error_message} [defined position of column(s): #{index + 1}]")
+        def initialize(error_message, schema_name, definition_index)
+          @schema_name = schema_name
+          @definition_index = definition_index
+          super("#{error_message} [#{schema_name}] defined position of column(s): #{definition_index + 1}")
         end
       end
     end

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

@@ -6,26 +6,24 @@ module TableStructure
       class Validator
         DEFAULT_SIZE = 1
 
-        def initialize(index, options)
+        def initialize(name, index, options)
+          @name = name
           @index = index
           @options = options
         end
 
         def validate(name:, key:, size:, **)
           if key.respond_to?(:call)
-            raise Error.new('"key" must not be lambda.', @index)
+            raise Error.new('"key" must not be lambda.', @name, @index)
           end
           if !key && name.respond_to?(:call) && !size
-            raise Error.new('"size" must be defined, because column size cannot be determined.', @index)
+            raise Error.new('"size" must be defined, because column size cannot be determined.', @name, @index)
           end
           if size && size < DEFAULT_SIZE
-            raise Error.new('"size" must be positive.', @index)
-          end
-          if @options[:result_type] == :hash && !key
-            raise Error.new('"key" must be defined when "result_type: :hash" is specified.', @index)
+            raise Error.new('"size" must be positive.', @name, @index)
           end
           if key && size && [key].flatten.size < size
-            raise Error.new('"key" size must be greater than or equal to specified "size".', @index)
+            raise Error.new('"key" size must be greater than or equal to specified "size".', @name, @index)
           end
 
           true

data/lib/table_structure/schema/definition.rb

@@ -13,7 +13,8 @@ module TableStructure
 
       DEFAULT_SIZE = 1
 
-      def initialize(definitions, options)
+      def initialize(name, definitions, options)
+        @name = name
         @definitions = definitions
         @options = options
       end
@@ -22,7 +23,7 @@ module TableStructure
         @definitions
           .map { |definition| Utils.evaluate_callable(definition, context) }
           .map.with_index do |definition, i|
-            validator = Validator.new(i, @options)
+            validator = Validator.new(@name, i, @options)
 
             [definition]
               .flatten
@@ -40,7 +41,7 @@ module TableStructure
                 elsif Utils.schema_class?(definition)
                   definition.new(context: context)
                 else
-                  raise Error.new('Invalid definition.', i)
+                  raise Error.new('Invalid definition.', @name, i)
                 end
               end
           end

data/lib/table_structure/schema/table.rb

@@ -4,13 +4,16 @@ module TableStructure
   module Schema
     class Table
       RESULT_BUILDERS = {
-        hash: ->(values, keys, *) { keys.zip(values).to_h }
+        hash: lambda { |values, keys, *|
+          keys.map.with_index { |key, i| [key || i, values[i]] }.to_h
+        }
       }.freeze
 
       attr_reader :columns, :column_converters, :result_builders, :options
 
-      def initialize(column_definitions, column_converters, result_builders, context, options)
-        @columns = build_columns(column_definitions, context, options)
+      def initialize(name, column_definitions, column_converters, result_builders, context, options)
+        @name = name
+        @columns = build_columns(name, column_definitions, context, options)
         @column_converters = column_converters
         @result_builders = result_builders
         @context = context
@@ -29,11 +32,15 @@ module TableStructure
         @keys ||= @columns.map(&:key).flatten
       end
 
+      def size
+        @size ||= @columns.map(&:size).reduce(0) { |memo, size| memo + size }
+      end
+
       private
 
-      def build_columns(definitions, context, options)
+      def build_columns(name, definitions, context, options)
         Definition
-          .new(definitions, options)
+          .new(name, definitions, options)
           .compile(context)
           .map { |definition| Column.create(definition, options) }
       end

data/lib/table_structure/schema/utils.rb

@@ -7,15 +7,6 @@ module TableStructure
         val.respond_to?(:call) ? val.call(*params) : val
       end
 
-      def self.concat_key(key, prefix, suffix)
-        case key
-        when Symbol
-          "#{prefix}#{key}#{suffix}".to_sym
-        else
-          "#{prefix}#{key}#{suffix}"
-        end
-      end
-
       def self.schema_class?(val)
         val.is_a?(Class) &&
           val.included_modules.include?(::TableStructure::Schema)

data/lib/table_structure/schema.rb

@@ -16,7 +16,7 @@ module TableStructure
       key_suffix: nil
     }.freeze
 
-    def initialize(context: nil, **options)
+    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
@@ -24,6 +24,7 @@ module TableStructure
       options = DEFAULT_OPTIONS.merge(self.class.options).merge(options)
       @table_structure_schema_table_ =
         Table.new(
+          name,
           column_definitions,
           column_converters,
           result_builders,

data/lib/table_structure/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_structure
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - jsmmr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-30 00:00:00.000000000 Z
+date: 2019-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler