ntable 0.1.5 → 0.1.6

data/History.rdoc

@@ -1,3 +1,7 @@
+=== 0.1.6 / 2012-09-24
+
+* It is now possible to specify a fixed structure for NTable.from_nested_object.
+
 === 0.1.5 / 2012-09-24
 
 * INCOMPATIBLE CHANGE: Renamed :postprocess option in NTable.from_nested_object to :postprocess_labels.

data/Version

@@ -1 +1 @@
-0.1.5
+0.1.6

data/lib/ntable/construction.rb

@@ -153,13 +153,24 @@ module NTable
     # [<tt>:stringify_by_default</tt>]
     #   If set to a Proc, this Proc is used as the default stringification
     #   routine for converting labels for a LabeledAxis.
+    # [<tt>:structure</tt>]
+    #   Force the use of the given Structure. Any data that does not fit
+    #   into this structure is ignored. When this option is provided,
+    #   the :name, :sort, :postprocess_labels, and :postprocess_range
+    #   field options are ignored. However, :stringify and :objectify may
+    #   still be provided to specify how hash keys should map to labels.
 
     def from_nested_object(obj_, field_opts_=[], opts_={})
+      if field_opts_.is_a?(::Hash)
+        opts_ = field_opts_
+        field_opts_ = []
+      end
       axis_data_ = []
       _populate_nested_axes(axis_data_, 0, obj_)
       objectify_by_default_ = opts_[:objectify_by_default]
       stringify_by_default_ = opts_[:stringify_by_default]
-      struct_ = Structure.new
+      fixed_struct_ = opts_[:structure]
+      struct_ = Structure.new unless fixed_struct_
       axis_data_.each_with_index do |ai_, i_|
         field_ = field_opts_[i_] || {}
         axis_ = nil
@@ -184,7 +195,7 @@ module NTable
             klass_ = ObjectAxis
           else
             stringify_ = nil unless stringify_.respond_to?(:call)
-              h_ = ::Set.new
+            h_ = ::Set.new
             ai_.keys.each do |k_|
               nv_ = (stringify_ ? stringify_.call(k_) : k_).to_s
               ai_[k_] = nv_
@@ -193,35 +204,39 @@ module NTable
             labels_ = h_.to_a
             klass_ = LabeledAxis
           end
-          if (sort_ = field_[:sort])
-            if sort_.respond_to?(:call)
-              func_ = sort_
-            elsif sort_ == :string
-              func_ = @string_sort
-            elsif sort_ == :integer
-              func_ = @integer_sort
-            elsif sort_ == :numeric
-              func_ = @numeric_sort
-            else
-              func_ = nil
+          if struct_
+            if (sort_ = field_[:sort])
+              if sort_.respond_to?(:call)
+                func_ = sort_
+              elsif sort_ == :string
+                func_ = @string_sort
+              elsif sort_ == :integer
+                func_ = @integer_sort
+              elsif sort_ == :numeric
+                func_ = @numeric_sort
+              else
+                func_ = nil
+              end
+              labels_.sort!(&func_)
             end
-            labels_.sort!(&func_)
+            postprocess_ = field_[:postprocess_labels]
+            labels_ = postprocess_.call(labels_) || labels_ if postprocess_.respond_to?(:call)
+            axis_ = klass_.new(labels_)
           end
-          postprocess_ = field_[:postprocess_labels]
-          labels_ = postprocess_.call(labels_) || labels_ if postprocess_.respond_to?(:call)
-          axis_ = klass_.new(labels_)
         when ::Array
-          range_ = ((ai_[0].to_i)...(ai_[1].to_i))
-          postprocess_ = field_[:postprocess_range]
-          range_ = postprocess_.call(range_) || range_ if postprocess_.respond_to?(:call)
-          ai_[0] = range_.first.to_i
-          ai_[1] = range_.last.to_i
-          ai_[1] += 1 unless range_.exclude_end?
-          axis_ = IndexedAxis.new(ai_[1] - ai_[0], ai_[0])
+          if struct_
+            range_ = ((ai_[0].to_i)...(ai_[1].to_i))
+            postprocess_ = field_[:postprocess_range]
+            range_ = postprocess_.call(range_) || range_ if postprocess_.respond_to?(:call)
+            ai_[0] = range_.first.to_i
+            ai_[1] = range_.last.to_i
+            ai_[1] += 1 unless range_.exclude_end?
+            axis_ = IndexedAxis.new(ai_[1] - ai_[0], ai_[0])
+          end
         end
         struct_.add(axis_, name_) if axis_
       end
-      table_ = Table.new(struct_, :fill => opts_[:fill])
+      table_ = Table.new(fixed_struct_ || struct_, :fill => opts_[:fill])
       _populate_nested_values(table_, [], axis_data_, obj_)
       table_
     end

data/test/tc_nested_object.rb

@@ -233,6 +233,36 @@ module NTable
       end
 
 
+      def test_integer_sort
+        obj_ = {'9' => 1, '10' => 2}
+        t1_ = Table.from_nested_object(obj_, [{:sort => :integer}])
+        assert_equal(['9', '10'], t1_.structure.axis(0).to_a)
+      end
+
+
+      def test_custom_sort
+        sorter_ = ->(a_, b_){ b_.to_i <=> a_.to_i }
+        obj_ = {'9' => 1, '10' => 2, '11' => 3}
+        t1_ = Table.from_nested_object(obj_, [{:sort => sorter_}])
+        assert_equal(['11', '10', '9'], t1_.structure.axis(0).to_a)
+      end
+
+
+      def test_custom_object_sort
+        sorter_ = ->(a_, b_){ b_.to_s.to_i <=> a_.to_s.to_i }
+        obj_ = {:'9' => 1, :'10' => 2, :'11' => 3}
+        t1_ = Table.from_nested_object(obj_, [{:sort => sorter_, :objectify => true}])
+        assert_equal([:'11', :'10', :'9'], t1_.structure.axis(0).to_a)
+      end
+
+
+      def test_fixed_struct
+        struct_ = Structure.add(@indexed_axis_2, 'row').add(@labeled_axis_3, 'col')
+        t1_ = Table.from_nested_object(nil, :structure => struct_, :fill => 0)
+        assert_equal(Table.new(struct_, :load => [0, 0, 0, 0, 0, 0]), t1_)
+      end
+
+
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ntable
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000 Z
+date: 2012-09-25 00:00:00.000000000 Z
 dependencies: []
 description: NTable provides a convenient data structure for storing n-dimensional
   tabular data. It works with zero-dimensional scalar values, arrays, tables, and