ruby-tables 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+*.swp

data/README.rdoc

@@ -0,0 +1,56 @@
+= Description
+This library provides a ruby implementation of a Table data structure from lua.
+
+Tables are essentially a combination of hashes and arrays.
+
+They're more for convenience than anything else, but they provide setters and getters
+for symbolized keys in hashes and uniform hash and array like access.
+
+Any methods from the Enumerable module should work and will treat the table as an array,
+ignoring any pairs inside it.
+
+= Caveats
+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 ]
+
+Unlike in lua, where an error is raised if you attempt to use numerical keys, ruby-tables
+will change all numerical keys into [ index ] as shown above.
+
+That is:
+  t = Table[ 1, 2, 3, { 4 => 5 } ]
+  t[ 4 ] = 5
+  t.pairs #=> { [ 4 ] => 5 }
+  t.to_a #=> [ 1, 2, 3, nil, 5 ]
+  t[ [ 4 ] ] = 50
+  t.pairs #=> { [ 4 ] => 50 }
+
+Notice above that index 3 was set to a nil value. That's because numeric indexes are filled
+in when you create a key well out of bounds. This is not unlike typical ruby Arrays:
+  ary = [ 1 ]
+  ary[ 10 ] = 2
+  ary #=> [ 1, nil, nil, nil, nil, nil, nil, nil, nil, nil, 2 ]
+
+= Examples
+  # as hashes with convient dot notation for keys
+  t1 = Table[ :something => 50, :else => 100 ]
+  t1.something #=> 50
+  t1.something = 100
+  t1.something #=> 100
+  t1.some_new_key = "sdsdsd"
+  t1.some_new_key #=> "sdsdsd"
+
+  # as a combination of an array and a hash
+  t2 = Table[ 1, 2, 3, 4, 5, { :a => 1000, :b => 2000 }, 6, 7, { :c => 50, :d => 60 }, 8, 9 ]
+
+  # the size method returns the number of array values inside the table, this is identical
+  # to lua's length operator (#table)
+  t2.size #=> 9
+  
+  t2.each_pair { | k, v | print k } #=> abcd
+
+  # tables can be concatenated
+  t3 = t1 + t2
+  t3.pairs #=> { :something => 50, :else => 100, :a => 1000, :b => 2000, :c => 50, :d => 60 }
+  t3.to_a #=> [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+  t3.inject { |sum, i | sum + i } #=> 45

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+ 
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = "0.1.0"
+    gem.name = "ruby-tables"
+    gem.summary = %Q{Ruby implementation of lua tables}
+    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" ]
+    gem.add_development_dependency "rspec", ">= 1.2.2"
+    gem.has_rdoc = true
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+ 
+task :default => :spec
+ 
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+ 
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby-tables #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/table.rb

@@ -0,0 +1,193 @@
+# Implements a table data structure
+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 } ]
+  def self.[] *args
+    new *args
+  end
+
+  def initialize *args
+    @values = []
+    @records = {}
+    process *args
+  end
+
+  # returns the value corresponding to the index or key
+  #
+  #   t = Table[ 1, 2, "string", { :a => 4, :b => 5 }, 3, 4 ]
+  #   t[ 2 ] #=> "string"
+  #   t[ :a ] #=> 4
+  #
+  # symbolized keys are also accessible via dot notation:
+  #
+  #   t.a #=> 4
+  #   t.b #=> 5
+  def [] key
+    if key.is_a? Integer
+      @values[ key ]
+    else
+      @records[ key ]
+    end
+  end
+
+  # updates the value for a given key or index
+  # 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
+  #
+  # note that like an array, if you insert a value into a table at an
+  # index that doesn't yet exist, any gaps will be filled in with nil
+  # such as:
+  #
+  #   t[ 5 ] = 100
+  #   t.to_a #=> [ 54, nil, nil, nil, 100 ]
+  #
+  # symbolized keys also have setters so that you can use dot notation:
+  #
+  #   t.a = "bbcec"
+  #   t.a #=> "bbcec"
+  def []= key, value
+    if key.is_a? Integer
+      @values[ key ] = value
+    else
+      process_hash key => value
+    end
+  end
+
+  # add a hash or value to this table
+  #
+  #   t = Table[ 1, 2, 3 ]
+  #   t << { :a => 4, :b => 4 }
+  def << arg
+    process arg
+  end
+
+  # combines 2 tables
+  #
+  #   Table[ :a => 4, :b => 5 ] + Table[ 1, 2, 3, 4, { :c => 4 } ]
+  def + other
+    values = self.to_a + other.to_a 
+    Table[ self.pairs, other.pairs, *values ]
+  end
+
+  # returns the first non pair item in the table
+  #
+  #   t = Table[ { :a => 4 }, 1, 2, 3, 4, { :b => 4, :c => 23 } ]
+  #   t.first #=> 1
+  def first
+    @values.first
+  end
+
+  # returns the last non pair item in the table
+  #
+  #   t = Table[ { :a => 4 }, 1, 2, 3, 4, { :b => 4, :c => 23 } ]
+  #   t.last #=> 4
+  def last
+    @values.last
+  end
+
+  # returns the length of all integer indexes
+  #
+  #   t = Table[ 1, 2, { :b => 4 }, 3, 4 ]
+  #   t.size #=> 4
+  def size
+    @values.size
+  end
+
+  alias length size
+
+  # iterate through each of the array values
+  def each &block
+    @values.each &block
+  end
+
+  # sort the array values
+  #
+  #   t = Table[ 2, 23, 54, { :a => 4 }, 49 ]
+  #   t.sort #=> [ 2, 23, 49, 54 ]
+  def sort &block
+    @values.sort &block
+  end
+
+  # iterate through the key => value pairs in the table
+  def each_pair &block
+    @records.each_pair &block
+  end
+
+  # iterate through the hash keys in the table 
+  def each_key &block
+    @records.each_key &block
+  end
+
+  # returns a hash of all key => value pairs inside the table
+  #
+  #   t = Table[ 1, { :a => 4 }, 2, { :b => 543 } ]
+  #   t.pairs #=> { :a => 4, :b => 543 }
+  def pairs
+    @records
+  end
+
+  # return an array of all hash keys in the table
+  #
+  #   t = Table[ 1, 2, { :a => 55, :b => 77 }, 3, { :c => 22 } ]
+  #   t.keys #=> [ :a, :b, :c ]
+  def keys
+    @records.keys
+  end
+
+  # returns an array of all hash values in the table
+  #
+  #   t = Table[ 1, 2, { :a => 55, :b => 77 }, 3, { :c => 22 } ]
+  #   t.values #=> [ 55, 77, 22 ]
+  def values
+    @records.values
+  end
+
+  private
+    def process *args
+      args.each do | arg |
+        if arg.is_a? Hash
+          process_hash arg
+        else
+          @values << arg
+        end
+      end
+    end
+
+    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 }="
+
+        instance_eval <<-EOM
+          def #{ key }
+            @records[ :#{ key } ]
+          end
+
+          def #{ key }= value
+            @records[ :#{ key } ] = value
+          end
+        EOM
+      end
+    end
+
+    # if an accessor is called that doesn't exist, the key => value
+    # are added into the table
+    def method_missing meth_id, *args
+      name = meth_id.id2name
+      if key = name[ /(\w+)=/, 1 ]
+        process_hash key.to_sym => args.first
+      end
+    end
+end

data/ruby-tables.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby-tables}
+  s.version = "0.1.0"
+
+  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.email = %q{nick.loves.rails@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/table.rb",
+     "ruby-tables.gemspec",
+     "spec/spec_helper.rb",
+     "spec/table_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/Abica/ruby-tables}
+  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.test_files = [
+    "spec/spec_helper.rb",
+     "spec/table_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.2"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.2"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.2"])
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require File.join( File.dirname( __FILE__ ), "..", "lib", "table" )
+ 
+Spec::Runner.configure do | config |
+end

data/spec/table_spec.rb

@@ -0,0 +1,193 @@
+require File.join( "spec", "spec_helper" )
+
+describe Table do
+  before :all do
+    @args = [ 1, 2, 3, 4, 5, { :k => 4 }, 7, 8, { :v => 10 } ]
+    @array_vals = @args.reject { | a | a.is_a? Hash }
+    @table = Table[ *@args ]
+  end
+
+  describe "[]" do
+    it "is a new Table instance" do
+      t = Table[ *@args ]
+
+      t.should be_a( Table )
+    end
+  end
+
+  describe "#self.[]" do
+    it "returns the value at index" do
+      @array_vals.each_with_index do | val, i |
+        @table[ i ].should == val
+      end
+    end
+
+    it "returns the value at key" do
+      @table[ :k ].should == @args[ 5 ][ :k ]
+      @table[ :v ].should == @args[ 8 ][ :v ]
+    end
+  end
+
+  describe "#[]=" do
+    it "creates a new value at index" do
+      i = 500
+      new_value = "something_new"
+      @table[ i ].should be_nil
+      @table[ i ] = new_value
+      @table[ i ].should == new_value
+      @table.size.should >= i
+    end
+
+    it "updates the value at index" do
+      i = 3
+      old_value = @args[ i ]
+      new_value = 34903489034
+      @table[ i ].should == old_value
+      @table[ i ] = new_value
+      @table[ i ].should == new_value
+    end
+
+    it "creates a new value for key" do
+      key = :something_long_and_fake
+      new_value = 0b0110
+      @table[ key ].should be_nil
+      @table[ key ] = new_value
+      @table[ key ].should == new_value
+    end
+
+    it "updates the value for key" do
+      key = :v
+      old_value = @args[ 8 ][ key ]
+      new_value = 50000000
+
+      @table[ key ].should == old_value
+      @table[ key ] = new_value 
+
+      @table[ key ].should == new_value
+    end
+  end
+
+  describe "#<<" do
+    it "pushes an argument onto the table" do
+      vals = [ 4000, [ 5, 0, 0, 0 ], "6000" ]
+      vals.each do | val |
+        @table << val
+        @table.last.should == val
+      end
+
+      hsh = { :this => 1, :was => 2, :added => 3 }
+      @table << hsh
+      hsh.each do | k, v |
+        @table[ k ].should == v
+      end
+    end
+  end
+
+  describe "#+" do
+    before :all do
+      @t1 = Table[ 1, 2, 3, { :a => 5, :b => 6 } ]
+      @t2 = Table[ 4, 5, { :c => 7, :d => 8 }, 6 ]
+      @t3 = @t1 + @t2
+    end
+
+    it "should combine 2 tables together" do
+      @t3.to_a.should == [ 1, 2, 3, 4, 5, 6 ]
+      pairs = @t3.pairs
+      [ :a, :b, :c, :d ].each do | key |
+        pairs.should have_key( key )
+      end
+    end
+  end
+
+  describe "#first" do
+    it "should return the first array element" do
+      t = Table[ *50..80 ]
+      t.first.should == 50
+
+      t = Table[ :a => 4, :b => 5, :c => 6 ]
+      t.first.should be_nil
+    end
+  end
+
+  describe "#last" do
+    it "should return the last array element" do
+      t = Table[ *50..80 ]
+      t.last.should == 80
+
+      t = Table[ :a => 4, :b => 5, :c => 6 ]
+      t.last.should be_nil
+
+      t = Table[ 1, 2, 3, { :a => 4, :b => 5, :c => 6 }, 600, 700, 800 ]
+      t.last.should == 800
+    end
+  end
+
+  describe "#size" do
+    it "should return the number of array elements in the table" do
+      @table.size.should == @array_vals.size
+    end
+
+    it "should be the same as length" do
+      @table.size.should == @table.length
+    end
+  end
+
+  describe "#sort" do
+    it "returns a sorted array" do
+      rand_vals = @array_vals.sort_by { rand }
+      sorted_vals = rand_vals.sort
+
+      t = Table[ *rand_vals ]
+      t.to_a.should_not == sorted_vals
+      t.sort.should == sorted_vals
+    end
+  end
+
+  describe "#pairs" do
+    it "returns a hash of all of the key => value pairs" do
+      pairs = @table.pairs
+      [ :k, :v ].each do | key |
+        pairs.should have_key( key )
+      end
+    end
+  end
+
+  describe "#keys" do
+    it "returns an array of all hash keys" do
+      pairs = @table.pairs
+      [ :k, :v ].each do | key |
+        pairs.should have_key( key )
+      end
+    end
+  end
+
+  describe "#values" do
+    it "returns an array of all hash values" do
+      @table.values.sort.should == [ 4, 10 ]
+    end
+  end
+
+  describe "setters for hash keys" do
+    it "should add a key if one doesn't exist" do
+      key = :super_long_key_name
+      meth_name = "#{ key }="
+      value = 349348908340
+      @table.should_not respond_to( meth_name )
+      @table.send meth_name, value
+      @table.should respond_to( meth_name )
+      @table[ key ].should == value
+    end
+
+    it "should override an existing key" do
+      @table.v.should == 10
+      @table.v = 50
+      @table.v.should == 50
+    end
+  end
+
+  describe "getters for hash keys" do
+    it "returns the value for a key" do
+      @table.v.should == 10
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-tables
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nicholas Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.2
+    version: 
+description: A table data structure implemented in ruby
+email: nick.loves.rails@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/table.rb
+- ruby-tables.gemspec
+- spec/spec_helper.rb
+- spec/table_spec.rb
+has_rdoc: true
+homepage: http://github.com/Abica/ruby-tables
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of lua tables
+test_files: 
+- spec/spec_helper.rb
+- spec/table_spec.rb