rdy 0.2.0 → 0.2.1

data/Gemfile

@@ -1,5 +1,5 @@
 source "http://rubygems.org"
-gem "aws-sdk", ">= 1.3.2"
+gem "aws-sdk", ">= 1.3.5"
 group :development do
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.0"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    aws-sdk (1.3.4)
+    aws-sdk (1.3.5)
       httparty (~> 0.7)
       json (~> 1.4)
       nokogiri (>= 1.4.4)
@@ -15,19 +15,23 @@ GEM
       git (>= 1.2.5)
       rake
     json (1.6.5)
-    multi_json (1.0.4)
+    multi_json (1.1.0)
     multi_xml (0.4.1)
     nokogiri (1.5.0)
     rake (0.9.2.2)
     rcov (1.0.0)
-    shoulda (2.11.3)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
     uuidtools (2.1.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  aws-sdk (>= 1.3.2)
+  aws-sdk (>= 1.3.5)
   bundler (~> 1.0.0)
   jeweler (~> 1.6.4)
   rcov

data/README.md

@@ -2,10 +2,12 @@
 
 Fun little ruby client for Amazon DynamoDB.
 
+    # hash-key based tables
     rdy = Rdy.new("your_table", [:your_hash_key, :string])
     rdy.any_attribute = "nice!"
     rdy.foo = "bar"
-    rdy.save("1") # hash key value
+    rdy.save("1") # set your hash key value
+    # rdy.save # if ommitted the hash key value is generated
     
     rdy.foo = "bar2"
     rdy.save # update
@@ -13,7 +15,9 @@ Fun little ruby client for Amazon DynamoDB.
     rdy.any_attribute = nil
     rdy.save # delete an attribute
     
-    rdy.find("1") # find by hash key value
+    rdy.find("1") # find by hash key value / sets values to current instance
+    rdy_instance = Rdy.find([:id, :string, 'mykey1']) # returns new Rdy instance
+
     rdy.destroy # delete item
 
     rdy.all
@@ -21,20 +25,41 @@ Fun little ruby client for Amazon DynamoDB.
 
     rdy.scan(:any_attribute => 'nice!')
     limit = 10
-    rdy.scan(:any_attribute => 'nice!', 10)
+    rdy.scan(:any_attribute => 'nice!', limit)
+
+    # hash & range-key based tables
+    rdy2 = Rdy.new("your_table", [:your_hash_key, :string], [:your_range_key, :number])
+    rdy2.your_range_key = 1
+    rdy2.save('mykey1') # or just rdy2.save
+
+    rdy2.find('mykey1', 1) # sets item values to current instance
+    rdy_instance = Rdy.find([:your_hash_key, :string, 'mykey1'], [:your_range_key, :number, 1]) # returns new Rdy instance
+
+    rdy2.query(:hash_value => 'mykey1', :range_value => 1)
+    rdy2.query_by_range_value(1)
 
     read_capacity_units = 10
     write_capacity_units = 5
     Rdy.create_table("rdy", read_capacity_units, write_capacity_units, :id => :string) # hash key only
     Rdy.create_table("rdy2", read_capacity_units, write_capacity_units, {:id => :string}, {:comment_id => :number}) # hash and range key
-    
-Advanced features like queries, scans etc. are not supported yet.
+
+    # You can also create your own class
+    class User < RdyItem
+        def initialize([:id, :string], [:your_range_key, :number]) # this will save data to the 'users' table
+        end
+    end
 
 ## Installation
 
     gem install rdy
     
-Then create a .rdy.yml file with your AWS credentials in your home directory. Checkout the sample file for help. Also make sure you activate DynamoDB in your AWS account.
+Create a .rdy.yml file with your AWS credentials in your home directory. Checkout the sample file for help. Also make sure you activate DynamoDB in your AWS account.
+
+## Tests
+
+    rake test
+    
+On the initial run the tables are created. This may take a while, so it's possible the first run of the tests is going to fail. You can also create the tables manually if you want to avoid this. Check out the helper.rb class.
 
 ## Contributing to rdy
  

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/rdy.rb

@@ -1,13 +1,14 @@
 require "rubygems"
 gem "aws-sdk"
 require "aws-sdk"
+require 'digest'
 
 class Rdy
   attr_accessor :hash_key_conditional_check, :check_table_status
   @@_tables = {}
   
   def initialize(table, hash_key, range_key = nil)
-    @attributes = {}; @table = table; @hash_key = hash_key[0].to_s
+    @attributes = {}; @table = table.to_s; @hash_key = hash_key[0].to_s
     @range_key = range_key[0].to_s if range_key
     @is_new = true
     self.hash_key_conditional_check = false
@@ -28,13 +29,16 @@ class Rdy
       end
     end
   end
-  def table=(value); @table = value; end
+  def table=(value); @table = value.to_s; end
   def table; @table; end
+  def table_exists?; @_table.exists?; end
   def attributes; @attributes; end
   def hash_value; @hash_value; end
   def hash_key; @hash_key; end
   def range_key; @range_key; end
-
+  def range_value; @range_value; end
+  def self.generate_key; Digest::SHA1.hexdigest((0...50).map{ ('a'..'z').to_a[rand(26)] }.join); end
+  
   def self.dynamo_db
     config = YAML.load(File.read("#{ENV['HOME']}/.rdy.yml"))
     raise "Config file expected in ~/.rdy.yml" unless config
@@ -46,18 +50,32 @@ class Rdy
       :hash_key => hash_key, :range_key => range_key)
   end
 
+  def build(attrs)
+    if attrs
+      @attributes.clear
+      attrs.each {|k, v| self.send("#{k.to_s}=".to_sym, v) unless k == @hash_key }
+      return self
+    end
+  end
+
   def all; @_table.items.collect {|i| i.attributes.to_h }; end
+  def self.find(table, hash_key_value, range_key_value = nil)
+    rdy = Rdy.new(table, hash_key_value[0..1], range_key_value ? range_key_value[0..1] : nil)
+    rdy.find(hash_key_value[2], range_key_value ? range_key_value[2] : nil)
+    rdy
+  end
   def find(hash_value, range_value = nil)
     raise "missing hash value" if hash_value.nil?
     if @range_key and range_value
-      @_item = @_table.items.at(@hash_value, range_value)
+      @_item = @_table.items.at(hash_value, range_value)
     else
       @_item = @_table.items[hash_value]
     end
     @attributes.clear
     if @_item and @_item.attributes and @_item.attributes.any?
-      @_item.attributes.to_h.each {|k, v| self.send("#{k}=".to_sym, v) unless k == @hash_key }
+      self.build(@_item.attributes.to_h)
       @hash_value = hash_value; @is_new = false
+      @range_value = range_value if range_value
     else
       @hash_value = nil
     end
@@ -67,7 +85,7 @@ class Rdy
 
   def is_new?; @is_new; end
   def save(hash_value = nil)
-    raise "missing hash value" if hash_value.nil? and is_new?
+    hash_value = Rdy.generate_key if hash_value.nil? and is_new?
     if is_new?
       if @range_key
         values = { @hash_key.to_sym => hash_value, @range_key.to_sym => @attributes[@range_key] }
@@ -75,7 +93,7 @@ class Rdy
         values = { @hash_key.to_sym => hash_value }
       end
       options = {}
-      options[:unless_exists] = @hash_key if hash_key_conditional_check  
+      options[:unless_exists] = @hash_key if hash_key_conditional_check
       @_item = @_table.items.create(values, options)
     end
     if @_item
@@ -100,6 +118,17 @@ class Rdy
     values
   end
 
+  def query(options = {})
+    if options and options.any?
+      values = []
+      @_table.items.query(options).each do |item|
+        values << item.attributes.to_h
+      end
+      values
+    end
+  end
+  def query_by_range_value(value); query(:hash_value => self.hash_value.to_s, :range_value => value); end
+
   def destroy
     unless is_new?
       @_item.delete
@@ -116,3 +145,14 @@ class Rdy
     end
   end
 end
+
+class RdyItem < Rdy
+  def initialize(hash_key, range_key = nil, table = nil)
+    super(table ? table.to_s : "#{self.class.name.downcase}s", hash_key, range_key)
+  end
+
+  def self.create_table(read_capacity_units, write_capacity_units, hash_key, range_key = nil)
+    dynamo_db.tables.create(self.table, read_capacity_units, write_capacity_units,
+      :hash_key => hash_key, :range_key => range_key)
+  end
+end

data/test/helper.rb

@@ -16,10 +16,24 @@ require 'rdy'
 
 RDY_SIMPLE_TABLE = 'rdy_test_simple'
 RDY_RANGE_TABLE = 'rdy_test_range'
+creating = false
 
-puts "Setting up test tables for Rdy..."
-Rdy.create_table(RDY_SIMPLE_TABLE, 10, 5, :id => :string) rescue nil
-Rdy.create_table(RDY_RANGE_TABLE, 10, 5, {:id => :string}, {:foo => :string}) rescue nil
+unless Rdy.new(RDY_SIMPLE_TABLE, [:id, :string]).table_exists?
+  puts "Setting up test tables for Rdy: #{RDY_SIMPLE_TABLE}"
+  Rdy.create_table(RDY_SIMPLE_TABLE, 10, 5, :id => :string)
+  creating = true
+end
+
+unless Rdy.new(RDY_RANGE_TABLE, [:id, :string], [:foo, :string]).table_exists?
+  puts "Setting up test tables for Rdy: #{RDY_RANGE_TABLE}"
+  Rdy.create_table(RDY_RANGE_TABLE, 10, 5, {:id => :string}, {:foo => :string})
+  creating = true
+end
+
+if creating
+  puts "Waiting for tables to become active..."
+  sleep 60
+end
 
 class Test::Unit::TestCase
 end

data/test/test_rdy.rb

@@ -44,8 +44,18 @@ class TestRdy < Test::Unit::TestCase
       assert_equal @rdy.attributes.size, 1
       assert_equal @rdy.attributes['foo'], 'bar'
     end
+    
+    should "build an Rdy instance from an attributes hash" do
+      rdy
+      attributes = { 'test' => 'testval', 'foo' => 'bar', :number => 1}
+      rdy_instance = Rdy.new(RDY_SIMPLE_TABLE, [:id, :string]).build(attributes)
+      assert_not_nil rdy_instance
+      assert_equal rdy_instance.test, 'testval'
+      assert_equal rdy_instance.foo, 'bar'
+      assert_equal rdy_instance.number, 1
+    end
   end
-  
+
   context "Creating" do
     setup do
       rdy
@@ -59,8 +69,28 @@ class TestRdy < Test::Unit::TestCase
       assert_equal @rdy.foo, "bar"
       assert_equal @rdy.table, RDY_SIMPLE_TABLE
       assert_nil @rdy.hash_value
-      attributes = @rdy.save('1')
-      assert_equal @rdy.hash_value, '1'
+      hash_value = Rdy.generate_key
+      attributes = @rdy.save(hash_value)
+      assert_equal @rdy.hash_value, hash_value
+      assert_equal attributes.size, 4
+      assert attributes.keys.include?('id')
+      assert attributes.keys.include?('foo')
+      assert attributes.keys.include?('count')
+      assert attributes.keys.include?('tags')
+      assert !@rdy.is_new?
+      @rdy.destroy
+    end
+    
+    should "save an item with a generated hash key value" do
+      assert @rdy.is_new?
+      @rdy.foo = "bar"
+      @rdy.count = 1
+      @rdy.tags = ['a', 'b', 'c']
+      assert_equal @rdy.foo, "bar"
+      assert_equal @rdy.table, RDY_SIMPLE_TABLE
+      assert_nil @rdy.hash_value
+      attributes = @rdy.save
+      assert_not_nil @rdy.hash_value
       assert_equal attributes.size, 4
       assert attributes.keys.include?('id')
       assert attributes.keys.include?('foo')
@@ -70,7 +100,7 @@ class TestRdy < Test::Unit::TestCase
       @rdy.destroy
     end
   end
-  
+
   context "Updating" do
     setup do
       rdy
@@ -78,15 +108,16 @@ class TestRdy < Test::Unit::TestCase
 
     should "update an item" do
       @rdy.foo = "bar"
-      attributes = @rdy.save("2")
+      hash_value = Rdy.generate_key
+      attributes = @rdy.save(hash_value)
       assert !@rdy.is_new?
-      assert_equal @rdy.hash_value, "2"
+      assert_equal @rdy.hash_value, hash_value
       assert_equal @rdy.foo, "bar"
       assert_equal attributes['foo'], "bar"
       @rdy.foo = "bar2"
       attributes = @rdy.save
       assert !@rdy.is_new?
-      assert_equal @rdy.hash_value, "2"
+      assert_equal @rdy.hash_value, hash_value
       assert_equal @rdy.foo, "bar2"
       assert_equal attributes['foo'], "bar2"
       @rdy.destroy
@@ -100,12 +131,13 @@ class TestRdy < Test::Unit::TestCase
     
     should "destroy an item" do
       @rdy.foo = "bar"
-      attributes = @rdy.save("3")
-      @rdy.find("3")
+      hash_value = Rdy.generate_key
+      attributes = @rdy.save(hash_value)
+      @rdy.find(hash_value)
       assert_not_nil @rdy.foo
       assert_equal @rdy.foo, "bar"
       @rdy.destroy
-      @rdy.find("3")
+      @rdy.find(hash_value)
       assert_nil @rdy.hash_value
     end
   end
@@ -116,15 +148,17 @@ class TestRdy < Test::Unit::TestCase
     end
     
     should "scan table by attribute values" do
+      hash_value1 = Rdy.generate_key
       @rdy2 = Rdy.new(RDY_RANGE_TABLE, [:id, :string], [:foo, :string])
       @rdy2.foo = "bar1"
       @rdy2.data = "test"
-      @rdy2.save("4")
+      @rdy2.save(hash_value1)
       
+      hash_value2 = Rdy.generate_key
       @rdy3 = Rdy.new(RDY_RANGE_TABLE, [:id, :string], [:foo, :string])
       @rdy3.foo = "bar2"
       @rdy3.data = "test"
-      @rdy3.save("5")
+      @rdy3.save(hash_value2)
 
       attrs = @rdy2.scan(:data => 'test')
       assert_not_nil attrs
@@ -145,10 +179,10 @@ class TestRdy < Test::Unit::TestCase
       assert_not_nil attrs
       assert_equal attrs.size, 1
       
-      @rdy2.find("4", "bar1")
+      @rdy2.find(hash_value1, "bar1")
       @rdy2.destroy
       
-      @rdy3.find("5", "bar2")
+      @rdy3.find(hash_value2, "bar2")
       @rdy3.destroy
     end
   end
@@ -159,27 +193,112 @@ class TestRdy < Test::Unit::TestCase
     end
     
     should "find an item by hash-key" do
+      hash_value = Rdy.generate_key
       @rdy.foo = "bar"
-      attributes = @rdy.save("6")
-      @rdy.find("6")
+      attributes = @rdy.save(hash_value)
+      @rdy.find(hash_value)
       assert_not_nil @rdy.foo
       assert_equal @rdy.foo, "bar"
       @rdy.destroy
     end
+    
+    should "use the find class method" do
+      hash_value = Rdy.generate_key
+      @rdy.foo = "bar"
+      attributes = @rdy.save(hash_value)
+      rdy_result = Rdy.find(RDY_SIMPLE_TABLE, [:id, :string, hash_value])
+      assert_not_nil rdy_result
+      assert rdy_result.is_a?(Rdy)
+      assert_not_nil rdy_result.attributes
+      assert_equal rdy_result.foo, 'bar'
+      assert_equal rdy_result.hash_value, hash_value
+      @rdy.destroy
+    end
   end
-  
+
   context "Finding hash-key/range based items" do
     setup do
       rdy_range
     end
     
     should "find an item by hash-key & range combination" do
+      hash_value = Rdy.generate_key
       @rdy2.foo = "bar"
-      attributes = @rdy2.save("7")
-      @rdy2.find("7", "bar")
+      attributes = @rdy2.save(hash_value)
+      @rdy2.find(hash_value, "bar")
       assert_not_nil @rdy2.foo
       assert_equal @rdy2.foo, "bar"
       @rdy2.destroy
     end
+    
+    should "use the find class method" do
+      hash_value = Rdy.generate_key
+      @rdy2.foo = "bar"
+      attributes = @rdy2.save(hash_value)
+      rdy_result = Rdy.find(RDY_RANGE_TABLE, [:id, :string, hash_value], [:foo, :string, 'bar'])
+      assert_not_nil rdy_result
+      assert rdy_result.is_a?(Rdy)
+      assert_not_nil rdy_result.attributes
+      assert_equal rdy_result.foo, 'bar'
+      assert_equal rdy_result.hash_value, hash_value
+      assert_equal rdy_result.range_value, 'bar'
+      @rdy2.destroy
+    end
+  end
+  
+  context "Query Table" do
+    setup do
+      rdy_range
+    end
+    
+    should "query table by hash value and range value" do    
+      hash_value1 = Rdy.generate_key
+      @rdy2 = Rdy.new(RDY_RANGE_TABLE, [:id, :string], [:foo, :string])
+      @rdy2.foo = "a"
+      @rdy2.save(hash_value1)
+      
+      hash_value2 = Rdy.generate_key
+      @rdy3 = Rdy.new(RDY_RANGE_TABLE, [:id, :string], [:foo, :string])
+      @rdy3.foo = "b"
+      @rdy3.save(hash_value2)
+
+      attrs = @rdy2.query(:hash_value => hash_value1, :range_value => "a")
+      assert_not_nil attrs
+      assert_equal attrs.size, 1
+      assert_equal attrs[0]['id'], hash_value1
+      assert_equal attrs[0]['foo'], 'a'
+      
+      attrs = @rdy2.query_by_range_value("a")
+      assert_not_nil attrs
+      assert_equal attrs.size, 1
+      assert_equal attrs[0]['id'], hash_value1
+      assert_equal attrs[0]['foo'], 'a'
+      
+      attrs = @rdy2.query_by_range_value("b")
+      assert_not_nil attrs
+      assert_equal attrs.size, 0
+      
+      attrs = @rdy3.query(:hash_value => hash_value2, :range_value => "b")
+      assert_not_nil attrs
+      assert_equal attrs.size, 1
+      assert_equal attrs[0]['id'], hash_value2
+      assert_equal attrs[0]['foo'], 'b'
+      
+      attrs = @rdy3.query_by_range_value("b")
+      assert_not_nil attrs
+      assert_equal attrs.size, 1
+      assert_equal attrs[0]['id'], hash_value2
+      assert_equal attrs[0]['foo'], 'b'
+      
+      attrs = @rdy3.query_by_range_value("a")
+      assert_not_nil attrs
+      assert_equal attrs.size, 0
+
+      @rdy2.find(hash_value1, "a")
+      @rdy2.destroy
+      
+      @rdy3.find(hash_value2, "b")
+      @rdy3.destroy
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rdy
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Oliver Kiessler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-15 00:00:00 Z
+date: 2012-03-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -23,12 +23,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 17
         segments: 
         - 1
         - 3
-        - 2
-        version: 1.3.2
+        - 5
+        version: 1.3.5
   name: aws-sdk
   prerelease: false
   type: :runtime