minidynamo 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "aws-sdk", "~> 1.11.2"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "jeweler", "~> 1.8.4"
+  #gem "simplecov", "~> 0.7.1"
+end

data/Gemfile.lock

@@ -0,0 +1,39 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    aws-sdk (1.11.2)
+      json (~> 1.4)
+      nokogiri (< 1.6.0)
+      uuidtools (~> 2.1)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.8.0)
+    multi_json (1.7.6)
+    nokogiri (1.5.10)
+    rake (10.0.4)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.2)
+    shoulda-matchers (2.2.0)
+      activesupport (>= 3.0.0)
+    uuidtools (2.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aws-sdk (~> 1.11.2)
+  jeweler (~> 1.8.4)
+  rdoc (~> 3.12)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,19 @@
+This gem contains modified code from Amazon's AWS SDK for Ruby. 
+The original license comes from http://aws.amazon.com/apache2.0/
+
+Original copyright notice from the aws-sdk gem
+==============================================
+
+Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"). You
+may not use this file except in compliance with the License. A copy of
+the License is located at
+
+    http://aws.amazon.com/apache2.0/
+
+or in the "license" file accompanying this file. This file is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+

data/README.md

@@ -0,0 +1,83 @@
+Minidynamo
+==============
+
+Monkey patch for AWS ruby SDK HashModel to support models backed by DynamoDB tables with hash-range keys. 
+
+## What's minidynamo for?
+
+
+As of June 2013 AWS-sdk for ruby HasModel for DynamoDB does not support working with tables having a hash-range main key. Additionally the main key in hash tables is alway called :id. 
+
+Another well known DynamoDB ORM is Dynamoid, but they lack this as well. Most likely because they've built on top of HashModel and hence they are subject to its current functionality.
+
+Having the ability to perform queries in hash-range tables and the recent addition of secondary indexes for this kind of tables, we monkey patched the HashModel class to offer some initial support. 
+
+Depending on when and how Amazon supports this kind of tables, Minidynamo will continue to be supported. Since this gem is very small and mostly based on their own code, we're optimistic that Amazon will implement something similar. In the meantime, we hope this is useful.
+
+Minidynamo offers the following compared to HashModel:
+
+* Definition of tables and initial throughput with class methods á la Rails.
+* Custom name(s) for the primary key column(s)
+* For hash-range tables find() issues a rangeless query.
+* find_by_#{hash_key}() is created by default when the main key hash column name isn't :id
+* There's a create table method for each Model that accepts 0 parameteres and only uses the information given in the table definition.
+
+This simple additions, even though still not offering the full range of posibilities for hash-range tables in DynamoDB current API, will cover lots of use cases. We currently use it in more than 3 internal applications. Hash-range + DynamoDB in this applications enable low latency data availability to improve response times in internal components and make scaling a matter of clicks.
+
+## Current limitations
+
+* There's currently no definition of extra indexes.
+* Besides rangeless_query to find items in hash-range tables by only providing the hash value, there's no other querying functionality.
+* Nothing has been done regarding scoping, scanning or anything related to find more than the rangeless_query method listed below.
+
+## Instructions
+
+Include minidynamo in your Gemfile. 
+
+```ruby
+gem 'minidynamo', '~> 0.1.0'
+```
+
+Don't forget to do `bundle install` right after.
+
+### Defining a table
+
+```ruby
+class TestModel < Minidynamo::Model
+
+	table 	name: "my_table", 
+			hash_key: {:my_attribute => :string},
+			range_key: {:my_range_name => :string}
+
+	initial_througput read_capacity: 5, write_capacity: 5
+
+	timestamps
+
+	field :custom_field, :string
+
+end
+```
+
+With `field` the valid types are those that HashModel offers in the form of `{type}_attr` methods. For example:
+
+* string_attr, hence you can use :string as a type in field
+* date_attr, hence you can use :date as a type in field
+* integer_attr, hence you can use :integer as a type in field
+
+`field` only calls those methods. This is pure synthactic sugar, but we think it resembles a lot better the way we've become used to see ruby syntax, specially if you come from the Rails world.
+
+timestamps, as any other methods available via HashModel continue to be ready for you to use. You can check more in the [HasModel docs](http://docs.aws.amazon.com/AWSRubySDK/latest/frames.html#!http%3A//docs.aws.amazon.com/AWSRubySDK/latest/AWS/DynamoDB.html).
+
+You can still work with hash-only tables. Just omit the range_key part in the call to `table`.
+
+You could go and create the table by calling `TestModel.create_table`
+
+## Contributing to minidynamo
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so we can cherry-pick around it.

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "minidynamo"
+  gem.homepage = "http://github.com/vlipco/minidynamo"
+  gem.license = "MIT"
+  gem.summary = %Q{AWS SDK HashModel extension to support DynamoDB tables with hash-range keys}
+  gem.description = %Q{Monkey patch for AWS ruby SDK HashModel to support model backed by DynamoDB tables with hash-range keys. It also provides some convenience methods to define your model in a more expressive rails style.}
+  gem.email = "info@vlipco.co"
+  gem.authors = ["David Pelaez"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+#  test.libs << 'test'
+#  test.pattern = 'test/**/test_*.rb'
+#  test.verbose = true
+#  test.rcov_opts << '--exclude "gems/*"'
+#end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "minidynamo #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/minidynamo.rb

@@ -0,0 +1,3 @@
+require 'aws-sdk'
+require 'minidynamo/check_digit'
+require 'minidynamo/model'

data/lib/minidynamo/check_digit.rb

@@ -0,0 +1,37 @@
+# Check digit generator & validator using UPC barcode algorithm
+# as described in http://www.gs1.org/barcodes/support/check_digit_calculator
+
+
+class CheckDigit
+	class << self
+
+		def calculate_check_digit(number)
+			(10 - (check_sum(number)%10)) % 10
+		end
+
+		
+
+		def valid?(number)
+			digits = to_digits number
+			check = digits.pop
+			check == calculate_check_digit(digits)
+		end
+
+		private
+
+		def check_sum(number)
+			digits = to_digits number
+			values = digits.each_slice(2).map do |x, y|
+					y ||= 0
+					[x*3, y]
+				end
+			values.flatten.inject(:+)
+		end
+
+
+		def to_digits(number)
+			number.to_s.chars.map &:to_i
+		end
+	end
+
+end

data/lib/minidynamo/model.rb

@@ -0,0 +1,74 @@
+# Based on AWS::Record::HashModel from aws-sdk gem. 
+# Check the license file included in this gem or the original version at:
+# http://aws.amazon.com/apache2.0/
+
+module Minidynamo 
+	class Model < AWS::Record::HashModel
+
+		require 'minidynamo/model/keys'
+		require 'minidynamo/model/definition_helpers'
+		require 'minidynamo/model/dynamo_db_overloads'
+		require 'minidynamo/model/finder_overloads'
+
+		#require 'aws/record/hash_model/attributes'
+		#require 'aws/record/hash_model/finder_methods'
+		#require 'aws/record/hash_model/scope'
+
+		#extend AWS::Record::AbstractBase
+		
+		extend Keys
+		extend DefinitionHelpers
+		extend DynamoDBOverloads
+		extend FinderOverloads
+
+
+
+		class << self
+
+			#
+
+		end
+
+		#private
+		#def create_storage
+		#	attributes = serialize_attributes.merge('id' => @_id)
+		#	dynamo_db_table.items.create(attributes, opt_lock_conditions)
+		#end
+#
+		#private
+		#def update_storage
+		#	# Only enumerating dirty (i.e. changed) attributes.  Empty
+		#	# (nil and empty set) values are deleted, the others are replaced.
+		#	dynamo_db_item.attributes.update(opt_lock_conditions) do |u|
+		#		changed.each do |attr_name|
+		#			attribute = self.class.attribute_for(attr_name)
+		#			value = serialize_attribute(attribute, @_data[attr_name])
+		#			if value.nil? or value == []
+		#				u.delete(attr_name)
+		#			else
+		#				u.set(attr_name => value)
+		#			end
+		#		end
+		#	end
+		#end
+#
+		#private
+		#def delete_storage
+		#	dynamo_db_item.delete(opt_lock_conditions)
+		#end
+#
+		#private
+		#def deserialize_item_data data
+		#	data.inject({}) do |hash,(attr_name,value)|
+		#		if attribute = self.class.attributes[attr_name]
+		#			hash[attr_name] = value.is_a?(Set) ?
+		#			value.map{|v| attribute.deserialize(v) } :
+		#			attribute.deserialize(value)
+		#		end
+		#		hash
+		#	end
+		#end
+
+	end
+
+end

data/lib/minidynamo/model/definition_helpers.rb

@@ -0,0 +1,41 @@
+module Minidynamo
+	class Model
+		module DefinitionHelpers
+
+			# For all the fields with defaults
+			attr_writer :write_capacity, :read_capacity
+
+			attr_accessor :range_key
+
+			def table options = {}
+				set_shard_name options[:name]
+				self.hash_key = options[:hash_key] unless options[:hash_key].nil?
+				self.range_key = options[:range_key] unless options[:range_key].nil?
+			end
+
+			#
+			# TABLE STRUCTURE HELPERS
+			#
+
+			def field key, type, options = {}
+				method_name = "#{type.to_s}_attr".to_sym
+				puts "CALLING #{method_name}"
+				send method_name, key, options
+			end
+
+			def initial_througput options = {}
+				self.read_capacity = options[:read_capacity]
+				self.write_capacity = options[:write_capacity]
+			end
+
+			def read_capacity
+				@read_capacity || 10
+			end
+
+			def write_capacity
+				@write_capacity || 10
+			end
+
+		end
+	end
+end

data/lib/minidynamo/model/dynamo_db_overloads.rb

@@ -0,0 +1,71 @@
+module Minidynamo
+	class Model
+		module DynamoDBOverloads
+
+			def self.extended base
+				base.send(:extend, ClassMethods)
+				base.send(:include, InstanceMethods)
+			end
+
+			module ClassMethods
+
+				# Changed: Don't accept parameters when creating, use the declared options
+				# inside the model
+				def create_table
+					create_opts = {}
+					create_opts[:hash_key] = hash_key
+					create_opts[:range_key] = range_key if range_key
+
+					dynamo_db.tables.create   dynamo_db_table_name,
+					read_capacity,
+					write_capacity,
+					create_opts
+				end
+
+				# @return [DynamoDB::Table]
+				# changed to use hash key other than id
+				# @api private
+				def dynamo_db_table shard_name = nil
+					table = dynamo_db.tables[dynamo_db_table_name(shard_name)]
+					table.hash_key = hash_key #[:id, :string]
+					table.range_key = range_key if range_key
+
+					#table.hash_key = {:public_token => :string }
+					#table.range_key = {:created_at => :string }
+
+					#table.hash_key = [:public_token, :string]
+					#table.range_key = [:created_at, :string]
+					table
+				end
+
+
+			end
+
+			module InstanceMethods
+
+				def serialize_current attr_name
+					serialized_value = attributes[attr_name]
+					attr_object = self.class.attribute_for(attr_name)
+					serialize_attribute attr_object, serialized_value
+				end
+
+				# @return [DynamoDB::Item] Returns a reference to the item as stored in
+				#   simple db.
+				# obtain items ALSO if there's a range key
+				# @api private
+				private
+				def dynamo_db_item
+					hash_value = serialize_current self.class.hash_key_attribute_name
+					if self.class.range_key
+						range_value = serialize_current self.class.range_key_attribute_name
+						dynamo_db_table.items[hash_value, range_value]
+					else
+						dynamo_db_table.items[hash_value]
+					end
+				end
+
+			end
+
+		end
+	end
+end

data/lib/minidynamo/model/finder_overloads.rb

@@ -0,0 +1,74 @@
+module Minidynamo
+	class Model
+		module FinderOverloads
+
+			def find_by_id id, options = {}
+
+				table = dynamo_db_table(options[:shard])
+
+				data = table.items[id].attributes.to_h
+
+				raise RecordNotFound, "no data found for id: #{id}" if data.empty?
+
+				obj = self.new(:shard => table)
+				obj.send(:hydrate, id, data)
+				obj
+			end
+
+			alias_method :[], :find_by_id
+			
+			#def find *args
+			#	new_scope.find(*args)
+			#end
+
+			def find *args
+				# If find(id), determine wether a query or regular find will work
+				# convert the first argument to integer, if it's a string it'll yield 0
+
+				# if the first argument is an integer and this is a table with range as main key
+				if args.length == 1 && !args[0].is_a?(Symbol) && hash_range_table?
+					items = rangeless_query args[0]
+					case items.length
+					when 0
+						raise AWS::Record::RecordNotFound, "no data found for #{hash_key_attribute}: #{args[0]}"  
+					when 1
+						return items[0]
+					else
+						return items
+					end
+				end
+
+				#in any other case fall back to the default HashModel
+				new_scope.find(*args)
+			end
+
+			def rangeless_query(*args)
+				hkv = args[0]
+				result = dynamo_db.client.query 	:table_name => dynamo_db_table_name, 
+											:consistent_read => true, 
+											:hash_key_value => {hash_key_type => hkv} 
+
+				# Convert the result to items
+				hashed_items = result["Items"]
+				items = []
+
+				hashed_items.each do |i|
+					i_data = {}
+					i.each do |k,v|
+						# Obtain the first key for the hash describing the value of a DDB column
+						k_data_type = i[k].keys[0]
+						i_data[k] = i[k][k_data_type]
+					end
+					#puts "SEL CLASS #{self.class}"
+
+					pt = new
+					pt.send :hydrate, i_data["id"], i_data
+					items << pt
+				end
+
+				items
+			end
+
+		end
+	end
+end

data/lib/minidynamo/model/keys.rb

@@ -0,0 +1,45 @@
+module Minidynamo
+	class Model
+		module Keys
+
+			# For all the fields with defaults
+			attr_writer :write_capacity, :read_capacity
+
+			attr_accessor :range_key
+
+			def hash_key
+				@hash_key || {:id => :string}
+			end
+
+			def hash_key=(key)
+				@hash_key = key
+				hk = key.keys[0]
+				finder_method_name = "find_by_#{hk}".to_sym           
+				self.define_singleton_method finder_method_name do |x|
+					find_by_id x
+				end
+				type = key[hk]
+				attribute_creator_method_name = "#{type.to_s}_attr".to_sym
+				
+				send attribute_creator_method_name, hk unless attribute_creator_method_name == :find_by_id
+			end
+
+			def hash_key_attribute_name
+				hash_key.keys[0]
+			end
+
+			def range_key_attribute_name
+				range_key.keys[0]
+			end
+
+			def hash_key_type
+				dynamo_db_table.hash_key.type.to_s.chars.first.to_sym
+			end
+			
+			def hash_range_table?
+				! range_key.nil?
+			end
+
+		end
+	end
+end

data/minidynamo.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "minidynamo"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Pelaez"]
+  s.date = "2013-06-14"
+  s.description = "Monkey patch for AWS ruby SDK HashModel to support model backed by DynamoDB tables with hash-range keys. It also provides some convenience methods to define your model in a more expressive rails style."
+  s.email = "info@vlipco.co"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/minidynamo.rb",
+    "lib/minidynamo/check_digit.rb",
+    "lib/minidynamo/model.rb",
+    "lib/minidynamo/model/definition_helpers.rb",
+    "lib/minidynamo/model/dynamo_db_overloads.rb",
+    "lib/minidynamo/model/finder_overloads.rb",
+    "lib/minidynamo/model/keys.rb",
+    "minidynamo.gemspec",
+    "model2.rb",
+    "test/helper.rb",
+    "test/test_minidynamo.rb"
+  ]
+  s.homepage = "http://github.com/vlipco/minidynamo"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "AWS SDK HashModel extension to support DynamoDB tables with hash-range keys"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<aws-sdk>, ["~> 1.11.2"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+    else
+      s.add_dependency(%q<aws-sdk>, ["~> 1.11.2"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    end
+  else
+    s.add_dependency(%q<aws-sdk>, ["~> 1.11.2"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+  end
+end
+

data/model2.rb

@@ -0,0 +1,199 @@
+require 'aws-sdk'
+
+def precede_with_check(x)
+	check_digit = CheckDigit.calculate_check_digit(x)
+	"#{check_digit}#{x}"
+end
+
+
+module Minidynamo
+
+
+	# Wrap some HashModel behaviour and offers minor overrides for readability
+	# and to create tables using ranges.
+	class Model < AWS::Record::HashModel
+
+		class << self
+
+			# For all the fields with defaults
+			attr_writer :write_capacity, :read_capacity
+
+			attr_accessor :range_key
+
+			# Use the client table creator instead of the HashModel inheritance
+			def create_table
+				# TODO verify it's not already created
+
+	          create_opts = {}
+	          create_opts[:hash_key] = hash_key
+	          create_opts[:range_key] = range_key if range_key
+	          
+
+	          dynamo_db.tables.create 	dynamo_db_table_name,
+							            read_capacity,
+							            write_capacity,
+							            create_opts
+
+	        end
+
+	        # Obtain the DynamoDB status of a table
+	        def status
+	        end
+
+	        def count_total
+	        	
+	        	initial_q = dynamo_db.client.scan 	:table_name => dynamo_db_table_name, 
+		        									:count => true
+	        	count = initial_q["Count"]
+	        	if initial_q["LastEvaluatedKey"]
+	        		last = initial_q["LastEvaluatedKey"]
+		        	begin 
+		        		q = dynamo_db.client.scan 	:table_name => dynamo_db_table_name, 
+		        									:count => true,
+		        									:exclusive_start_key => last
+		        		count += q["Count"]
+		        		last = q["LastEvaluatedKey"]
+		        	end while last
+		        end
+		        count
+	        	
+			end
+
+			def ddb_client
+				@client ||= AWS::DynamoDB.new.client
+			end
+
+	        
+
+	        #
+	        # TABLE THROUGHPUT HELPERS
+	        #
+
+	        def initial_througput options = {}
+	        	self.read_capacity = options[:read_capacity]
+	        	self.write_capacity = options[:write_capacity]
+	        end
+
+	        def read_capacity
+				@read_capacity || 10
+	        end
+
+	        def write_capacity
+	        	@write_capacity || 10
+	        end
+
+	        def hash_key
+	        	@hash_key || {:id => :string}
+	        end
+
+	        def table options = {}
+	        	set_shard_name options[:name]
+	        	self.hash_key = options[:hash_key] unless options[:hash_key].nil?
+	        	self.range_key = options[:range_key] unless options[:range_key].nil?
+	        end
+
+	        #
+	        # TABLE STRUCTURE HELPERS
+	        #
+
+	        def field key, type, options = {}
+	        	method_name = "#{type.to_s}_attr".to_sym
+	        	puts "CALLING #{method_name}"
+	        	send method_name, key, options
+	        end
+
+	        def hash_key=(key)
+	        	@hash_key = key
+	        	hk = key.keys[0]
+	        	finder_method_name = "find_by_#{hk}".to_sym	        	
+				self.define_singleton_method finder_method_name do |x|
+					find_by_id x
+				end
+				type = key[hk]
+				attribute_creator_method_name = "#{type.to_s}_attr".to_sym
+				puts "CREATING HASH KEY ATTR #{attribute_creator_method_name}"
+				send attribute_creator_method_name, hk
+			end
+
+	        # OVERLOAD THE FINDER TO USE CUSTOM HASK KEYS IN ERRORS
+
+	        alias_method :_find_by_id, :find_by_id
+	        alias_method :_find, :find
+
+#data = table.items[id].attributes.to_h
+#
+#raise RecordNotFound, "no data found for id: #{id}" if data.empty?
+#
+#obj = self.new(:shard => table)
+#obj.send(:hydrate, id, data)
+#obj
+#
+#.query :table_name => "sample-table", :consistent_read => true, :hash_key_value => {:s => "123"} 
+
+	        def find *args
+	        	# If find(id), determine wether a query or regular find will work
+	        	# convert the first argument to integer, if it's a string it'll yield 0
+	        	
+	        	# if the first argument is an integer and this is a table with range as main key
+	        	if args.length == 1 && !args[0].is_a?(Symbol) && hash_range_table?
+	        		items = rangeless_query args[0]
+	        		case items.length
+	        		when 0
+	        			raise AWS::Record::RecordNotFound, "no data found for #{hash_key.keys[0]}: #{args[0]}"  
+	        		when 1
+	        			return items[0]
+	        		else
+	        			return items
+	        		end
+          		end
+
+          		#in any other case fall back to the default HashModel
+          		new_scope.find(*args)
+        	end
+
+        	# converts string > s, numeric > n
+        	def hash_key_type
+	        	dynamo_db_table.hash_key.type.to_s.chars.first.to_sym
+        	end
+
+        	def rangeless_query(*args)
+        		# Map to string if that's the case. For any other type of hash_key
+        		# you will have to provide the converted value or errors might appear
+        		hash_key_type == :s ? hkv = args[0].to_s : hkv = args[0]
+        		result = dynamo_db.client.query :table_name => dynamo_db_table_name, 
+        								:consistent_read => true, 
+        								:hash_key_value => {hash_key_type => hkv} 
+
+        		# Convert the result to items
+        		hashed_items = result["Items"]
+        		items = []
+        		hashed_items.each do |i|
+        			i_data = {}
+        			i.each do |k,v|
+        				# Obtain the first key for the hash describing the value of a DDB column
+        				k_data_type = i[k].keys[0]
+	        			i_data[k] = i[k][k_data_type]
+	        		end
+	        		pt = PublicToken.new
+	        		pt.send :hydrate, i_data["id"], i_data
+	        		items << pt
+	        	end
+        		items
+        	end
+
+        	def hash_range_table?
+        		! hash_key.nil?
+        	end
+
+	        def find_by_id *args
+	        	begin
+	        		hash_range_table? ? rangeless_query(args) : _find_by_id(args)
+					
+				rescue AWS::Record::RecordNotFound
+					raise AWS::Record::RecordNotFound, "no data found for #{hash_key}: #{id}" 
+				end
+	        end
+
+	    end
+	end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'minidynamo'
+
+class Test::Unit::TestCase
+end

data/test/test_minidynamo.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestMinidynamo < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: minidynamo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David Pelaez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: Monkey patch for AWS ruby SDK HashModel to support model backed by DynamoDB
+  tables with hash-range keys. It also provides some convenience methods to define
+  your model in a more expressive rails style.
+email: info@vlipco.co
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/minidynamo.rb
+- lib/minidynamo/check_digit.rb
+- lib/minidynamo/model.rb
+- lib/minidynamo/model/definition_helpers.rb
+- lib/minidynamo/model/dynamo_db_overloads.rb
+- lib/minidynamo/model/finder_overloads.rb
+- lib/minidynamo/model/keys.rb
+- minidynamo.gemspec
+- model2.rb
+- test/helper.rb
+- test/test_minidynamo.rb
+homepage: http://github.com/vlipco/minidynamo
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: AWS SDK HashModel extension to support DynamoDB tables with hash-range keys
+test_files: []
+has_rdoc: