ocean-dynamo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 339c58baa4132d2d0b311087fbad549938a548b0
+  data.tar.gz: 070fcef8bb7d01c0b7bb1f1151389cae94388b51
+SHA512:
+  metadata.gz: 421fae8d3ff273f4218fa6f4607a6d0538a36ab33490128d716ec8eb1e243333e9590f07a981e426eec8680af4860b2cafc12904b54c0117510c3f0ba4c9a4a8
+  data.tar.gz: 0c7062fab4972a0008cc8e71078d407f4945fcf428a0f0bec36a268ca77ef94618db4abf8bd6bf6bcbf08049b45b60cc1c8fcaf7837bed43eaacdac83e88ae85

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Peter Bengtson
+
+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.rdoc

@@ -0,0 +1,103 @@
+== ocean-dynamo
+
+This is the OceanDynamo ruby gem, implementing a highly scalable Amazon DynamoDB 
+near drop-in replacement for ActiveRecord.
+
+OceanDynamo requires Ruby 2.0 and Ruby on Rails 4.0.0 or later.
+
+{<img src="https://badge.fury.io/rb/ocean-dynamo.png" alt="Gem Version" />}[http://badge.fury.io/rb/ocean-dynamo]
+
+
+==== Features
+
+OceanDynamo will use secondary indices to retrieve related table items, 
+which means it will scale without limits. (NB: this is a pre-release which as yet doesn't
+implement relations, but they are underway.)
+
+As one important use case for OceanDynamo is to facilitate the conversion of SQL based
+ActiveRecord models to DynamoDB based models, it is important that the syntax and semantics
+of OceanDynamo's operations are as close as possible to those of ActiveRecord. This means
+that all callbacks should be available, before, around and after, and that they should be
+called in the same order as in ActiveRecord. OceanDynamo follows this pattern closely and
+is of course based on ActiveModel.
+
+The attribute and persistence layer of OceanDynamo is modeled on that of ActiveRecord:
+there's +save+, +save!+, +create+, +update+, +update!+, +update_attribute+ and all the other
+methods you're used to. The design goal is always to implement as much as possible of the
+ActiveRecord interface, without sacrificing scalability. This makes the task of switching from
+SQL to no-SQL much easier.
+
+
+=== Documentation
+
+* Ocean-dynamo gem API: http://rdoc.info/github/OceanDev/ocean-dynamo/frames
+* Ocean-dynamo gem on Rubygems: https://rubygems.org/gems/ocean-dynamo
+* Ocean-dynamo source and wiki: https://github.org/OceanDev/ocean-dynamo
+
+See also Ocean, a Rails framework for creating highly scalable SOAs in the cloud, in which
+OceanDynamo is used as a central component:
+* http://wiki.oceanframework.net
+
+
+=== Running the specs
+
+To run the specs for the OceanDynamo gem, you must first install the bundle. It will download
+a gem called +fake_dynamo+, which runs a local, in-memory functional clone of Amazon DynamoDB.
+We use +fake_dynamo+ during development and testing.
+
+First of all, copy the AWS configuration file from the template:
+
+ cp spec/dummy/config/aws.yml.example spec/dummy/config/aws.yml
+
+NB: +aws.yml+ is excluded from source control. This allows you to enter your AWS credentials
+safely. Note that +aws.yml.example+ is under source control: don't edit it.
+
+Make sure your have version 0.1.3 of the +fake_dynamo+ gem. It implements the +2011-12-05+ version
+of the DynamoDB API. We're not yet using the +2012-08-10+ version, as the +aws-sdk+ ruby gem
+doesn't fully support it. We'll make the change as soon as +aws-sdk+ is updated. Reportedly,
+it's in the works.
+
+Next, start +fake_dynamo+:
+
+  fake_dynamo --port 4567
+
+If this returns errors, make sure that <tt>/usr/local/var/fake_dynamo</tt> exists and
+is writable:
+
+ sudo mkdir -p /usr/local/var/fake_dynamo
+ sudo chown peterb:staff /usr/local/var/fake_dynamo
+
+When +fake_dynamo+ runs normally, open another window and issue the following command:
+
+ curl -X DELETE http://localhost:4567
+
+This will reset the +fake_dynamo+ database. It's not a required operation when starting
++fake_dynamo+; we're just using it here as a test that the installation works. It will
+be issued automatically as part of the test suite, so don't expect test data to survive
+between runs.
+
+With +fake_dynamo+ running, you should now be able to do
+
+ rspec
+
+All tests should pass.
+
+
+=== Rails console
+
+The Rails console is available from the built-in dummy application:
+
+ cd spec/dummy
+ rails console
+
+You may need to initialise the table connection (for each table):
+
+ CloudModel.establish_db_connection
+
+This will, amongst other things, also create the CloudModel table if it doesn't already
+exist. On Amazon, this will take a little while. With +fake_dynamo+, it's practically
+instant.
+
+When you leave the console, you must navigate back to the top directory (<tt>cd ../..</tt>)
+in order to be able to run RSpec again.
+

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Ocean'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+
+end

data/lib/ocean-dynamo.rb

@@ -0,0 +1,9 @@
+require "ocean-dynamo/engine"
+
+require "ocean-dynamo/dynamo"
+
+
+module OceanDynamo
+
+  
+end

data/lib/ocean-dynamo/dynamo.rb

@@ -0,0 +1,538 @@
+
+require "aws-sdk"
+
+module OceanDynamo
+
+  DEFAULT_FIELDS = [
+    [:created_at,   :datetime], 
+    [:updated_at,   :datetime],
+    [:lock_version, :integer, default: 0]
+  ]
+
+  class DynamoError < StandardError; end
+
+  class NoPrimaryKeyDeclared < DynamoError; end
+  class UnknownTableStatus < DynamoError; end
+  class UnsupportedType < DynamoError; end
+  class RecordInvalid < DynamoError; end
+  class RecordNotSaved < DynamoError; end
+  class RecordNotFound < DynamoError; end
+  class RecordInConflict < DynamoError; end
+
+
+  class Base
+
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+
+    # ---------------------------------------------------------
+    #
+    #  Class variables and methods
+    #
+    # ---------------------------------------------------------
+
+    class_attribute :dynamo_client, instance_writer: false
+    class_attribute :dynamo_table, instance_writer: false
+    class_attribute :dynamo_items, instance_writer: false
+
+    class_attribute :table_name, instance_writer: false
+    class_attribute :table_name_prefix, instance_writer: false
+    class_attribute :table_name_suffix, instance_writer: false
+
+    class_attribute :table_hash_key, instance_writer: false
+    class_attribute :table_range_key, instance_writer: false
+
+    class_attribute :table_read_capacity_units, instance_writer: false
+    class_attribute :table_write_capacity_units, instance_writer: false
+
+    class_attribute :fields, instance_writer: false
+
+
+    def self.set_table_name(name)
+      self.table_name = name
+    end
+
+    def self.set_table_name_prefix(prefix)
+      self.table_name_prefix = prefix
+    end
+
+    def self.set_table_name_suffix(suffix)
+      self.table_name_suffix = suffix
+    end
+
+
+    def self.compute_table_name
+      name.pluralize.underscore
+    end
+
+
+    def self.table_full_name
+      "#{table_name_prefix}#{table_name}#{table_name_suffix}"
+    end
+
+
+    def self.primary_key(hash_key, range_key=nil)
+      self.table_hash_key = hash_key
+      self.table_range_key = range_key
+      # Find a better place to do the following initialisation:
+      set_table_name compute_table_name unless self.table_name
+      nil
+    end
+
+
+    def self.read_capacity_units(units)
+      self.table_read_capacity_units = units
+    end
+
+
+    def self.write_capacity_units(units)
+      self.table_write_capacity_units = units
+    end
+
+
+    def self.field(name, type=:string, **pairs)
+      attr_accessor name
+      fields[name] = {type:    type, 
+                      default: pairs[:default]}
+    end
+
+
+    def self.establish_db_connection
+      setup_dynamo      
+      if dynamo_table.exists?
+        wait_until_table_is_active
+      else
+        create_table
+      end
+      set_dynamo_table_keys
+    end
+
+
+    def self.setup_dynamo
+      #self.dynamo_client = AWS::DynamoDB::Client.new(:api_version => '2012-08-10') 
+      self.dynamo_client ||= AWS::DynamoDB.new
+      self.dynamo_table = dynamo_client.tables[table_full_name]
+      self.dynamo_items = dynamo_table.items
+    end
+
+
+    def self.wait_until_table_is_active
+      loop do
+        case dynamo_table.status
+        when :active
+          set_dynamo_table_keys
+          return
+        when :updating, :creating
+          sleep 1
+          next
+        when :deleting
+          sleep 1 while dynamo_table.exists?
+          create_table
+          return
+        else
+          raise UnknownTableStatus.new("Unknown DynamoDB table status '#{dynamo_table.status}'")
+        end
+        sleep 1
+      end
+    end
+
+
+    def self.set_dynamo_table_keys
+      dynamo_table.hash_key = [table_hash_key, fields[table_hash_key][:type]]
+      if table_range_key
+        dynamo_table.range_key = [table_range_key, fields[table_range_key][:type]]
+      end
+    end
+
+
+    def self.create_table
+      self.dynamo_table = dynamo_client.tables.create(table_full_name, 
+        table_read_capacity_units, table_write_capacity_units,
+        hash_key: { table_hash_key => fields[table_hash_key][:type]},
+        range_key: table_range_key && { table_range_key => fields[table_range_key][:type]}
+        )
+      sleep 1 until dynamo_table.status == :active
+      setup_dynamo
+      true
+    end
+
+    def self.delete_table
+      return false unless dynamo_table.exists? && dynamo_table.status == :active
+      dynamo_table.delete
+      true
+    end
+
+
+    def self.create(attributes = nil, &block)
+      object = new(attributes)
+      yield(object) if block_given?
+      object.save
+      object
+    end
+
+
+    def self.create!(attributes = nil, &block)
+      object = new(attributes)
+      yield(object) if block_given?
+      object.save!
+      object
+    end
+
+
+    def self.find(hash, range=nil, consistent: false)
+      item = dynamo_items[hash, range]
+      raise RecordNotFound unless item.exists?
+      new.send(:post_instantiate, item, consistent)
+    end
+
+
+    def self.delete(hash, range=nil)
+      item = dynamo_items[hash, range]
+      return false unless item.exists?
+      item.delete
+      true
+    end
+
+
+    def self.count
+      dynamo_table.item_count || -1    # The || -1 is for fake_dynamo specs.
+    end
+
+
+    # ---------------------------------------------------------
+    #
+    #  Callbacks
+    #
+    # ---------------------------------------------------------
+
+    define_model_callbacks :initialize, only: :after
+    define_model_callbacks :save
+    define_model_callbacks :create
+    define_model_callbacks :update
+    define_model_callbacks :destroy
+    define_model_callbacks :commit, only: :after
+    define_model_callbacks :touch
+
+
+    # ---------------------------------------------------------
+    #
+    #  Class initialisation, done once at load time
+    #
+    # ---------------------------------------------------------
+
+    self.table_read_capacity_units = 10
+    self.table_write_capacity_units = 5
+
+    self.fields = HashWithIndifferentAccess.new
+    DEFAULT_FIELDS.each { |k, name, **pairs| Base.field k, name, **pairs }
+
+
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
+
+    attr_reader :attributes
+    attr_reader :destroyed
+    attr_reader :new_record
+    attr_reader :dynamo_item
+
+
+    def initialize(attributes={})
+      run_callbacks :initialize do
+        @attributes = HashWithIndifferentAccess.new
+        fields.each do |name, v| 
+          write_attribute(name, evaluate_default(v[:default])) unless read_attribute(name)
+          self.class.class_eval "def #{name}; read_attribute('#{name}'); end"
+          self.class.class_eval "def #{name}=(value); write_attribute('#{name}', value); end"
+          if fields[name][:type] == :boolean
+            self.class.class_eval "def #{name}?; read_attribute('#{name}'); end"
+          end
+        end
+        super
+        @dynamo_item = nil
+        @destroyed = false
+        @new_record = true
+        raise NoPrimaryKeyDeclared unless table_hash_key
+      end
+    end
+
+
+    def read_attribute(name)
+      @attributes[name]
+    end
+
+
+    def write_attribute(name, value)
+      @attributes[name] = value
+    end
+
+
+    def [](attribute)
+      read_attribute attribute
+    end
+
+
+    def []=(attribute, value)
+      write_attribute attribute, value
+    end
+
+
+    def id
+      read_attribute(table_hash_key)
+    end
+
+
+    def id=(value)
+      write_attribute(table_hash_key, value)
+    end
+
+
+    def to_key
+      return nil unless persisted?
+      key = respond_to?(:id) && id
+      key ? [key] : nil
+    end
+
+
+
+    def assign_attributes(values)
+      values.each do |k, v|
+        send("#{k}=", v)
+      end
+    end
+
+
+    def serialized_attributes
+      result = {}
+      fields.each do |attribute, metadata|
+        serialized = serialize_attribute(attribute, read_attribute(attribute), metadata)
+        result[attribute] = serialized unless serialized == nil
+      end
+      result
+    end
+
+
+    def serialize_attribute(attribute, value, 
+                            metadata=fields[attribute],
+                            type: metadata[:type],
+                            default: metadata[:default])
+      return nil if value == nil
+      case type
+      when :string
+        value == "" ? nil : value
+      when :integer
+        value
+      when :float
+        value
+      when :boolean
+        value ? "true" : "false"
+      when :datetime
+        value.to_i
+      when :serialized
+        value.to_json
+      else
+        raise UnsupportedType.new(type.to_s)
+      end
+    end
+
+
+    def deserialized_attributes(consistent_read: false, hash: nil)
+      hash ||= dynamo_item.attributes.to_hash(consistent_read: consistent_read)
+      result = {}
+      fields.each do |attribute, metadata|
+        result[attribute] = deserialize_attribute(hash[attribute], metadata)
+      end
+      result
+    end
+
+
+    def deserialize_attribute(value, metadata, 
+                              type: metadata[:type], 
+                              default: metadata[:default])
+      if value == nil && default != nil && type != :string
+        return evaluate_default(default)
+      end
+      case type
+      when :string
+        return "" if value == nil
+        value
+      when :integer
+        return nil if value == nil
+        value.is_a?(Array) ? value.collect(&:to_i) : value.to_i
+      when :float
+        return nil if value == nil
+        value.is_a?(Array) ? value.collect(&:to_f) : value.to_f
+      when :boolean
+        case value
+        when "true"
+          true
+        when "false"
+          false
+        else
+          nil
+        end
+      when :datetime
+        return nil if value == nil
+        Time.at(value.to_i)
+      when :serialized
+        return nil if value == nil
+        JSON.parse(value)
+      else
+        raise UnsupportedType.new(type.to_s)
+      end
+    end
+
+
+    def destroyed?
+      @destroyed
+    end
+
+
+    def new_record?
+      @new_record
+    end
+
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+
+    def save
+      begin
+        create_or_update
+      rescue RecordInvalid
+        false
+      end
+    end
+
+
+    def save!(*)
+      create_or_update || raise(RecordNotSaved)
+    end
+
+
+    def update_attributes(attributes={})
+      assign_attributes(attributes)
+      save
+    end
+
+
+    def update_attributes!(attributes={})
+      assign_attributes(attributes)
+      save!
+    end
+
+
+    def create_or_update
+      result = new_record? ? create : update
+      result != false
+    end
+
+
+    def create
+      return false unless valid?(:create)
+      run_callbacks :commit do
+        run_callbacks :save do
+          run_callbacks :create do
+            write_attribute(table_hash_key, SecureRandom.uuid) if read_attribute(table_hash_key) == nil
+            t = Time.now
+            self.created_at ||= t
+            self.updated_at ||= t
+            dynamo_persist
+            true
+          end
+        end
+      end
+    end
+
+
+    def update
+      return false unless valid?(:update)
+      run_callbacks :commit do
+        run_callbacks :save do
+          run_callbacks :update do
+            self.updated_at = Time.now
+            dynamo_persist
+            true
+          end
+        end
+      end
+    end
+
+    def destroy
+      run_callbacks :commit do
+        run_callbacks :destroy do
+          delete
+        end
+      end
+    end
+
+
+    def delete
+      if persisted?
+        @dynamo_item.delete
+      end
+      @destroyed = true
+      freeze
+    end
+
+
+    def reload(**keywords)
+      range_key = table_range_key && attributes[table_range_key]
+      new_instance = self.class.find(id, range_key, **keywords)
+      assign_attributes(new_instance.attributes)
+      self
+    end
+
+
+    def touch(name=nil)
+      run_callbacks :touch do
+        attrs = [:updated_at]
+        attrs << name if name
+        t = Time.now
+        attrs.each { |k| write_attribute name, t }
+        # TODO: handle lock_version
+        dynamo_item.attributes.update do |u|
+          attrs.each do |k|
+            u.set(k => serialize_attribute(k, t))
+          end
+        end
+        self
+      end
+    end
+
+
+
+    protected
+
+    def evaluate_default(v)
+      return v.call if v.is_a?(Proc)
+      return v.clone if v.is_a?(Array) || v.is_a?(String)   # Instances need their own copy
+      v
+    end
+
+
+    def dynamo_persist
+      @dynamo_item = dynamo_items.put(serialized_attributes)
+      @new_record = false
+    end
+
+
+    def post_instantiate(item, consistent)
+      @dynamo_item = item
+      @new_record = false
+      assign_attributes(deserialized_attributes(
+        hash: nil,
+        consistent_read: consistent)
+      )
+      self
+    end
+
+  end # Base
+
+end # Dynamo
+

data/lib/ocean-dynamo/engine.rb

@@ -0,0 +1,6 @@
+module OceanDynamo
+  class Engine < ::Rails::Engine
+    config.generators.integration_tool :rspec
+    config.generators.test_framework :rspec
+  end
+end

data/lib/ocean-dynamo/version.rb

@@ -0,0 +1,3 @@
+module OceanDynamo
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: ocean-dynamo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Bengtson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: fake_dynamo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+description: "== ocean-dynamo\n\nThis is the OceanDynamo ruby gem, implementing a
+  highly scalable Amazon DynamoDB near drop-in \nreplacement for ActiveRecord.\n\nOceanDynamo
+  will use secondary indices to retrieve related table items, \nwhich means it will
+  scale without limits. (NB: this is a pre-release which as yet doesn't\nimplement
+  relations, but they are underway.)\n\nAs one important use case for OceanDynamo
+  is to facilitate the conversion of SQL based\nActiveRecord models to DynamoDB based
+  models, it is important that the syntax and semantics\nof OceanDynamo's operations
+  are as close as possible to those of ActiveRecord. This means\nthat all callbacks
+  should be available, before, around and after, and that they should be\ncalled in
+  the same order as in ActiveRecord. Ocean-dynamo follows this pattern closely and\nis
+  of course based on ActiveModel.\n\nThe attribute and persistence layer of OceanDynamo
+  is modeled on that of ActiveRecord:\nthere's +save+, +save!+, +create+, +update+,
+  +update!+, +update_attribute+ and all the other\nmethods you're used to. The design
+  goal is always to implement as much as possible of the\nActiveRecord interface,
+  without sacrificing scalability. This makes the task of switching from\nSQL to no-SQL
+  much easier.\n\nSee also Ocean, a Rails framework for creating highly scalable SOAs
+  in the cloud, in which\nocean-dynamo is used as a central component: http://wiki.oceanframework.net"
+email:
+- peter@peterbengtson.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/routes.rb
+- lib/ocean-dynamo/dynamo.rb
+- lib/ocean-dynamo/engine.rb
+- lib/ocean-dynamo/version.rb
+- lib/ocean-dynamo.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: https://github.com/OceanDev/ocean-dynamo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: This gem implements common Ocean behaviour for Ruby and Ruby on Rails.
+test_files: []