ntable 0.1.0 → 0.1.1

data/History.rdoc

@@ -1,3 +1,13 @@
+=== 0.1.1 / 2012-09-07
+
+* The "preferred" construction methods are now module methods on ::NTable.
+* Added an ObjectAxis type that lets labels be any arbitrary object.
+* NTable.from_nested_object now understands :objectify and :stringify options. These control whether the axis ends up as an ObjectAxis or LabeledAxis, and optionally let you provide a proc to convert the labels yourself.
+* INCOMPATIBLE CHANGE: Table#get and Table#set! now raise NoSuchCellError if the cell specification doesn't exist.
+* Added Table#include? to test for the correctness of a cell specification.
+# Table#set!, Table#load!, and Table#fill! now return self so they can be chained.
+* Filled out some more documentation.
+
 === 0.1.0 / 2012-09-01
 
 * Initial test release

data/Version

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/ntable.rb

@@ -35,6 +35,62 @@
 
 
 # NTable is an N-dimensional table data structure for Ruby.
+#
+# == Basics
+#
+# This is a convenient data structure for storing tabular data of
+# arbitrary dimensionality. An NTable can represent zero-dimensional data
+# (i.e. a simple scalar value), one-dimensional data (i.e. an array or
+# dictionary), a two-dimensional table such as a database result set or
+# spreadsheet, or any number of higher dimensions.
+#
+# The structure of the table is defined explicitly. Each dimension is
+# represented by an axis, which describes how many "rows" the table has
+# in that dimension, and how each row is labeled. For example, you could
+# have a "numeric" indexed axis whose rows are identified by indexes.
+# Or you could have a "string" labeled axis identified by names (e.g.
+# columns in a database.)
+#
+# For example, a typical two-dimensional spreadsheet would have
+# numerically-identified "rows", and columns identified by name. You might
+# describe the structure of the table with two axes, the major one a
+# numeric indexed axis, and the minor one a string labeled axis. In code,
+# such a table with 100 rows and two columns could be created like this:
+#
+#  table = NTable.structure(NTable::IndexedAxis.new(100)).
+#                 add(NTable::LabeledAxis(:name, :address)).
+#                 create
+#
+# You can then look up individual cells like this:
+#
+#  value = table[10, :address]
+#
+# Axes can be given names as well:
+#
+#  table = NTable.structure(NTable::IndexedAxis.new(100), :row).
+#                 add(NTable::LabeledAxis(:name, :address), :col).
+#                 create
+#
+# Then you can specify the axes by name when you look up:
+#
+#  value = table[:row => 10, :col => :address]
+#
+# You can use the same syntax to set data:
+#
+#  table[10, :address] = "123 Main Street"
+#  table[:row => 10, :col => :address] = "123 Main Street"
+#
+# == Iterating
+#
+# (to be written)
+#
+# == Slicing and decomposition
+#
+# (to be written)
+#
+# == Serialization
+#
+# (to be written)
 
 module NTable
 end
@@ -44,3 +100,4 @@ require 'ntable/errors'
 require 'ntable/axis'
 require 'ntable/structure'
 require 'ntable/table'
+require 'ntable/construction'

data/lib/ntable/axis.rb

@@ -114,7 +114,8 @@ module NTable
     # Create a LabeledAxis given an array of the label strings.
     # Symbols may also be provided, but will be converted to strings.
 
-    def initialize(labels_)
+    def initialize(*labels_)
+      labels_ = labels_.flatten
       @a = labels_.map{ |label_| label_.to_s }
       @h = {}
       @a.each_with_index{ |n_, i_| @h[n_] = i_ }
@@ -123,9 +124,12 @@ module NTable
 
 
     def eql?(obj_)
-      obj_.is_a?(LabeledAxis) && obj_.instance_variable_get(:@a).eql?(@a)
+      obj_.is_a?(LabeledAxis) && @a.eql?(obj_.instance_variable_get(:@a))
+    end
+
+    def ==(obj_)
+      obj_.is_a?(LabeledAxis) && @a == obj_.instance_variable_get(:@a)
     end
-    alias_method :==, :eql?
 
     def hash
       @a.hash
@@ -217,4 +221,62 @@ module NTable
   end
 
 
+  # An axis in which the labels are arbitrary objects.
+  # This axis cannot be serialized.
+
+  class ObjectAxis
+
+
+    # Create a ObjectAxis given an array of the label objects.
+
+    def initialize(labels_)
+      @a = labels_.dup
+      @h = {}
+      @a.each_with_index{ |n_, i_| @h[n_] = i_ }
+      @size = labels_.size
+    end
+
+
+    def eql?(obj_)
+      obj_.is_a?(ObjectAxis) && @a.eql?(obj_.instance_variable_get(:@a))
+    end
+
+    def ==(obj_)
+      obj_.is_a?(ObjectAxis) && @a == obj_.instance_variable_get(:@a)
+    end
+
+    def hash
+      @a.hash
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} #{@a.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+
+    attr_reader :size
+
+
+    def label_to_index(label_)
+      @h[label_]
+    end
+
+    def index_to_label(index_)
+      @a[index_]
+    end
+
+
+    def to_json_object(json_obj_)
+      raise "Unable to JSON serialize an ObjectAxis"
+    end
+
+    def from_json_object(json_obj_)
+      raise "Unable to JSON serialize an ObjectAxis"
+    end
+
+
+  end
+
+
 end

data/lib/ntable/construction.rb

@@ -0,0 +1,277 @@
+# -----------------------------------------------------------------------------
+#
+# NTable constructors
+#
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'json'
+
+
+module NTable
+
+
+  @numeric_sort = ::Proc.new{ |a_, b_| a_.to_f <=> b_.to_f }
+
+
+  class << self
+
+
+    # Create and return a new Structure.
+    #
+    # If you pass the optional axis argument, that axis will be added
+    # to the structure.
+    #
+    # The most convenient way to create a table is probably to chain
+    # methods off this method. For example:
+    #
+    #  NTable.structure(NTable::IndexedAxis.new(10)).
+    #    add(NTable::LabeledAxis.new(:column1, :column2)).
+    #    create(:fill => 0)
+
+    def structure(axis_=nil, name_=nil)
+      axis_ ? Structure.add(axis_, name_) : Structure.new
+    end
+
+
+    # Create a table with the given Structure.
+    #
+    # You can initialize the data using the following options:
+    #
+    # [<tt>:fill</tt>]
+    #   Fill all cells with the given value.
+    # [<tt>:load</tt>]
+    #   Load the cell data with the values from the given array, in order.
+
+    def create(structure_, data_={})
+      Table.new(structure_, data_)
+    end
+
+
+    # Construct a table given a JSON object representation.
+
+    def from_json_object(json_)
+      Table.new(Structure.from_json_array(json_['axes'] || []), :load => json_['values'] || [])
+    end
+
+
+    # Construct a table given a JSON unparsed string representation.
+
+    def parse_json(json_)
+      from_json_object(::JSON.parse(json_))
+    end
+
+
+    # Construct a table given nested hashes and arrays.
+    #
+    # The second argument is an array of hashes, providing options for
+    # the axes in order. Recognized keys in these hashes include:
+    #
+    # [<tt>:name</tt>]
+    #   The name of the axis, as a string or symbol
+    # [<tt>:sort</tt>]
+    #   The sort strategy. You can provide a callable object such as a
+    #   Proc, or one of the constants <tt>:numeric</tt> or
+    #   <tt>:string</tt>. If you omit this key or set it to false, no
+    #   sort is done on the labels for this axis.
+    # [<tt>:objectify</tt>]
+    #   An optional Proc that modifies the labels. The Proc should take
+    #   a single argument and return the new label. If an objectify
+    #   proc is provided, the resulting axis will be an ObjectAxis.
+    #   You can also pass true instead of a Proc; this will create an
+    #   ObjectAxis and make the conversion a nop.
+    # [<tt>:stringify</tt>]
+    #   An optional Proc that modifies the labels. The Proc should take
+    #   a single argument and return the new label, which will then be
+    #   converted to a string if it isn't one already. If a stringify
+    #   proc is provided, the resulting axis will be a LabeledAxis.
+    #   You can also pass true instead of a Proc; this will create an
+    #   LabeledAxis and make the conversion a simple to_s.
+    #
+    # The third argument is an optional hash of miscellaneous options.
+    # The following keys are recognized:
+    #
+    # [<tt>:fill</tt>]
+    #   Fill all cells not explicitly set, with the given value.
+    #   Default is nil.
+    # [<tt>:objectify_by_default</tt>]
+    #   By default, all hash-created axes are LabeledAxis unless an
+    #   <tt>:objectify</tt> field option is explicitly provided. This
+    #   option, if true, reverses this behavior. You can pass true, or
+    #   a Proc that transforms the label.
+    # [<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.
+
+    def from_nested_object(obj_, field_opts_=[], opts_={})
+      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
+      axis_data_.each_with_index do |ai_, i_|
+        field_ = field_opts_[i_] || {}
+        axis_ = nil
+        name_ = field_[:name]
+        case ai_
+        when ::Hash
+          objectify_ = field_[:objectify]
+          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)
+            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
+            end
+            labels_ = h_.keys
+            klass_ = LabeledAxis
+          end
+          if (sort_ = field_[:sort])
+            if sort_.respond_to?(:call)
+              func_ = sort_
+            elsif sort_ == :numeric
+              func_ = @numeric_sort
+            else
+              func_ = nil
+            end
+            labels_.sort!(&func_)
+          end
+          axis_ = klass_.new(labels_)
+        when ::Array
+          axis_ = IndexedAxis.new(ai_[1].to_i - ai_[0].to_i, ai_[0].to_i)
+        end
+        struct_.add(axis_, name_) if axis_
+      end
+      table_ = Table.new(struct_, :fill => opts_[:fill])
+      _populate_nested_values(table_, [], obj_)
+      table_
+    end
+
+
+    def _populate_nested_axes(axis_data_, index_, obj_)  # :nodoc:
+      ai_ = axis_data_[index_]
+      case obj_
+      when ::Hash
+        if ::Hash === ai_
+          set_ = ai_
+        else
+          set_ = axis_data_[index_] = {}
+          (ai_[0]...ai_[1]).each{ |i_| set_[i_] = true } if ::Array === ai_
+        end
+        obj_.each do |k_, v_|
+          set_[k_] = true
+          _populate_nested_axes(axis_data_, index_+1, v_)
+        end
+      when ::Array
+        if ::Hash === ai_
+          obj_.each_with_index do |v_, i_|
+            ai_[i_] = true
+            _populate_nested_axes(axis_data_, index_+1, v_)
+          end
+        else
+          s_ = obj_.size
+          if ::Array === ai_
+            if s_ > 0
+              ai_[1] = s_ if !ai_[1] || s_ > ai_[1]
+              ai_[0] = s_ if !ai_[0]
+            end
+          else
+            ai_ = axis_data_[index_] = (s_ == 0 ? [nil, nil] : [s_, s_])
+          end
+          obj_.each_with_index do |v_, i_|
+            ai_[0] = i_ if ai_[0] > i_ && !v_.nil?
+            _populate_nested_axes(axis_data_, index_+1, v_)
+          end
+        end
+      end
+    end
+
+
+    def _populate_nested_values(table_, path_, obj_)  # :nodoc:
+      if path_.size == table_.dim
+        table_.set!(*path_, obj_)
+      else
+        case obj_
+        when ::Hash
+          obj_.each do |k_, v_|
+            _populate_nested_values(table_, path_ + [k_], v_)
+          end
+        when ::Array
+          obj_.each_with_index do |v_, i_|
+            _populate_nested_values(table_, path_ + [i_], v_) unless v_.nil?
+          end
+        end
+      end
+    end
+
+
+  end
+
+
+  class Table
+
+    class << self
+
+
+      # Deprecated synonym for ::NTable.from_json_object
+
+      def from_json_object(json_)
+        ::NTable.from_json_object(json_)
+      end
+
+
+      # Deprecated synonym for ::NTable.parse_json
+
+      def parse_json(json_)
+        ::NTable.parse_json(json_)
+      end
+
+
+      # Deprecated synonym for ::NTable.from_nested_object
+
+      def from_nested_object(obj_, field_opts_=[], opts_={})
+        ::NTable.from_nested_object(obj_, field_opts_, opts_)
+      end
+
+
+    end
+
+  end
+
+
+end

data/lib/ntable/errors.rb

@@ -72,4 +72,10 @@ module NTable
   end
 
 
+  # Raised if you attempt to access a nonexistent cell.
+
+  class NoSuchCellError < NTableError
+  end
+
+
 end

data/lib/ntable/structure.rb

@@ -412,11 +412,19 @@ module NTable
     end
 
 
+    # Create a new substructure of this structure. The new structure
+    # has this structure as its parent, but includes only the given
+    # axes, which can be provided as an array of axis names or indexes.
+
     def substructure_including(*axes_)
       _substructure(axes_.flatten, true)
     end
 
 
+    # Create a new substructure of this structure. The new structure
+    # has this structure as its parent, but includes all axes EXCEPT the
+    # given axes, provided as an array of axis names or indexes.
+
     def substructure_omitting(*axes_)
       _substructure(axes_.flatten, false)
     end
@@ -469,6 +477,21 @@ module NTable
     end
 
 
+    # Create a new table using this structure as the structure.
+    # Note that this also has the side effect of locking this structure.
+    #
+    # You can initialize the data using the following options:
+    #
+    # [<tt>:fill</tt>]
+    #   Fill all cells with the given value.
+    # [<tt>:load</tt>]
+    #   Load the cell data with the values from the given array, in order.
+
+    def create(data_={})
+      Table.new(self, data_)
+    end
+
+
     def _substructure(axes_, bool_)  # :nodoc:
       raise StructureStateError, "Structure not locked" unless @locked
       sub_ = Structure.new
@@ -609,13 +632,24 @@ module NTable
     end
 
 
-    def self.add(axis_, name_=nil)
-      self.new.add(axis_, name_)
-    end
+    class << self
+
+
+      # Create a new structure and automatically add the given axis.
+      # See Structure#add.
+
+      def add(axis_, name_=nil)
+        self.new.add(axis_, name_)
+      end
+
+
+      # Deserialize a structure from the given JSON array
+
+      def from_json_array(array_)
+        self.new.from_json_array(array_)
+      end
 
 
-    def self.from_json_array(array_)
-      self.new.from_json_array(array_)
     end
 
 

data/lib/ntable/table.rb

@@ -45,14 +45,8 @@ module NTable
   class Table
 
 
-    # Create a table with the given structure.
-    #
-    # You can initialize the data using the following hash keys:
-    #
-    # [<tt>:fill</tt>]
-    #   Fill all cells with the given value.
-    # [<tt>:load</tt>]
-    #   Load the cell data with the values from the given array, in order.
+    # This is a low-level table creation mechanism.
+    # Generally, you should use ::NTable.create instead.
 
     def initialize(structure_, data_={})
       @structure = structure_
@@ -189,18 +183,27 @@ module NTable
     #  get(3, 'name')
     #  get([3, 'name'])
     #  get(:row => 3, :col => 'name')
+    #
+    # Raises NoSuchCellError if the coordinates do not exist.
 
     def get(*args_)
-      if args_.size == 1
-        first_ = args_.first
-        args_ = first_ if first_.is_a?(::Hash) || first_.is_a?(::Array)
+      offset_ = _offset_for_args(args_)
+      unless offset_
+        raise NoSuchCellError
       end
-      offset_ = @structure._offset(args_)
-      offset_ ? @vals[@offset + offset_] : nil
+      @vals[@offset + offset_]
     end
     alias_method :[], :get
 
 
+    # Returns a boolean indicating whether the given cell coordinates
+    # actually exist. The arguments use the same syntax as for Table#get.
+
+    def include?(*args_)
+      _offset_for_args(args_) ? true : false
+    end
+
+
     # Set the value in the cell at the given coordinates. If a block is
     # given, it is passed the current value and expects the new value
     # to be its result. If no block is given, the last argument is taken
@@ -209,23 +212,23 @@ module NTable
     #
     # You cannot set a value in a table with a parent. Instead, you must
     # modify the parent, and those changes will be reflected in the child.
+    #
+    # Raises NoSuchCellError if the coordinates do not exist.
+    #
+    # Returns self so calls can be chained.
 
     def set!(*args_, &block_)
       raise TableLockedError if @parent
       value_ = block_ ? nil : args_.pop
-      if args_.size == 1
-        first_ = args_.first
-        args_ = first_ if first_.is_a?(::Hash) || first_.is_a?(::Array)
+      offset_ = _offset_for_args(args_)
+      unless offset_
+        raise NoSuchCellError
       end
-      offset_ = @structure._offset(args_)
-      if offset_
-        if block_
-          value_ = block_.call(@vals[@offset + offset_])
-        end
-        @vals[@offset + offset_] = value_
-      else
-        @missing_value
+      if block_
+        value_ = block_.call(@vals[@offset + offset_])
       end
+      @vals[@offset + offset_] = value_
+      self
     end
     alias_method :[]=, :set!
 
@@ -234,6 +237,8 @@ module NTable
     #
     # You cannot load values into a table with a parent. Instead, you must
     # modify the parent, and those changes will be reflected in the child.
+    #
+    # Returns self so calls can be chained.
 
     def load!(vals_)
       raise TableLockedError if @parent
@@ -246,6 +251,7 @@ module NTable
       else
         @vals = vals_.dup
       end
+      self
     end
 
 
@@ -253,10 +259,13 @@ module NTable
     #
     # You cannot load values into a table with a parent. Instead, you must
     # modify the parent, and those changes will be reflected in the child.
+    #
+    # Returns self so calls can be chained.
 
     def fill!(value_)
       raise TableLockedError if @parent
       @vals.fill(value_)
+      self
     end
 
 
@@ -600,121 +609,12 @@ module NTable
     end
 
 
-    @numeric_sort = ::Proc.new{ |a_, b_| a_.to_f <=> b_.to_f }
-
-
-    class << self
-
-
-      # Construct a table given a JSON object representation.
-
-      def from_json_object(json_)
-        new(Structure.from_json_array(json_['axes'] || []), :load => json_['values'] || [])
-      end
-
-
-      # Construct a table given a JSON unparsed string representation.
-
-      def parse_json(json_)
-        from_json_object(::JSON.parse(json_))
-      end
-
-
-      # Construct a table given nested hashes and arrays.
-
-      def from_nested_object(obj_, field_opts_=[], opts_={})
-        axis_data_ = []
-        _populate_nested_axes(axis_data_, 0, obj_)
-        struct_ = Structure.new
-        axis_data_.each_with_index do |ai_, i_|
-          field_ = field_opts_[i_] || {}
-          axis_ = nil
-          name_ = field_[:name]
-          case ai_
-          when ::Hash
-            labels_ = ai_.keys
-            if (sort_ = field_[:sort])
-              if sort_.respond_to?(:call)
-                func_ = sort_
-              elsif sort_ == :numeric
-                func_ = @numeric_sort
-              else
-                func_ = nil
-              end
-              labels_.sort!(&func_)
-            end
-            if (xform_ = field_[:transform])
-              labels_.map!(&xform_)
-            end
-            axis_ = LabeledAxis.new(labels_)
-          when ::Array
-            axis_ = IndexedAxis.new(ai_[1].to_i - ai_[0].to_i, ai_[0].to_i)
-          end
-          struct_.add(axis_, name_) if axis_
-        end
-        table_ = new(struct_, :fill => opts_[:fill])
-        _populate_nested_values(table_, [], obj_)
-        table_
-      end
-
-
-      def _populate_nested_axes(axis_data_, index_, obj_)  # :nodoc:
-        ai_ = axis_data_[index_]
-        case obj_
-        when ::Hash
-          if ::Hash === ai_
-            set_ = ai_
-          else
-            set_ = axis_data_[index_] = {}
-            (ai_[0]...ai_[1]).each{ |i_| set_[i_.to_s] = true } if ::Array === ai_
-          end
-          obj_.each do |k_, v_|
-            set_[k_.to_s] = true
-            _populate_nested_axes(axis_data_, index_+1, v_)
-          end
-        when ::Array
-          if ::Hash === ai_
-            obj_.each_with_index do |v_, i_|
-              ai_[i_.to_s] = true
-              _populate_nested_axes(axis_data_, index_+1, v_)
-            end
-          else
-            s_ = obj_.size
-            if ::Array === ai_
-              if s_ > 0
-                ai_[1] = s_ if !ai_[1] || s_ > ai_[1]
-                ai_[0] = s_ if !ai_[0]
-              end
-            else
-              ai_ = axis_data_[index_] = (s_ == 0 ? [nil, nil] : [s_, s_])
-            end
-            obj_.each_with_index do |v_, i_|
-              ai_[0] = i_ if ai_[0] > i_ && !v_.nil?
-              _populate_nested_axes(axis_data_, index_+1, v_)
-            end
-          end
-        end
-      end
-
-
-      def _populate_nested_values(table_, path_, obj_)  # :nodoc:
-        if path_.size == table_.dim
-          table_.set!(*path_, obj_)
-        else
-          case obj_
-          when ::Hash
-            obj_.each do |k_, v_|
-              _populate_nested_values(table_, path_ + [k_.to_s], v_)
-            end
-          when ::Array
-            obj_.each_with_index do |v_, i_|
-              _populate_nested_values(table_, path_ + [i_], v_) unless v_.nil?
-            end
-          end
-        end
+    def _offset_for_args(args_)
+      if args_.size == 1
+        first_ = args_.first
+        args_ = first_ if first_.is_a?(::Hash) || first_.is_a?(::Array)
       end
-
-
+      @structure._offset(args_)
     end
 
 

data/test/tc_axes.rb

@@ -54,6 +54,7 @@ module NTable
         axis_ = LabeledAxis.new([:one, :two])
         assert_equal(0, axis_.label_to_index(:one))
         assert_equal(1, axis_.label_to_index(:two))
+        assert_equal(0, axis_.label_to_index('one'))
         assert_nil(axis_.label_to_index(:three))
       end
 
@@ -68,7 +69,7 @@ module NTable
 
       def test_labeled_axis_equality
         axis1_ = LabeledAxis.new([:one, :two])
-        axis2_ = LabeledAxis.new([:one, :two])
+        axis2_ = LabeledAxis.new([:one, 'two'])
         axis3_ = LabeledAxis.new([:one, :three])
         assert_equal(axis1_, axis2_)
         refute_equal(axis1_, axis3_)
@@ -81,6 +82,44 @@ module NTable
       end
 
 
+      def test_object_axis_size
+        axis_ = ObjectAxis.new([:one, :two])
+        assert_equal(2, axis_.size)
+      end
+
+
+      def test_object_axis_label_to_index
+        axis_ = ObjectAxis.new([:one, :two])
+        assert_equal(0, axis_.label_to_index(:one))
+        assert_equal(1, axis_.label_to_index(:two))
+        assert_nil(axis_.label_to_index('one'))
+        assert_nil(axis_.label_to_index(:three))
+      end
+
+
+      def test_object_axis_index_to_label
+        axis_ = ObjectAxis.new([:one, :two])
+        assert_equal(:one, axis_.index_to_label(0))
+        assert_equal(:two, axis_.index_to_label(1))
+        assert_nil(axis_.index_to_label(2))
+      end
+
+
+      def test_object_axis_equality
+        axis1_ = ObjectAxis.new([:one, :two])
+        axis2_ = ObjectAxis.new([:one, :two])
+        axis3_ = ObjectAxis.new([:one, 'two'])
+        assert_equal(axis1_, axis2_)
+        refute_equal(axis1_, axis3_)
+      end
+
+
+      def test_object_axis_empty
+        axis_ = ObjectAxis.new([])
+        assert_equal(0, axis_.size)
+      end
+
+
       def test_indexed_axis_size
         axis_ = IndexedAxis.new(2)
         assert_equal(2, axis_.size)

data/test/tc_basic_values.rb

@@ -47,7 +47,7 @@ module NTable
       def setup
         @labeled_axis = LabeledAxis.new([:red, :white, :blue])
         @indexed_axis = IndexedAxis.new(10)
-        @structure = Structure.new.add(@indexed_axis, :row).add(@labeled_axis, :column)
+        @structure = Structure.add(@indexed_axis, :row).add(@labeled_axis, :column)
       end
 
 
@@ -123,6 +123,32 @@ module NTable
       end
 
 
+      def test_convenience_construction
+        t_ = NTable.structure(@indexed_axis, :row).add(@labeled_axis, :column).create(:fill => 1)
+        assert_equal(1, t_.get(0, :red))
+      end
+
+
+      def test_include_p
+        t1_ = Table.new(@structure, :fill => 0)
+        assert_equal(true, t1_.include?(0, :red))
+        assert_equal(true, t1_.include?(9, :blue))
+        assert_equal(false, t1_.include?(10, :red))
+        assert_equal(false, t1_.include?(0, :black))
+      end
+
+
+      def test_no_such_cell
+        t1_ = Table.new(@structure, :fill => 0)
+        assert_raises(NoSuchCellError) do
+          t1_[10, :red]
+        end
+        assert_raises(NoSuchCellError) do
+          t1_[0, :black]
+        end
+      end
+
+
     end
 
   end

data/test/tc_nested_object.rb

@@ -46,6 +46,7 @@ module NTable
 
       def setup
         @labeled_axis_2 = LabeledAxis.new([:one, :two])
+        @object_axis_2 = ObjectAxis.new([:one, :two])
         @labeled_axis_3 = LabeledAxis.new([:blue, :red, :white])
         @indexed_axis_2 = IndexedAxis.new(2)
         @indexed_axis_10 = IndexedAxis.new(10, 1)
@@ -185,6 +186,19 @@ module NTable
       end
 
 
+      def test_from_level_1_labeled_with_objectify
+        obj_ = {:one => 1, :two => 2}
+        t1_ = Table.from_nested_object(obj_, [{:sort => true, :objectify => true}])
+        assert_equal(Table.new(Structure.add(@object_axis_2), :load => [1,2]), t1_)
+      end
+
+
+      def test_to_level_1_labeled_with_objectify
+        t1_ = Table.new(Structure.add(@object_axis_2), :load => [1,2])
+        assert_equal({:one => 1, :two => 2}, t1_.to_nested_object)
+      end
+
+
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ntable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-02 00:00:00.000000000 Z
+date: 2012-09-07 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
@@ -26,6 +26,7 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - lib/ntable/axis.rb
+- lib/ntable/construction.rb
 - lib/ntable/errors.rb
 - lib/ntable/structure.rb
 - lib/ntable/table.rb
@@ -62,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: virtuoso
-rubygems_version: 1.8.24
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: NTable is an n-dimensional table data structure for Ruby.