ocean-dynamo 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73851353b9d6b8bee8d39d16f43cf6006026260f
-  data.tar.gz: d0d20d6ec619909fad2b35e46294be360c964dbd
+  metadata.gz: 2715c40f4987fe7ffe19eecd488bc67b5a9cebb3
+  data.tar.gz: 8fdae13f4f5d71632a0c938588e977807a53ec61
 SHA512:
-  metadata.gz: b41c394e855a63e1afc69968b97a807044ad8cde207607aa77ae63300f121f0b733e463579727d92029d65a5916663f41fe630fc089ad78bd9591214f752d8c7
-  data.tar.gz: 9ecb8bb8b155e5a9aa9f92a8a53675b38e2336df9b5381cfd5242ba0354b60b4f0e1616a2ce377e3e6447509cd5ebdbf65056642f7717f0e43b8c520ea112b6b
+  metadata.gz: b400e19b2a3b2707adfea3e415fe672352fe0e30267992ce14e70b616a7bce0ee1a569396278e0fe675ec2f4a7a4db65e4e7fd922ecd6d5112d7ce4aa5eff240
+  data.tar.gz: a0cc3aa3eb5866d64db1407267e5c9ac63606452eaeda01eb766f24888d6546b33768b80bcb3df6ccf8851f45876106a660026dee48ef7df6e3cd3b151c54610

data/lib/ocean-dynamo.rb

@@ -1,9 +1,24 @@
 require "ocean-dynamo/engine"
 
-require "ocean-dynamo/dynamo"
+require "aws-sdk"
+
+require "ocean-dynamo/base"
+require "ocean-dynamo/exceptions"
+require "ocean-dynamo/class_variables"
+require "ocean-dynamo/tables"
+require "ocean-dynamo/schema"
+require "ocean-dynamo/callbacks"
+require "ocean-dynamo/attributes"
+require "ocean-dynamo/queries"
+require "ocean-dynamo/persistence"
 
 
 module OceanDynamo
 
-  
+  DEFAULT_ATTRIBUTES = [
+    [:created_at,   :datetime], 
+    [:updated_at,   :datetime],
+    [:lock_version, :integer, default: 0]
+  ]
+
 end

data/lib/ocean-dynamo/attributes.rb

@@ -0,0 +1,230 @@
+module OceanDynamo
+  class Base
+    include ActiveModel::DeprecatedMassAssignmentSecurity
+    include ActiveModel::ForbiddenAttributesProtection
+
+    attr_reader :attributes
+    attr_reader :destroyed
+    attr_reader :new_record
+    attr_reader :dynamo_item
+
+
+    def initialize(attrs={})
+      run_callbacks :initialize do
+        @attributes = Hash.new
+        fields.each do |name, md| 
+          write_attribute(name, evaluate_default(md[:default], md[:type]))
+          self.class.class_eval "def #{name}; read_attribute('#{name.to_s}'); end"
+          self.class.class_eval "def #{name}=(value); write_attribute('#{name.to_s}', value); end"
+          if fields[name][:type] == :boolean
+            self.class.class_eval "def #{name}?; read_attribute('#{name.to_s}'); end"
+          end
+        end
+        @dynamo_item = nil
+        @destroyed = false
+        @new_record = true
+        raise UnknownPrimaryKey unless table_hash_key
+      end
+      attrs &&  attrs.delete_if { |k, v| !fields.has_key?(k) }
+      super(attrs)
+    end
+
+
+    def read_attribute_for_validation(key)
+      @attributes[key.to_s]
+    end
+
+
+    def read_attribute(attr_name)
+      attr_name = attr_name.to_s
+      if attr_name == 'id' && fields[table_hash_key] != attr_name.to_sym
+        return read_attribute(table_hash_key)
+      end
+      @attributes[attr_name]   # Type cast!
+    end
+
+
+    def write_attribute(attr_name, value)
+      attr_name = attr_name.to_s
+      attr_name = table_hash_key.to_s if attr_name == 'id' && fields[table_hash_key]
+      if fields.has_key?(attr_name)
+        @attributes[attr_name] = type_cast_attribute_for_write(attr_name, value)
+      else
+        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+      end
+    end
+
+
+    def type_cast_attribute_for_write(name, value, metadata=fields[name],
+                                      type: metadata[:type])
+      case type
+      when :string
+        return nil if value == nil
+        return value.collect(&:to_s) if value.is_a?(Array)
+        value
+      when :integer
+        return nil if value == nil
+        return value.collect(&:to_i) if value.is_a?(Array)
+        value.to_i
+      when :float
+        return nil if value == nil
+        return value.collect(&:to_f) if value.is_a?(Array)
+        value.to_f
+      when :boolean
+        return nil if value == nil
+        return true if value == true
+        return true if value == "true"
+        false
+      when :datetime
+        return nil if value == nil || !value.kind_of?(Time)
+        value
+      when :serialized
+        return nil if value == nil
+        value
+      else
+        raise UnsupportedType.new(type.to_s)
+      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])
+      return nil if value == nil
+      case type
+      when :string
+        ["", []].include?(value) ? nil : value
+      when :integer
+        value == [] ? nil : value
+      when :float
+        value == [] ? nil : 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])
+      case type
+      when :string
+        return "" if value == nil
+        value.is_a?(Set) ? value.to_a : value
+      when :integer
+        return nil if value == nil
+        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_i) : value.to_i
+      when :float
+        return nil if value == nil
+        value.is_a?(Set) || 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.zone.at(value.to_i)
+      when :serialized
+        return nil if value == nil
+        JSON.parse(value)
+      else
+        raise UnsupportedType.new(type.to_s)
+      end
+    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
+      return nil unless key
+      table_range_key ? [key, read_attribute(table_range_key)] : [key]
+    end
+
+
+    def assign_attributes(values)
+      return if values.blank?
+      values = values.stringify_keys
+      # if values.respond_to?(:permitted?)
+      #   unless values.permitted?
+      #     raise ActiveModel::ForbiddenAttributesError
+      #   end
+      # end
+      values.each do |k, v|
+        #send("#{k}=", v)
+        _assign_attribute(k, v)
+      end
+    end
+
+
+    private
+
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v)
+    rescue ActiveModel::NoMethodError
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise ActiveModel::UnknownAttributeError, "unknown attribute: #{k}"
+      end
+    end
+
+
+    protected
+
+    def evaluate_default(default, type)
+      return default.call if default.is_a?(Proc)
+      return "" if default == nil && type == :string
+      return default.clone if default.is_a?(Array) || default.is_a?(String)   # Instances need their own copies
+      default
+    end
+
+  end
+end

data/lib/ocean-dynamo/base.rb

@@ -0,0 +1,8 @@
+module OceanDynamo
+  class Base
+
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+  end
+end

data/lib/ocean-dynamo/callbacks.rb

@@ -0,0 +1,15 @@
+module OceanDynamo
+  class Base
+
+    include ActiveModel::Validations::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
+
+  end
+end

data/lib/ocean-dynamo/class_variables.rb

@@ -0,0 +1,38 @@
+module OceanDynamo
+  class Base
+
+    class_attribute :dynamo_client, instance_writer: false
+    self.dynamo_client = nil
+
+    class_attribute :dynamo_table, instance_writer: false
+    self.dynamo_table = nil
+
+    class_attribute :dynamo_items, instance_writer: false
+    self.dynamo_items = nil
+
+    class_attribute :table_name, instance_writer: false
+    self.table_name = nil
+
+    class_attribute :table_name_prefix, instance_writer: false
+    self.table_name_prefix = nil
+
+    class_attribute :table_name_suffix, instance_writer: false
+    self.table_name_suffix = nil
+
+    class_attribute :table_hash_key, instance_writer: false
+    self.table_hash_key = nil
+
+    class_attribute :table_range_key, instance_writer: false
+    self.table_range_key = nil
+
+    class_attribute :table_read_capacity_units, instance_writer: false
+    self.table_read_capacity_units = 10
+
+    class_attribute :table_write_capacity_units, instance_writer: false
+    self.table_write_capacity_units = 5
+
+    class_attribute :fields, instance_writer: false
+    self.fields = nil
+
+  end
+end

data/lib/ocean-dynamo/exceptions.rb

@@ -0,0 +1,39 @@
+module OceanDynamo
+
+  class DynamoError < StandardError; end
+
+  class UnknownPrimaryKey < DynamoError; end
+
+  class UnknownTableStatus < DynamoError; end
+
+  class UnsupportedType < DynamoError; end
+
+  class SerializationTypeMismatch < DynamoError; end
+
+  class ConnectionNotEstablished < DynamoError; end
+
+  class RecordNotFound < DynamoError; end
+
+  class RecordNotSaved < DynamoError; end
+
+  class RecordInvalid < DynamoError; end     
+
+  class RecordNotDestroyed < DynamoError; end
+
+  class StatementInvalid < DynamoError; end
+    class RecordNotUnique < StatementInvalid; end   
+    class InvalidForeignKey < StatementInvalid; end
+
+  class StaleObjectError < DynamoError; end
+ 
+  class ReadOnlyRecord < DynamoError; end
+
+  class DangerousAttributeError < DynamoError; end
+
+  class UnknownAttributeError < NoMethodError; end
+
+  class AttributeAssignmentError < DynamoError; end
+
+  class MultiparameterAssignmentErrors < DynamoError; end
+
+end

data/lib/ocean-dynamo/persistence.rb

@@ -0,0 +1,202 @@
+module OceanDynamo
+  class Base
+
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+
+    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.delete(hash, range=nil)
+      item = dynamo_items[hash, range]
+      return false unless item.exists?
+      item.delete
+      true
+    end
+
+
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
+
+    def destroyed?
+      @destroyed
+    end
+
+
+    def new_record?
+      @new_record
+    end
+
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    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
+            k = read_attribute(table_hash_key)
+            write_attribute(table_hash_key, SecureRandom.uuid) if k == "" || k == nil
+            t = Time.zone.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.zone.now
+            dynamo_persist
+            true
+          end
+        end
+      end
+    end
+
+
+    def destroy
+      run_callbacks :commit do
+        run_callbacks :destroy do
+          delete
+        end
+      end
+    end
+
+
+    def destroy!
+      destroy || raise(RecordNotDestroyed)
+    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)
+      raise DynamoError, "can not touch on a new record object" unless persisted?
+      run_callbacks :touch do
+        attrs = ['updated_at']
+        attrs << name if name
+        t = Time.zone.now
+        attrs.each { |k| write_attribute k, 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 perform_validations(options={}) # :nodoc:
+      options[:validate] == false || valid?(options[:context])
+    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
+end

data/lib/ocean-dynamo/queries.rb

@@ -0,0 +1,16 @@
+module OceanDynamo
+  class Base
+
+    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.count
+      dynamo_table.item_count || -1    # The || -1 is for fake_dynamo specs.
+    end
+
+  end
+end

data/lib/ocean-dynamo/schema.rb

@@ -0,0 +1,66 @@
+module OceanDynamo
+  class Base
+
+    def self.set_table_name(name)
+      self.table_name = name
+      true
+    end
+
+
+    def self.set_table_name_prefix(prefix)
+      self.table_name_prefix = prefix
+      true
+    end
+
+
+    def self.set_table_name_suffix(suffix)
+      self.table_name_suffix = suffix
+      true
+    end
+
+
+    def self.compute_table_name
+      name.pluralize.underscore
+    end
+
+
+    def self.table_full_name
+      "#{table_name_prefix}#{table_name}#{table_name_suffix}"
+    end
+
+
+    #
+    # This is where the class is initialized
+    #
+    def self.primary_key(hash_key, range_key=nil)
+      self.dynamo_client = nil
+      self.dynamo_table = nil
+      self.dynamo_items = nil
+      self.table_name = compute_table_name
+      self.table_name_prefix = nil
+      self.table_name_suffix = nil
+      self.fields = HashWithIndifferentAccess.new
+      self.table_hash_key = hash_key
+      self.table_range_key = range_key
+      DEFAULT_ATTRIBUTES.each { |k, name, **pairs| attribute k, name, **pairs }
+      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.attribute(name, type=:string, **pairs)
+      attr_accessor name
+      fields[name.to_s] = {type: type, default: pairs[:default]}
+    end
+
+  end
+end

data/lib/ocean-dynamo/tables.rb

@@ -0,0 +1,71 @@
+module OceanDynamo
+  class Base
+
+    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
+
+  end
+end

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-09 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -134,8 +134,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/routes.rb
-- lib/ocean-dynamo/dynamo.rb
+- lib/ocean-dynamo/attributes.rb
+- lib/ocean-dynamo/base.rb
+- lib/ocean-dynamo/callbacks.rb
+- lib/ocean-dynamo/class_variables.rb
 - lib/ocean-dynamo/engine.rb
+- lib/ocean-dynamo/exceptions.rb
+- lib/ocean-dynamo/persistence.rb
+- lib/ocean-dynamo/queries.rb
+- lib/ocean-dynamo/schema.rb
+- lib/ocean-dynamo/tables.rb
 - lib/ocean-dynamo/version.rb
 - lib/ocean-dynamo.rb
 - MIT-LICENSE

data/lib/ocean-dynamo/dynamo.rb

@@ -1,604 +0,0 @@
-
-require "aws-sdk"
-
-module OceanDynamo
-
-  DEFAULT_FIELDS = [
-    [:created_at,   :datetime], 
-    [:updated_at,   :datetime],
-    [:lock_version, :integer, default: 0]
-  ]
-
-  class DynamoError < StandardError; end
-
-  class UnknownPrimaryKey < DynamoError; end
-
-  class UnknownTableStatus < DynamoError; end
-
-  class UnsupportedType < DynamoError; end
-
-  class SerializationTypeMismatch < DynamoError; end
-
-  class ConnectionNotEstablished < DynamoError; end
-
-  class RecordNotFound < DynamoError; end
-
-  class RecordNotSaved < DynamoError; end
-
-  class RecordInvalid < DynamoError; end     
-
-  class RecordNotDestroyed < DynamoError; end
-
-  class StatementInvalid < DynamoError; end
-  
-  class WrappedDatabaseException < StatementInvalid; end
-    class RecordNotUnique < WrappedDatabaseException; end   
-    class InvalidForeignKey < WrappedDatabaseException; end
-
-  class StaleObjectError < DynamoError; end
- 
-  class ReadOnlyRecord < DynamoError; end
-
-  class DangerousAttributeError < DynamoError; end
-
-  class UnknownAttributeError < NoMethodError; end
-
-  class AttributeAssignmentError < DynamoError; end
-
-  class MultiparameterAssignmentErrors < DynamoError; end
-
-
-
-
-
-
-
-  class Base
-
-    include ActiveModel::Model
-    include ActiveModel::Validations::Callbacks
-
-
-    # ---------------------------------------------------------
-    #
-    #  Class variables and methods
-    #
-    # ---------------------------------------------------------
-
-    class_attribute :dynamo_client, instance_writer: false
-    self.dynamo_client = nil
-
-    class_attribute :dynamo_table, instance_writer: false
-    self.dynamo_table = nil
-
-    class_attribute :dynamo_items, instance_writer: false
-    self.dynamo_items = nil
-
-    class_attribute :table_name, instance_writer: false
-    self.table_name = nil
-
-    class_attribute :table_name_prefix, instance_writer: false
-    self.table_name_prefix = nil
-
-    class_attribute :table_name_suffix, instance_writer: false
-    self.table_name_suffix = nil
-
-    class_attribute :table_hash_key, instance_writer: false
-    self.table_hash_key = nil
-
-    class_attribute :table_range_key, instance_writer: false
-    self.table_range_key = nil
-
-    class_attribute :table_read_capacity_units, instance_writer: false
-    self.table_read_capacity_units = 10
-
-    class_attribute :table_write_capacity_units, instance_writer: false
-    self.table_write_capacity_units = 5
-
-    class_attribute :fields, instance_writer: false
-    self.fields = nil
-
-
-    def self.set_table_name(name)
-      self.table_name = name
-      true
-    end
-
-
-    def self.set_table_name_prefix(prefix)
-      self.table_name_prefix = prefix
-      true
-    end
-
-
-    def self.set_table_name_suffix(suffix)
-      self.table_name_suffix = suffix
-      true
-    end
-
-
-    def self.compute_table_name
-      name.pluralize.underscore
-    end
-
-
-    def self.table_full_name
-      "#{table_name_prefix}#{table_name}#{table_name_suffix}"
-    end
-
-
-    #
-    # This is where the class is initialized
-    #
-    def self.primary_key(hash_key, range_key=nil)
-      self.dynamo_client = nil
-      self.dynamo_table = nil
-      self.dynamo_items = nil
-      self.table_name = compute_table_name
-      self.table_name_prefix = nil
-      self.table_name_suffix = nil
-      self.fields = HashWithIndifferentAccess.new
-      self.table_hash_key = hash_key
-      self.table_range_key = range_key
-      DEFAULT_FIELDS.each { |k, name, **pairs| attribute k, name, **pairs }
-      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.attribute(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
-
-
-    # ---------------------------------------------------------
-    #
-    #  Instance variables and methods
-    #
-    # ---------------------------------------------------------
-
-    attr_reader :attributes
-    attr_reader :destroyed
-    attr_reader :new_record
-    attr_reader :dynamo_item
-
-
-    def initialize(attrs={})
-      run_callbacks :initialize do
-        @attributes = HashWithIndifferentAccess.new
-        fields.each do |name, md| 
-          write_attribute(name, evaluate_default(md[:default], md[:type]))
-          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
-        @dynamo_item = nil
-        @destroyed = false
-        @new_record = true
-        raise UnknownPrimaryKey unless table_hash_key
-      end
-      attrs &&  attrs.delete_if { |k, v| !fields.has_key?(k) }
-      super(attrs)
-    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
-      return nil unless key
-      table_range_key ? [key, read_attribute(table_range_key)] : [key]
-    end
-
-
-
-    def assign_attributes(values)
-      # if values.respond_to?(:permitted?)
-      #   unless values.permitted?
-      #     raise ActiveModel::ForbiddenAttributesError
-      #   end
-      # end
-      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])
-      return nil if value == nil
-      case type
-      when :string
-        ["", []].include?(value) ? nil : value
-      when :integer
-        value == [] ? nil : value
-      when :float
-        value == [] ? nil : 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])
-      case type
-      when :string
-        return "" if value == nil
-        value.is_a?(Set) ? value.to_a : value
-      when :integer
-        return nil if value == nil
-        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_i) : value.to_i
-      when :float
-        return nil if value == nil
-        value.is_a?(Set) || 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 valid?(context = nil)
-      context ||= (new_record? ? :create : :update)
-      output = super(context)
-      errors.empty? && output
-    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
-            k = read_attribute(table_hash_key)
-            write_attribute(table_hash_key, SecureRandom.uuid) if k == "" || k == 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(default, type)
-      return default.call if default.is_a?(Proc)
-      return "" if default == nil && type == :string
-      return default.clone if default.is_a?(Array) || default.is_a?(String)   # Instances need their own copies
-      default
-    end
-
-
-    def perform_validations(options={}) # :nodoc:
-      options[:validate] == false || valid?(options[:context])
-    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
-