ruby-tables 0.1.0 → 0.1.1

data/README.rdoc

@@ -10,7 +10,9 @@ Any methods from the Enumerable module should work and will treat the table as a
 ignoring any pairs inside it.
 
 = Caveats
-As in lua, hash keys cannot be numeric indices. If you intend to use numeric hash keys,
+Like a hash, the order for paired objects is not guaranteed.
+
+Also, as in lua, hash keys cannot be numeric indices. If you intend to use numeric hash keys,
 they should be inside an array, such as:
   Table[ [ 2 ] => 4 ]
 

data/Rakefile

@@ -4,10 +4,10 @@ require 'rake'
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
-    gem.version = "0.1.0"
+    gem.version = "0.1.1"
     gem.name = "ruby-tables"
-    gem.summary = %Q{Ruby implementation of lua tables}
-    gem.description = %Q{A table data structure implemented in ruby}
+    gem.summary = %Q{Lua tables for Ruby}
+    gem.description = %Q{A table data structure implemented in Ruby}
     gem.email = "nick.loves.rails@gmail.com"
     gem.homepage = "http://github.com/Abica/ruby-tables"
     gem.authors = [ "Nicholas Wright" ]

data/lib/table.rb

@@ -1,11 +1,40 @@
-# Implements a table data structure
+#
+# A table is a basically a combination of an array and a hash.
+#
+# Actually a possibly easier way to think of them would be as
+# Arrays that have some metadata in the form of a hash.
+#
+# You can also access symbolized hash keys with dot notation, making them
+# really convenient for a lot of things.
+#
+# For instance:
+#
+#   t = Table[ 1, 2, 3, 4, { :a => "1", :b => "2" }, 7, 8 ]
+#   t #=> Table[1, 2, 3, 4, 7, 8, {:b=>"2", :a=>"1"}]
+#
+#   t.size #=> 8
+#   t.b #=> "2"
+#
+#   t.b = Table[ 255, 0, 0, { :color => "red" } ]
+#   t.b.color #=> "red"
+#   r, b, g = *t.b
+#   print r, g, b #=> 25500
+#
+#   t #=> Table[1, 2, 3, 4, 7, 8, {:b=>Table[255, 0, 0, {:color=>"red"}], :a=>"1", :c=>"3"}]
+#
+#   t << %{ a b c d }
+#   t.last #=> ["a", "b", "c", "d"]
+#   t[ -3 ] #=> 7
+#
+#   t #=> Table[1, 2, 3, 4, 7, 8, ["a", "b", "c", "d"], {:b=>Table[255, 0, 0, {:color=>"red"}], :a=>"1", :c=>"3"}]
+#
 class Table
   include Enumerable
 
   # takes a comma separated list of arrays and hashes and returns a table
   #
-  # example:
-  #   Table[ 1, 2, 3, 4, { :a => 3, :b => 5 }, 7, 8, { :c => 33 } ]
+  #   t = Table[ 1, 2, 3, 4, { :a => 3, :b => 5 }, 7, 8, { :c => 33 } ]
+  #   t #=> Table[1, 2, 3, 4, 7, 8, {:a=>3, :b=>5, :c=>33}]
   def self.[] *args
     new *args
   end
@@ -26,11 +55,16 @@ class Table
   #
   #   t.a #=> 4
   #   t.b #=> 5
-  def [] key
-    if key.is_a? Integer
-      @values[ key ]
-    else
-      @records[ key ]
+  def [] key, *rest
+    return @values.slice( key, *rest ) if rest.any?
+
+    case key
+      when Range
+        @values.slice key
+      when Integer
+        @values[ key ]
+      else
+        @records[ key ]
     end
   end
 
@@ -38,8 +72,10 @@ class Table
   # if no entry exists for the given key or index then one is created
   #
   #   t = Table[ :a => "abcde", :b => 44332211 ]
+  #
   #   t[ :a ] = 43
   #   t[ :a ] #=> 43
+  #
   #   t[ 0 ] = 54
   #   t.first #=> 54
   #
@@ -62,17 +98,25 @@ class Table
     end
   end
 
-  # add a hash or value to this table
+  # adds a hash or value to a table
   #
   #   t = Table[ 1, 2, 3 ]
+  #
   #   t << { :a => 4, :b => 4 }
+  #   t.pairs #=> { :a => 4, :b => 4 }
+  #
+  #   t << 40000
+  #   t.to_a #=> [ 1, 2, 3, 40000 ]
   def << arg
     process arg
   end
 
   # combines 2 tables
   #
-  #   Table[ :a => 4, :b => 5 ] + Table[ 1, 2, 3, 4, { :c => 4 } ]
+  #   t = Table[ :a => 4, :b => 5 ] + Table[ 1, 2, 3, 4, { :c => 4 } ]
+  #
+  #   t.pairs #=> { :a => 4, :b => 5, :c => 4 }
+  #   t.to_a #=> [ 1, 2, 3, 4 ]
   def + other
     values = self.to_a + other.to_a 
     Table[ self.pairs, other.pairs, *values ]
@@ -117,12 +161,30 @@ class Table
     @values.sort &block
   end
 
+  # slice a table like an array
+  #
+  #   t = Table[ 2, 23, 54, { :a => 4 }, 49 ]
+  #   t[ 2..4 ] #=> [ 54, 49 ]
+  def slice *args
+    @values.slice *args
+  end
+
   # iterate through the key => value pairs in the table
+  #
+  #   t = Table[ 1, 2, { :a => "cat", :b => "dog" } ]
+  #
+  #   t.each_pair { | k, v | print k, v }
+  #   #=> bdogacat
   def each_pair &block
     @records.each_pair &block
   end
 
   # iterate through the hash keys in the table 
+  #
+  #   t = Table[ 1, 2, { :a => "cat", :b => "dog" } ]
+  #
+  #   t.each_key { | k | print k }
+  #   #=> ab
   def each_key &block
     @records.each_key &block
   end
@@ -151,7 +213,18 @@ class Table
     @records.values
   end
 
+  def inspect
+    hsh = pairs
+    str = []
+
+    str << map { | item | item.inspect } if any?
+    str << "{#{ hsh.map { | key, val | "#{ key.inspect }=>#{ val.inspect }" } }}" if hsh.any?
+
+    "Table[#{ str.join( ", " ) }]"
+  end
+
   private
+    # adds +args+ into the table
     def process *args
       args.each do | arg |
         if arg.is_a? Hash
@@ -162,23 +235,27 @@ class Table
       end
     end
 
+    # adds a hash entries to the table and creates
+    # setters and getters for them if the keys are symbolized
+    #
+    # any keys that are numeric are wrapped in an array so as
+    # not to overlap array indices which could get confusing
     def process_hash hsh
       hsh.each do | key, value |
         key = [ key ] if key.is_a? Integer
         @records[ key ] = value
 
-        next unless key.is_a? Symbol
-        next if respond_to? key and respond_to? "#{ key }="
+        if key.is_a? Symbol and not respond_to? "#{ key }="
+          instance_eval <<-EOM
+            def #{ key }
+              @records[ :#{ key } ]
+            end
 
-        instance_eval <<-EOM
-          def #{ key }
-            @records[ :#{ key } ]
-          end
-
-          def #{ key }= value
-            @records[ :#{ key } ] = value
-          end
-        EOM
+            def #{ key }= value
+              @records[ :#{ key } ] = value
+            end
+          EOM
+        end
       end
     end
 

data/ruby-tables.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby-tables}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nicholas Wright"]
-  s.date = %q{2010-02-13}
-  s.description = %q{A table data structure implemented in ruby}
+  s.date = %q{2010-02-14}
+  s.description = %q{A table data structure implemented in Ruby}
   s.email = %q{nick.loves.rails@gmail.com}
   s.extra_rdoc_files = [
     "README.rdoc"
@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Ruby implementation of lua tables}
+  s.summary = %q{Lua tables for Ruby}
   s.test_files = [
     "spec/spec_helper.rb",
      "spec/table_spec.rb"

data/spec/table_spec.rb

@@ -26,6 +26,14 @@ describe Table do
       @table[ :k ].should == @args[ 5 ][ :k ]
       @table[ :v ].should == @args[ 8 ][ :v ]
     end
+
+    it "returns an array when sliced with a range" do
+      @table[ 1..3 ].should == @array_vals[ 1..3 ]
+    end
+
+    it "returns an array when sliced with a start and length" do
+      @table[ 4, 5 ].should == @array_vals[ 4, 5 ]
+    end
   end
 
   describe "#[]=" do
@@ -143,6 +151,16 @@ describe Table do
     end
   end
 
+  describe "#slice" do
+    it "returns a sub array based on a range" do
+      @table.slice( 1..3 ).should == @array_vals.slice( 1..3 )
+    end
+
+    it "returns a sub array based on a start and length" do
+      @table.slice( 4, 5 ).should == @array_vals.slice( 4, 5 )
+    end
+  end
+
   describe "#pairs" do
     it "returns a hash of all of the key => value pairs" do
       pairs = @table.pairs

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-tables
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Nicholas Wright
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 -07:00
+date: 2010-02-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.2.2
     version: 
-description: A table data structure implemented in ruby
+description: A table data structure implemented in Ruby
 email: nick.loves.rails@gmail.com
 executables: []
 
@@ -66,7 +66,7 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Ruby implementation of lua tables
+summary: Lua tables for Ruby
 test_files: 
 - spec/spec_helper.rb
 - spec/table_spec.rb