aws-record 1.0.0.pre.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84fe186e9a5995f6ca277aa4776a37dfaef73928
+  data.tar.gz: 267cf8b8556f23108e5cc3e660177af43ebe0c26
+SHA512:
+  metadata.gz: e69390465c8fe8f2eb45eaffeeef9d90a8ded9159a440170e3d5a3258e0679a230f4c6cc50930e2b6cd377f4a132a84389607569c1811238cd858f6a5fb9e830
+  data.tar.gz: b2ff7b50b0c2a652f21901d592ed6476fe97bd146cc95c89bdb0fccd34a2ffec3fe4233ea1e764fe72ff53bbf9af5d53e58a7cd4ac10e4717f2c45d9fe778778

data/lib/aws-record.rb

@@ -0,0 +1,24 @@
+require 'aws-sdk-resources'
+
+module Aws
+  autoload :Record, 'aws-record/record'
+
+  module Record
+    autoload :Attribute,      'aws-record/record/attribute'
+    autoload :Attributes,     'aws-record/record/attributes'
+    autoload :Errors,         'aws-record/record/errors'
+    autoload :ItemOperations, 'aws-record/record/item_operations'
+    autoload :TableMigration, 'aws-record/record/table_migration'
+    autoload :VERSION,        'aws-record/record/version'
+
+    module Attributes
+      autoload :StringMarshaler,   'aws-record/record/attributes/string_marshaler'
+      autoload :BooleanMarshaler,  'aws-record/record/attributes/boolean_marshaler'
+      autoload :IntegerMarshaler,  'aws-record/record/attributes/integer_marshaler'
+      autoload :FloatMarshaler,    'aws-record/record/attributes/float_marshaler'
+      autoload :DateMarshaler,     'aws-record/record/attributes/date_marshaler'
+      autoload :DateTimeMarshaler, 'aws-record/record/attributes/date_time_marshaler'
+    end
+
+  end
+end

data/lib/aws-record/record.rb

@@ -0,0 +1,65 @@
+module Aws
+  module Record
+    def self.included(sub_class)
+      sub_class.extend(RecordClassMethods)
+      sub_class.include(Attributes)
+      sub_class.include(ItemOperations)
+    end
+
+    private
+    def dynamodb_client
+      self.class.dynamodb_client
+    end
+
+    module RecordClassMethods
+      def table_name
+        if @table_name
+          @table_name
+        else
+          @table_name = self.name
+        end
+      end
+
+      def set_table_name(name)
+        @table_name = name
+      end
+
+      def provisioned_throughput
+        begin
+          resp = dynamodb_client.describe_table(table_name: @table_name)
+          throughput = resp.table.provisioned_throughput
+          return {
+            read_capacity_units: throughput.read_capacity_units,
+            write_capacity_units: throughput.write_capacity_units
+          }
+        rescue DynamoDB::Errors::ResourceNotFoundException
+          raise Record::Errors::TableDoesNotExist
+        end
+      end
+
+      def table_exists?
+        begin
+          resp = dynamodb_client.describe_table(table_name: @table_name)
+          if resp.table.table_status == "ACTIVE"
+            true
+          else
+            false
+          end
+        rescue DynamoDB::Errors::ResourceNotFoundException
+          false
+        end
+      end
+
+      def configure_client(opts = {})
+        provided_client = opts.delete(:client)
+        opts[:user_agent_suffix] = user_agent(opts.delete(:user_agent_suffix))
+        client = provided_client || Aws::DynamoDB::Client.new(opts)
+        @dynamodb_client = client
+      end
+
+      def dynamodb_client
+        @dynamodb_client ||= configure_client
+      end
+    end
+  end
+end

data/lib/aws-record/record/attribute.rb

@@ -0,0 +1,46 @@
+module Aws
+  module Record
+    class Attribute
+
+      attr_reader :name, :database_name, :dynamodb_type
+
+      def initialize(name, options = {})
+        @name = name
+        @database_name = options[:database_attribute_name] || name.to_s
+        @dynamodb_type = options[:dynamodb_type]
+        @marshaler = options[:marshaler] || DefaultMarshaler
+        @validators = options[:validators] || []
+      end
+
+      def type_cast(raw_value)
+        @marshaler.type_cast(raw_value)
+      end
+
+      def serialize(raw_value)
+        @marshaler.serialize(raw_value)
+      end
+
+      def valid?(raw_value)
+        value = type_cast(raw_value)
+        @validators.all? do |validator|
+          validator.validate(value)
+        end
+      end
+
+      def extract(dynamodb_item)
+        dynamodb_item[database_name]
+      end
+
+    end
+
+    module DefaultMarshaler
+      def self.type_cast(raw_value, options = {})
+        raw_value
+      end
+
+      def self.serialize(raw_value, options = {})
+        raw_value
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes.rb

@@ -0,0 +1,242 @@
+module Aws
+  module Record
+    module Attributes
+
+      def self.included(sub_class)
+        sub_class.extend(ClassMethods)
+        sub_class.instance_variable_set("@keys", {})
+        sub_class.instance_variable_set("@attributes", {})
+        sub_class.instance_variable_set("@storage_attributes", {})
+      end
+
+      def initialize
+        @data = {}
+      end
+
+      # Returns a hash representation of the attribute data.
+      #
+      # @return [Hash] Map of attribute names to raw values.
+      def to_h
+        @data.dup
+      end
+
+      module ClassMethods
+
+        # Define an attribute for your model, providing your own attribute type.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Marshaler] marshaler The marshaler for this attribute. So long
+        #   as you provide a marshaler which implements `#type_cast` and
+        #   `#serialize` that consume raw values as expected, you can bring your
+        #   own marshaler type. Convenience methods will provide this for you.
+        # @param [Hash] options
+        # @option options [Array] :validators An array of validator classes that
+        #   will be run when an attribute is checked for validity.
+        # @option options [String] :database_attribute_name Optional attribute
+        #   used to specify a different name for database persistence than the
+        #   `name` parameter. Must be unique (you can't have overlap between
+        #   database attribute names and the names of other attributes).
+        # @option options [String] :dynamodb_type Generally used for keys and
+        #   index attributes, one of "S", "N", "B", "BOOL", "SS", "NS", "BS",
+        #   "M", "L". Optional if this attribute will never be used for a key or
+        #   secondary index, but most convenience methods for setting attributes
+        #   will provide this.
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def attr(name, marshaler, opts = {})
+          validate_attr_name(name)
+
+          opts = opts.merge(marshaler: marshaler)
+          attribute = Attribute.new(name, opts)
+
+          storage_name = attribute.database_name
+
+          check_for_naming_collisions(name, storage_name)
+          check_if_reserved(name)
+
+          @attributes[name] = attribute
+          @storage_attributes[storage_name] = name
+
+          define_attr_methods(name, attribute)
+          key_attributes(name, opts)
+        end
+
+        # Define a string-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def string_attr(id, opts = {})
+          opts[:dynamodb_type] = "S"
+          attr(id, Attributes::StringMarshaler, opts)
+        end
+
+        # Define a boolean-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def boolean_attr(id, opts = {})
+          opts[:dynamodb_type] = "BOOL"
+          attr(id, Attributes::BooleanMarshaler, opts)
+        end
+
+        # Define a integer-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def integer_attr(id, opts = {})
+          opts[:dynamodb_type] = "N"
+          attr(id, Attributes::IntegerMarshaler, opts)
+        end
+
+        # Define a float-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def float_attr(id, opts = {})
+          opts[:dynamodb_type] = "N"
+          attr(id, Attributes::FloatMarshaler, opts)
+        end
+
+        # Define a date-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def date_attr(id, opts = {})
+          opts[:dynamodb_type] = "S"
+          attr(id, Attributes::DateMarshaler, opts)
+        end
+
+        # Define a datetime-type attribute for your model.
+        #
+        # @param [Symbol] name Name of this attribute.  It should be a name that
+        #   is safe to use as a method.
+        # @param [Hash] options
+        # @option options [Boolean] :hash_key Set to true if this attribute is
+        #   the hash key for the table.
+        # @option options [Boolean] :range_key Set to true if this attribute is
+        #   the range key for the table.
+        def datetime_attr(id, opts = {})
+          opts[:dynamodb_type] = "S"
+          attr(id, Attributes::DateTimeMarshaler, opts)
+        end
+
+        # @return [Hash] hash of symbolized attribute names to attribute objects
+        def attributes
+          @attributes
+        end
+
+        # @return [Aws::Record::Attribute,nil]
+        def hash_key
+          @attributes[@keys[:hash]]
+        end
+
+        # @return [Aws::Record::Attribute,nil]
+        def range_key
+          @attributes[@keys[:range]]
+        end
+
+        # @return [Hash] A mapping of the :hash and :range keys to the attribute
+        #   name symbols associated with them.
+        def keys
+          @keys
+        end
+
+        private
+        def define_attr_methods(name, attribute)
+          define_method(name) do
+            raw = @data[name]
+            attribute.type_cast(raw)
+          end
+
+          define_method("#{name}=") do |value|
+            @data[name] = value
+          end
+        end
+
+        def key_attributes(id, opts)
+          if opts[:hash_key] == true && opts[:range_key] == true
+            raise ArgumentError.new(
+              "Cannot have the same attribute be a hash and range key."
+            )
+          elsif opts[:hash_key] == true
+            define_key(id, :hash)
+          elsif opts[:range_key] == true
+            define_key(id, :range)
+          end
+        end
+
+        def define_key(id, type)
+          @keys[type] = id
+        end
+
+        def validate_attr_name(name)
+          unless name.is_a?(Symbol)
+            raise ArgumentError.new("Must use symbolized :name attribute.")
+          end
+          if @attributes[name]
+            raise Errors::NameCollision.new(
+              "Cannot overwrite existing attribute #{name}"
+            )
+          end
+        end
+
+        def check_if_reserved(name)
+          if instance_methods.include?(name)
+            raise Errors::ReservedName.new(
+              "Cannot name an attribute #{name}, that would collide with an"\
+                " existing instance method."
+            )
+          end
+        end
+
+        def check_for_naming_collisions(name, storage_name)
+          if @attributes[storage_name]
+            raise Errors::NameCollision.new(
+              "Custom storage name #{storage_name} already exists as an"\
+                " attribute name in #{@attributes}"
+            )
+          elsif @storage_attributes[name]
+            raise Errors::NameCollision.new(
+              "Attribute name #{name} already exists as a custom storage"\
+                " name in #{@storage_attributes}"
+            )
+          elsif @storage_attributes[storage_name]
+            raise Errors::NameCollision.new(
+              "Custom storage name #{storage_name} already in use in"\
+                " #{@storage_attributes}"
+            )
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-record/record/attributes/boolean_marshaler.rb

@@ -0,0 +1,41 @@
+module Aws
+  module Record
+    module Attributes
+      module BooleanMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              nil
+            when ''
+              nil
+            when false, 'false', '0', 0
+              false
+            else
+              true
+            end
+          end
+
+          def serialize(raw_value, options = {})
+            boolean = type_cast(raw_value, options)
+            case boolean
+            when nil
+              nil
+            when false
+              false
+            when true
+              true
+            else
+              msg = "expected a boolean value or nil, got #{boolean.class}"
+              raise ArgumentError, msg
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes/date_marshaler.rb

@@ -0,0 +1,49 @@
+require 'date'
+
+module Aws
+  module Record
+    module Attributes
+      module DateMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              nil
+            when ''
+              nil
+            when Date
+              raw_value
+            when Integer
+              begin
+                Date.parse(Time.at(raw_value).to_s) # assumed timestamp
+              rescue
+                nil
+              end
+            else
+              begin
+                Date.parse(raw_value.to_s) # Time, DateTime or String
+              rescue
+                nil
+              end
+            end
+          end
+
+          def serialize(raw_value, options = {})
+            date = type_cast(raw_value)
+            if date.nil?
+              nil
+            elsif date.is_a?(Date)
+              date.strftime('%Y-%m-%d')
+            else
+              raise ArgumentError, "expected a Date value or nil, got #{date.class}"
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes/date_time_marshaler.rb

@@ -0,0 +1,50 @@
+require 'date'
+
+module Aws
+  module Record
+    module Attributes
+      module DateTimeMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              nil
+            when ''
+              nil
+            when DateTime
+              raw_value
+            when Integer
+              begin
+                DateTime.parse(Time.at(raw_value).to_s) # timestamp
+              rescue
+                nil
+              end
+            else
+              begin
+                DateTime.parse(raw_value.to_s) # Time, Date or String
+              rescue
+                nil
+              end
+            end
+          end
+
+          def serialize(raw_value, options = {})
+            datetime = type_cast(raw_value)
+            if datetime.nil?
+              nil
+            elsif datetime.is_a?(DateTime)
+              datetime.strftime('%Y-%m-%dT%H:%M:%S%Z') 
+            else
+              msg = "expected a DateTime value or nil, got #{datetime.class}"
+              raise ArgumentError, msg
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes/float_marshaler.rb

@@ -0,0 +1,40 @@
+module Aws
+  module Record
+    module Attributes
+      module FloatMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              nil
+            when ''
+              nil
+            when Float
+              raw_value
+            else
+              raw_value.respond_to?(:to_f) ?
+                raw_value.to_f :
+                raw_value.to_s.to_f
+            end
+          end
+
+          def serialize(raw_value, options = {})
+            float = type_cast(raw_value, options = {})
+            if float.nil?
+              nil
+            elsif float.is_a?(Float)
+              float
+            else
+              msg = "expected a Float value or nil, got #{value.class}"
+              raise ArgumentError, msg
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes/integer_marshaler.rb

@@ -0,0 +1,40 @@
+module Aws
+  module Record
+    module Attributes
+      module IntegerMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              nil
+            when ''
+              nil
+            when Integer
+              raw_value
+            else
+              raw_value.respond_to?(:to_i) ?
+                raw_value.to_i :
+                raw_value.to_s.to_i
+            end
+          end
+
+          def serialize(raw_value, options = {})
+            integer = type_cast(raw_value, options = {})
+            if integer.nil?
+              nil
+            elsif integer.is_a?(Integer)
+              integer
+            else
+              msg = "expected an Integer value or nil, got #{value.class}"
+              raise ArgumentError, msg
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-record/record/attributes/string_marshaler.rb

@@ -0,0 +1,47 @@
+module Aws
+  module Record
+    module Attributes
+      module StringMarshaler
+
+        class << self
+
+          def type_cast(raw_value, options = {})
+            case raw_value
+            when nil
+              if options[:nil_as_empty_string]
+                ''
+              else
+                nil
+              end
+            when String
+              if raw_value.empty? && !options[:nil_as_empty_string]
+                nil
+              else
+                raw_value
+              end
+            else
+              raw_value.to_s
+            end
+          end
+
+          def serialize(raw_value, options = {})
+             value = type_cast(raw_value)
+            if value.is_a?(String)
+              if value.empty?
+                nil
+              else
+                value
+              end
+            elsif value.nil?
+              nil
+            else
+              msg = "expected a String value or nil, got #{value.class}"
+              raise ArgumentError, msg
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws-record/record/errors.rb

@@ -0,0 +1,13 @@
+module Aws
+  module Record
+    module Errors
+
+      class KeyMissing < RuntimeError; end
+      class NameCollision < RuntimeError; end
+      class ReservedName < RuntimeError; end
+      class InvalidModel < RuntimeError; end
+      class TableDoesNotExist < RuntimeError; end
+
+    end
+  end
+end

data/lib/aws-record/record/item_operations.rb

@@ -0,0 +1,107 @@
+module Aws
+  module Record
+    module ItemOperations
+
+      def self.included(sub_class)
+        sub_class.extend(ItemOperationsClassMethods)
+      end
+
+      def save
+        dynamodb_client.put_item(
+          table_name: self.class.table_name,
+          item: build_item_for_save
+        )
+      end
+
+      def delete!
+        dynamodb_client.delete_item(
+          table_name: self.class.table_name,
+          key: key_values
+        )
+        true
+      end
+
+      private
+      def build_item_for_save
+        validate_key_values
+        attributes = self.class.attributes
+        @data.inject({}) do |acc, name_value_pair|
+          attr_name, raw_value = name_value_pair
+          db_name = attributes[attr_name].database_name
+          acc[db_name] = attributes[attr_name].serialize(raw_value)
+          acc
+        end
+      end
+
+      def key_values
+        validate_key_values
+        attributes = self.class.attributes
+        self.class.keys.inject({}) do |acc, (_, attr_name)|
+          db_name = attributes[attr_name].database_name
+          acc[db_name] = attributes[attr_name].serialize(@data[attr_name])
+          acc
+        end
+      end
+
+      def validate_key_values
+        missing = missing_key_values
+        unless missing.empty?
+          raise Errors::KeyMissing.new(
+            "Missing required keys: #{missing.join(', ')}"
+          )
+        end
+      end
+
+      def missing_key_values
+        self.class.keys.inject([]) do |acc, key|
+          acc << key.last if @data[key.last].nil?
+          acc
+        end
+      end
+
+      module ItemOperationsClassMethods
+        def find(opts)
+          key = {}
+          @keys.each_value do |attr_sym|
+            unless opts[attr_sym]
+              raise Errors::KeyMissing.new(
+                "Missing required key #{attr_sym} in #{opts}"
+              )
+            end
+            attr_name = attr_sym.to_s
+            key[attr_name] = attributes[attr_sym].serialize(opts[attr_sym])
+          end
+          request_opts = {
+            table_name: table_name,
+            key: key
+          }
+          resp = dynamodb_client.get_item(request_opts)
+          if resp.item.nil?
+            nil
+          else
+            build_item_from_resp(resp)
+          end
+        end
+
+        private
+        def build_item_from_resp(resp)
+          record = new
+          data = record.instance_variable_get("@data")
+          attributes.each do |name, attr|
+            data[name] = attr.extract(resp.item)
+          end
+          record
+        end
+
+        def user_agent(custom)
+          if custom
+            custom
+          else
+            " aws-record/#{VERSION}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-record/record/table_migration.rb

@@ -0,0 +1,89 @@
+module Aws
+  module Record
+    class TableMigration
+
+      attr_accessor :client
+
+      def initialize(model, client: nil)
+        assert_model_valid(model)
+        @model = model
+        @client = client || Aws::DynamoDB::Client.new
+      end
+
+      def create!(opts)
+        create_opts = opts.merge({
+          table_name: @model.table_name,
+          attribute_definitions: attribute_definitions,
+          key_schema: key_schema
+        })
+        @client.create_table(create_opts)
+      end
+
+      def update!(opts)
+        begin
+          update_opts = opts.merge({
+            table_name: @model.table_name
+          })
+          @client.update_table(update_opts)
+        rescue DynamoDB::Errors::ResourceNotFoundException => e
+          raise Errors::TableDoesNotExist.new(e)
+        end
+      end
+
+      def delete!
+        begin
+          @client.delete_table(table_name: @model.table_name)
+        rescue DynamoDB::Errors::ResourceNotFoundException => e
+          raise Errors::TableDoesNotExist.new(e)
+        end
+      end
+
+      def wait_until_available
+        @client.wait_until(:table_exists, table_name: @model.table_name)
+      end
+
+      private
+      def assert_model_valid(model)
+        assert_required_include(model)
+        assert_keys(model)
+      end
+
+      def assert_required_include(model)
+        unless model.include?(::Aws::Record)
+          raise Errors::InvalidModel.new("Table models must include Aws::Record")
+        end
+      end
+
+      def assert_keys(model)
+        if model.hash_key.nil?
+          raise Errors::InvalidModel.new("Table models must include a hash key")
+        end
+      end
+
+      def attribute_definitions
+        keys.map do |type, attr|
+          {
+            attribute_name: attr.database_name,
+            attribute_type: attr.dynamodb_type
+          }
+        end
+      end
+
+      def key_schema
+        keys.map do |type, attr|
+          {
+            attribute_name: attr.database_name,
+            key_type: type == :hash ? "HASH" : "RANGE"
+          }
+        end
+      end
+
+      def keys
+        @model.keys.inject({}) do |acc, (type, name)|
+          acc[type] = @model.attributes[name]
+          acc
+        end
+      end
+    end
+  end
+end

data/lib/aws-record/record/version.rb

@@ -0,0 +1,5 @@
+module Aws
+  module Record
+    VERSION = "1.0.0.pre.1"
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: aws-record
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.1
+platform: ruby
+authors:
+- Amazon Web Services
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Provides an object mapping abstraction for Amazon DynamoDB.
+email:
+- alexwood@amazon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aws-record.rb
+- lib/aws-record/record.rb
+- lib/aws-record/record/attribute.rb
+- lib/aws-record/record/attributes.rb
+- lib/aws-record/record/attributes/boolean_marshaler.rb
+- lib/aws-record/record/attributes/date_marshaler.rb
+- lib/aws-record/record/attributes/date_time_marshaler.rb
+- lib/aws-record/record/attributes/float_marshaler.rb
+- lib/aws-record/record/attributes/integer_marshaler.rb
+- lib/aws-record/record/attributes/string_marshaler.rb
+- lib/aws-record/record/errors.rb
+- lib/aws-record/record/item_operations.rb
+- lib/aws-record/record/table_migration.rb
+- lib/aws-record/record/version.rb
+homepage: http://github.com/aws/aws-sdk-ruby-record
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: AWS Record library for Amazon DynamoDB
+test_files: []
+has_rdoc: