Dynamoid 0.0.1

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+gem 'activemodel'
+gem 'tzinfo'
+gem 'aws-sdk'
+
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "mocha"
+  gem "rake"
+  gem "rspec"
+  gem "bundler"
+  gem "jeweler"
+  gem "rcov"
+end

data/Gemfile.lock

@@ -0,0 +1,58 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.3)
+      activesupport (= 3.1.3)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    aws-sdk (1.3.5)
+      httparty (~> 0.7)
+      json (~> 1.4)
+      nokogiri (>= 1.4.4)
+      uuidtools (~> 2.1)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    httparty (0.8.1)
+      multi_json
+      multi_xml
+    i18n (0.6.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    json (1.6.5)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.0.4)
+    multi_xml (0.4.1)
+    nokogiri (1.5.0)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    tzinfo (0.3.31)
+    uuidtools (2.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel
+  aws-sdk
+  bundler
+  jeweler
+  mocha
+  rake
+  rcov
+  rspec
+  tzinfo

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Synthetic LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,66 @@
+# Dynamoid
+
+Dynamoid is an ORM for Amazon's DynamoDB for Ruby applications. It provides similar functionality to ActiveRecord and improves on Amazon's existing [HashModel](http://docs.amazonwebservices.com/AWSRubySDK/latest/AWS/Record/HashModel.html) by providing better searching tools, native association support, and a local adapter for offline development.
+
+## Warning!
+
+I'm still working on this gem a lot. Associations aren't working and that's a bummer, and you can only use the old-school ActiveRecord style finders like ```find_all_by_<attribute_name>``` or directly finding by an ID.
+
+## Usage
+
+Using Dynamoid is pretty simple. First you need to initialize it to get it going, so put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
+
+```ruby
+  Dynamoid.configure do |config|
+    config.adapter = 'local' # This adapter allows offline development without connecting to the DynamoDB servers.
+    # config.adapter = 'aws_sdk' # This adapter establishes a connection to the DynamoDB servers using's Amazon's own awful AWS gem.
+    # config.access_key = 'access_key' # If connecting to DynamoDB, your access key is required.
+    # config.secret_key = 'secret_key' # So is your secret key. 
+    config.namespace = "dynamoid_#{Rails.application.class.parent_name}_#{Rails.env}" # To namespace tables created by Dynamoid from other tables you might have.
+    config.warn_on_scan = true # Output a warning to stdout when you perform a scan rather than a query on a table
+  end
+
+```
+
+Inside your model:
+
+```ruby
+class User
+   include Dynamoid::Document
+   
+   field :name
+   field :email
+   
+   index :name
+   index :email
+   index [:name, :email]
+   
+end
+```
+
+Right now, you can only do a couple things with this amazing functionality:
+
+```ruby
+u = User.new(:name => 'Josh')
+u.email = 'josh@joshsymonds.com'
+u.save
+
+u == User.find(u.id)
+u == User.find_by_name('Josh')
+u == User.find_by_name_and_email('Josh','josh@joshsymonds.com')
+```
+
+Not super exciting yet, true... but it's getting there!
+
+## Credits
+
+Dynamoid borrows code, structure, and even its name very liberally from the truly amazing [Mongoid](https://github.com/mongoid/mongoid). Without Mongoid to crib from none of this would have been possible, and I hope they don't mind me reusing their very awesome ideas to make DynamoDB just as accessible to the Ruby world as MongoDB.
+
+## Running the tests
+
+The tests can be run in the simple predictable way with ```rake```. However, if you provide environment variables for ACCESS_KEY and SECRET_KEY, the tests will use the aws_sdk adapter rather than the local adapter: ```ACCESS_KEY=<accesskey> SECRET_KEY=<secretkey> rake```. Keep in mind this takes much, much longer than the local tests.
+
+## Copyright
+
+Copyright (c) 2012 Josh Symonds. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# 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 = "Dynamoid"
+  gem.homepage = "http://github.com/Veraticus/Dynamoid"
+  gem.license = "MIT"
+  gem.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
+  gem.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
+  gem.email = "josh@joshsymonds.com"
+  gem.authors = ["Josh Symonds"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+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 = "dynamoid #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/dynamoid.rb

@@ -0,0 +1,31 @@
+require "delegate"
+require "time"
+require "securerandom"
+require "active_support/core_ext"
+require 'active_support/json'
+require "active_support/inflector"
+require "active_support/lazy_load_hooks"
+require "active_support/time_with_zone"
+require "active_model"
+
+require 'dynamoid/errors'
+require 'dynamoid/attributes'
+require 'dynamoid/fields'
+require 'dynamoid/indexes'
+require 'dynamoid/persistence'
+require 'dynamoid/finders'
+require 'dynamoid/config'
+require 'dynamoid/components'
+require 'dynamoid/document'
+require 'dynamoid/adapter'
+
+module Dynamoid
+  extend self
+  
+  def configure
+    block_given? ? yield(Config) : Config
+    Dynamoid::Adapter.reconnect!
+  end
+  alias :config :configure
+  
+end

data/lib/dynamoid/adapter.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Adapter
+    extend self
+    
+    def adapter
+      reconnect! unless @adapter
+      @adapter
+    end
+    
+    def reconnect!
+      require "dynamoid/adapter/#{Dynamoid::Config.adapter}" unless Dynamoid::Adapter.const_defined?(Dynamoid::Config.adapter.camelcase)
+      @adapter = Dynamoid::Adapter.const_get(Dynamoid::Config.adapter.camelcase)
+      @adapter.connect! if @adapter.respond_to?(:connect!)
+    end
+    
+    def method_missing(method, *args)
+      return @adapter.send(method, *args) if @adapter.respond_to?(method)
+      super
+    end
+  end
+  
+end

data/lib/dynamoid/adapter/aws_sdk.rb

@@ -0,0 +1,99 @@
+require 'aws'
+
+module Dynamoid
+  module Adapter
+    module AwsSdk
+      extend self
+      @@connection = nil
+    
+      def connect!
+        @@connection = AWS::DynamoDB.new(:access_key_id => Dynamoid::Config.access_key, :secret_access_key => Dynamoid::Config.secret_key)
+      end
+    
+      def connection
+        @@connection
+      end
+    
+      # BatchGetItem
+      def batch_get_item(options)
+        batch = AWS::DynamoDB::BatchGet.new(:config => @@connection.config)
+        options.each do |t, ids|
+          batch.table(t, :all, Array(ids))
+        end
+        hash = Hash.new{|h, k| h[k] = []}
+        batch.each do |table_name, attributes|
+          hash[table_name] << attributes.symbolize_keys!
+        end
+        hash
+      end
+    
+      # CreateTable
+      def create_table(table_name, key)
+        table = @@connection.tables.create(table_name, 10, 5, :hash_key => {key.to_sym => :string})
+        sleep 0.5 while table.status == :creating
+        return table
+      end
+    
+      # DeleteItem
+      def delete_item(table_name, key)
+        table = @@connection.tables[table_name]
+        table.load_schema
+        result = table.items[key]
+        result.delete unless result.attributes.to_h.empty?
+        true
+      end
+    
+      # DeleteTable
+      def delete_table(table_name)
+        @@connection.tables[table_name].delete
+      end
+    
+      # DescribeTable
+    
+      # GetItem
+      def get_item(table_name, key)
+        table = @@connection.tables[table_name]
+        table.load_schema
+        result = table.items[key].attributes.to_h
+        if result.empty?
+          nil
+        else
+          result.symbolize_keys!
+        end
+      end
+    
+      # ListTables
+      def list_tables
+        @@connection.tables.collect(&:name)
+      end
+    
+      # PutItem
+      def put_item(table_name, object)
+        table = @@connection.tables[table_name]
+        table.load_schema
+        table.items.create(object.delete_if{|k, v| v.nil?})
+      end
+    
+      # Query
+      def query(table_name, id)
+        get_item(table_name, id)
+      end
+    
+      # Scan
+      def scan(table_name, scan_hash)
+        table = @@connection.tables[table_name]
+        table.load_schema
+        results = []
+        table.items.select do |data|
+          attributes = data.attributes.symbolize_keys!
+          results << attributes if scan_hash.all?{|k, v| !attributes[k].nil? && attributes[k] == v}
+        end
+        results
+      end
+    
+      # UpdateItem
+    
+      # UpdateTable
+    end
+  end
+end

data/lib/dynamoid/adapter/local.rb

@@ -0,0 +1,77 @@
+module Dynamoid
+  module Adapter
+    module Local
+      extend self
+      # Gimpy hash that should be somewhat equivalent to what Amazon's actual DynamoDB, for offline development.
+    
+      def data
+        @data ||= {}
+      end
+    
+      def reset_data
+        self.data.each {|k, v| v[:data] = {}}
+      end
+    
+      # BatchGetItem
+      def batch_get_item(options)
+        Hash.new { |h, k| h[k] = Array.new }.tap do |hash|
+          options.each do |table_name, keys|
+            table = data[table_name]
+            Array(keys).each do |key|
+              hash[table_name] << table[:data][key]
+            end
+          end
+        end
+      end
+    
+      # CreateTable
+      def create_table(table_name, key)
+        data[table_name] = {:id => key, :data => {}}
+      end
+    
+      # DeleteItem
+      def delete_item(table_name, key)
+        data[table_name][:data].delete(key)
+      end
+    
+      # DeleteTable
+      def delete_table(table_name)
+        data.delete(table_name)
+      end
+    
+      # DescribeTable
+    
+      # GetItem
+      def get_item(table_name, key)
+        data[table_name][:data][key]
+      end
+    
+      # ListTables
+      def list_tables
+        data.keys
+      end
+    
+      # PutItem
+      def put_item(table_name, object)
+        table = data[table_name]
+        table[:data][object[table[:id]]] = object
+      end
+    
+      # Query
+      def query(table_name, id)
+        get_item(table_name, id)
+      end
+    
+      # Scan
+      def scan(table_name, scan_hash)
+        return [] if data[table_name].nil?
+        data[table_name][:data].values.select{|d| scan_hash.all?{|k, v| !d[k].nil? && d[k] == v}}
+      end
+    
+      # UpdateItem
+    
+      # UpdateTable
+    
+    end
+  end
+end