ntable 0.1.2 → 0.1.3

data/History.rdoc

@@ -1,3 +1,8 @@
+=== 0.1.3 / 2012-09-10
+
+* Creating a table from a nested object, using a label conversion procedure, tended to fail with NoSuchCellError. Fixed and added test cases.
+* Support cell lookup using the 0-based row index as well as the label.
+
 === 0.1.2 / 2012-09-09
 
 I took a long look at ntable's interface, and the usage patterns of my own personal projects that depended on it, and decided some simplification was needed.

data/Version

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/ntable.rb

@@ -99,5 +99,6 @@ end
 require 'ntable/errors'
 require 'ntable/axis'
 require 'ntable/structure'
+require 'ntable/index_wrapper'
 require 'ntable/table'
 require 'ntable/construction'

data/lib/ntable/construction.rb

@@ -34,6 +34,7 @@
 ;
 
 
+require 'set'
 require 'json'
 
 
@@ -41,6 +42,8 @@ module NTable
 
 
   @numeric_sort = ::Proc.new{ |a_, b_| a_.to_f <=> b_.to_f }
+  @integer_sort = ::Proc.new{ |a_, b_| a_.to_i <=> b_.to_i }
+  @string_sort = ::Proc.new{ |a_, b_| a_.to_s <=> b_.to_s }
 
 
   class << self
@@ -148,22 +151,36 @@ module NTable
           stringify_ = field_[:stringify] || stringify_by_default_
           objectify_ ||= objectify_by_default_ unless stringify_
           if objectify_
-            labels_ = ai_.keys
-            labels_.map!(&objectify_) if objectify_.respond_to?(:call)
+            if objectify_.respond_to?(:call)
+              h_ = ::Set.new
+              ai_.keys.each do |k_|
+                nv_ = objectify_.call(k_)
+                ai_[k_] = nv_
+                h_ << nv_
+              end
+              labels_ = h_.to_a
+            else
+              labels_ = ai_.keys
+            end
             klass_ = ObjectAxis
           else
-            h_ = {}
             stringify_ = nil unless stringify_.respond_to?(:call)
-            ai_.each do |k_, v_|
-              k_ = stringify_.call(k_) if stringify_
-              h_[k_.to_s] = true
+              h_ = ::Set.new
+            ai_.keys.each do |k_|
+              nv_ = (stringify_ ? stringify_.call(k_) : k_).to_s
+              ai_[k_] = nv_
+              h_ << nv_
             end
-            labels_ = h_.keys
+            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
@@ -178,7 +195,7 @@ module NTable
         struct_.add(axis_, name_) if axis_
       end
       table_ = Table.new(struct_, :fill => opts_[:fill])
-      _populate_nested_values(table_, [], obj_)
+      _populate_nested_values(table_, [], axis_data_, obj_)
       table_
     end
 
@@ -191,16 +208,16 @@ module NTable
           set_ = ai_
         else
           set_ = axis_data_[index_] = {}
-          (ai_[0]...ai_[1]).each{ |i_| set_[i_] = true } if ::Array === ai_
+          (ai_[0]...ai_[1]).each{ |i_| set_[i_] = i_ } if ::Array === ai_
         end
         obj_.each do |k_, v_|
-          set_[k_] = true
+          set_[k_] = k_
           _populate_nested_axes(axis_data_, index_+1, v_)
         end
       when ::Array
         if ::Hash === ai_
           obj_.each_with_index do |v_, i_|
-            ai_[i_] = true
+            ai_[i_] = i_
             _populate_nested_axes(axis_data_, index_+1, v_)
           end
         else
@@ -222,18 +239,19 @@ module NTable
     end
 
 
-    def _populate_nested_values(table_, path_, obj_)  # :nodoc:
+    def _populate_nested_values(table_, path_, axis_data_, obj_)  # :nodoc:
       if path_.size == table_.dim
         table_.set!(*path_, obj_)
       else
         case obj_
         when ::Hash
+          h_ = axis_data_[path_.size]
           obj_.each do |k_, v_|
-            _populate_nested_values(table_, path_ + [k_], v_)
+            _populate_nested_values(table_, path_ + [h_[k_]], axis_data_, v_)
           end
         when ::Array
           obj_.each_with_index do |v_, i_|
-            _populate_nested_values(table_, path_ + [i_], v_) unless v_.nil?
+            _populate_nested_values(table_, path_ + [i_], axis_data_, v_) unless v_.nil?
           end
         end
       end

data/lib/ntable/index_wrapper.rb

@@ -0,0 +1,73 @@
+# -----------------------------------------------------------------------------
+#
+# NTable index wrapper
+#
+# -----------------------------------------------------------------------------
+# Copyright 2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module NTable
+
+
+  # Use one of these in a coordinate to force the coordinate to be
+  # treated as an index rather than a label.
+
+  class IndexWrapper
+
+    # Create an IndexWrapper with the given integer index
+
+    def initialize(val_)
+      @value = val_.to_i
+    end
+
+    def eql?(rhs_)
+      rhs_.is_a?(IndexWrapper) && @value == @rhs_.value
+    end
+    alias_method :==, :eql?
+
+    def hash
+      @value.hash
+    end
+
+    attr_reader :value
+    alias_method :to_i, :value
+
+  end
+
+
+  # Convenience method for creating an IndexWrapper
+
+  def self.index(val_)
+    IndexWrapper.new(val_)
+  end
+
+
+end

data/lib/ntable/structure.rb

@@ -132,6 +132,18 @@ module NTable
         @axis_index -= 1
       end
 
+
+      def _compute_offset(v_)
+        if v_.is_a?(::NTable::IndexWrapper)
+          index_ = v_.to_i
+          index_ = nil if index_ < 0 || index_ >= @axis_object.size
+        else
+          index_ = @axis_object.index(v_)
+          index_ = v_ if !index_ && v_.is_a?(::Integer) && v_ >= 0 && v_ < @axis_object.size
+        end
+        index_ ? @step * index_ : nil
+      end
+
     end
 
 
@@ -551,9 +563,9 @@ module NTable
         offset_ = 0
         arg_.each do |k_, v_|
           if (ainfo_ = axis(k_))
-            index_ = ainfo_.index(v_)
-            return nil unless index_
-            offset_ += ainfo_.step * index_
+            delta_ = ainfo_._compute_offset(v_)
+            return nil unless delta_
+            offset_ += delta_
           else
             return nil
           end
@@ -563,9 +575,9 @@ module NTable
         offset_ = 0
         arg_.each_with_index do |v_, i_|
           if (ainfo_ = @indexes[i_])
-            index_ = ainfo_.index(v_)
-            return nil unless index_
-            offset_ += ainfo_.step * index_
+            delta_ = ainfo_._compute_offset(v_)
+            return nil unless delta_
+            offset_ += delta_
           else
             return nil
           end

data/lib/ntable/table.rb

@@ -189,9 +189,9 @@ module NTable
 
 
     # Returns the value in the cell at the given coordinates, which
-    # must be given as labels.
+    # may be given as labels or as 0-based row indexes.
     # You may specify the cell as an array of coordinates, or as a
-    # hash mapping axis name to coordinate.
+    # hash mapping axis name or axis index to coordinate.
     #
     # For example, for a typical database result set with an axis called
     # "row" of numerically identified rows, and an axis called "col" with
@@ -200,6 +200,23 @@ module NTable
     #  get(3, 'name')
     #  get([3, 'name'])
     #  get(:row => 3, :col => 'name')
+    #  get(0 => 3, 1 => 'name')
+    #
+    # Alternately, you can provide row numbers (0-based) instead. If, for
+    # example, "name" is the second column (corresponding to index 1),
+    # then the following queries are also equivalent:
+    #
+    #  get(3, 1)
+    #  get(:row => 3, :col => 1)
+    #
+    # For axes whose labels are integers (for example, a numerically
+    # identified axis such as IndexedAxis), it is ambiguous whether a
+    # value is intended as a label or an index. In this case, NTable
+    # defalts to assuming the value is a label. If you want to force a
+    # value to be treated as a 0-based row index, wrap it in a call to
+    # NTable.index(), as follows:
+    #
+    #  get(NTable.index(3), 1)
     #
     # Raises NoSuchCellError if the coordinates do not exist.
 
@@ -450,10 +467,10 @@ module NTable
     # Performs a reduce on the entire table and returns the result.
     # You may use one of the following call sequences:
     #
-    # [reduce{ |accumulator, value, position| <i>block</i> }]
+    # [reduce_with_position{ |accumulator, value, position| <i>block</i> }]
     #   Reduces using the given block as the reduction function. The
     #   first element in the table is used as the initial accumulator.
-    # [reduce(initial){ |accumulator, value, position| <i>block</i> }]
+    # [reduce_with_position(initial){ |accumulator, value, position| <i>block</i> }]
     #   Reduces using the given block as the reduction function, with
     #   the given initial value for the accumulator.
 

data/test/tc_basic_values.rb

@@ -47,7 +47,9 @@ module NTable
       def setup
         @labeled_axis = LabeledAxis.new([:red, :white, :blue])
         @indexed_axis = IndexedAxis.new(10)
+        @indexed_axis_1 = IndexedAxis.new(10, 1)
         @structure = Structure.add(@indexed_axis, :row).add(@labeled_axis, :column)
+        @structure_1 = Structure.add(@indexed_axis_1, :row).add(@labeled_axis, :column)
       end
 
 
@@ -81,6 +83,15 @@ module NTable
       end
 
 
+      def test_load_and_get_indexes
+        table_ = Table.new(@structure_1, :load => (0..29).to_a)
+        assert_equal(14, table_.get(5, 2))
+        assert_equal(14, table_.get(0 => 5, 1 => 2))
+        assert_equal(17, table_.get(::NTable.index(5), 2))
+        assert_equal(17, table_.get(0 => ::NTable.index(5), 1 => 2))
+      end
+
+
       def test_set_from_array
         table_ = Table.new(@structure)
         table_.set!(0, :red, "foo")
@@ -101,6 +112,16 @@ module NTable
       end
 
 
+      def test_set_indexes
+        table_ = Table.new(@structure_1)
+        table_.set!(1, 1, "foo")
+        table_[1 => 2, 0 => ::NTable.index(5)] = "bar"
+        assert_equal("foo", table_.get(::NTable.index(0), :white))
+        assert_equal("bar", table_[6, :blue])
+        assert_nil(table_.get(5, :blue))
+      end
+
+
       def test_load_no_axes
         t1_ = Table.new(Structure.new, :load => [1])
         assert_equal(1, t1_.get)

data/test/tc_nested_object.rb

@@ -199,6 +199,22 @@ module NTable
       end
 
 
+      def test_from_level_1_labeled_with_objectify_conversion
+        obj_ = {'one' => 1, 'two' => 2}
+        t1_ = Table.from_nested_object(obj_,
+          [{:sort => true, :objectify => ::Proc.new{ |a_| a_.to_sym }}])
+        assert_equal(Table.new(Structure.add(@object_axis_2), :load => [1,2]), t1_)
+      end
+
+
+      def test_from_level_1_labeled_with_stringify_conversion
+        obj_ = {:one1 => 1, :two22 => 2}
+        t1_ = Table.from_nested_object(obj_,
+          [{:sort => true, :stringify => ::Proc.new{ |a_| a_.to_s.gsub(/\d/, '') }}])
+        assert_equal(Table.new(Structure.add(@labeled_axis_2), :load => [1,2]), t1_)
+      end
+
+
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ntable
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -28,6 +28,7 @@ files:
 - lib/ntable/axis.rb
 - lib/ntable/construction.rb
 - lib/ntable/errors.rb
+- lib/ntable/index_wrapper.rb
 - lib/ntable/structure.rb
 - lib/ntable/table.rb
 - lib/ntable.rb