aws-sdk-v1 1.52.0

data/lib/aws/record/errors.rb

@@ -0,0 +1,143 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    class Errors < Core::IndifferentHash
+
+      include Enumerable
+
+      # Returns the errors for the atttibute in an array.
+      #
+      #     errors.add(:name, 'may not be blank')
+      #     errors.add(:name, 'must be less than 30 characters')
+      #     errors[:name]
+      #     #=> ['may not be blank', 'must be less than 30 characters']
+      #
+      # @param [String,Symbol] attribute_name The name of the attribute to retnr
+      #   errors for.  You can pass the string or symbol version.
+      # @return [Array<String>] Returns the error messages for the given
+      #   `attribute_name`.  If there are no errors on the attribute then
+      #   an empty array is returned.
+      def [] attribute_name
+        super(attribute_name) || []
+      end
+      alias_method :on, :[]
+
+      # Adds an error message to the named attribute.
+      #
+      #     errors.add(:name, 'may not be blank')
+      #     errors.on(:name)
+      #     #=> ['may not be blank']
+      #
+      # If you want to add a general error message, then pass `:base`
+      # for `attribute_name`, or call {#add_to_base}.
+      # @param [String,Symbol] attribute_name The name of the attribute
+      #   that you are adding an error to.
+      # @param [String] message ('is invalid') The error message (should
+      #   not contain the attribute name).
+      # @return [String] Returns the message.
+      def []= attribute_name, message = 'is invalid'
+        if has_key?(attribute_name)
+          self[attribute_name] << message
+        else
+          super(attribute_name, [message])
+        end
+        self[attribute_name]
+      end
+      alias_method :add, :[]=
+
+      # Adds a general error message (not associated with any particular
+      # attribute).
+      # @param [String] message ('is invalid') The error message (should
+      #   not contain the attribute name).
+      # @return [String] Returns the message.
+      def add_to_base message
+        add(:base, message)
+      end
+
+      # @return [Integer] Returns the number of error messages.
+      def count
+        values.flatten.length
+      end
+      alias_method :size, :count
+
+      # Yields once for each error message added.
+      #
+      # An attribute_name may yield more than once if there are more than
+      # one errors associated with that attirbute.
+      #
+      # @yield [attribute_name, error_message]
+      # @yieldparam [String] attribute_name The name of the attribute
+      # @yieldparam [String] error_message The error message associated the
+      #   the named attribute.
+      def each &block
+        super do |attribute_name, error_messages|
+          error_messages.each do |error_message|
+            yield(attribute_name, error_message)
+          end
+        end
+      end
+
+      # Returns the errors prefixed by a humanized version of the attribute
+      # name.
+      #
+      #     errors.add(:name, 'may not be blank')
+      #     errors.full_messages
+      #     #=> ['Name may not be blank']
+      #
+      # @return [Array of Strings] Returns an array of error messages.
+      def full_messages
+        messages = []
+        each do |attr_name, error_message|
+          messages << case attr_name
+          when 'base' then error_message.dup
+          else "#{attr_name.capitalize.gsub(/_/, ' ')} #{error_message}"
+          end
+        end
+        messages
+      end
+      alias_method :to_a, :full_messages
+
+      # Returns a hash of of errors messages.  Keys are attribute names
+      # and values are arrays of error messages.
+      #
+      #     errors.add(:name, 'may not be blank')
+      #     errors.to_hash
+      #     #=> { 'name' => ['may not be blank'] }
+      #
+      # Please note that the hash values are always arrays, even if there
+      # is only one error message for the attribute.
+      def to_hash
+        hash = {}
+        each do |attr_name, message|
+          hash[attr_name] ||= []
+          hash[attr_name] << message.dup
+        end
+        hash
+      end
+
+      # Removes all error messages.
+      # @return [nil]
+      def clear!
+        keys.each do |key|
+          delete(key)
+        end
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/exceptions.rb

@@ -0,0 +1,51 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    # @api private
+    class RecordNotFound < StandardError; end
+
+    # Raised when trying to access an attribute that does not exist.
+    # @api private
+    class UndefinedAttributeError < StandardError
+      def initalize attribute_name
+        super("undefined attribute `#{attribute_name}`")
+      end
+    end
+
+    # Raised when calling #save!, #create! or #update_attributes! on a record that
+    # has validation errors.
+    # @api private
+    class InvalidRecordError < StandardError
+      def initialize record
+        @record = record
+        super(record.errors.full_messages.join(', '))
+      end
+      attr_reader :record
+    end
+
+    # Raised when trying to persist a record that has no attribute values
+    # to persist.
+    # @api private
+    class EmptyRecordError < StandardError
+      def initialize record
+        @record = record
+        super('unable persist empty records')
+      end
+      attr_reader :record
+    end
+
+  end
+end

data/lib/aws/record/hash_model.rb

@@ -0,0 +1,204 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+    class HashModel
+
+      require 'aws/record/hash_model/attributes'
+      require 'aws/record/hash_model/finder_methods'
+      require 'aws/record/hash_model/scope'
+
+      extend AbstractBase
+
+      def self.inherited(sub_class)
+        sub_class.string_attr :id,
+          :hash_key => true,
+          :default_hash_key_attribute => true
+      end
+
+      # @return [String,nil]
+      def hash_key
+        self[self.class.hash_key]
+      end
+
+      class << self
+
+        # Creates the DynamoDB table that is configured for this class.
+        #
+        #     class Product < AWS::Record::HashModel
+        #     end
+        #
+        #     # create the table 'Product' with 10 read/write capacity units
+        #     Product.create_table 10, 10
+        #
+        # If you shard you data across multiple tables, you can specify the
+        # shard name:
+        #
+        #     # create two tables, with the given names
+        #     Product.create_table 500, 10, :shard_name => 'products-1'
+        #     Product.create_table 500, 10, :shard_name => 'products-2'
+        #
+        # If you share a single AWS account with multiple applications, you
+        # can provide a table prefix to group tables and to avoid name
+        # collisions:
+        #
+        #     AWS::Record.table_prefix = 'myapp-'
+        #
+        #     # creates the table 'myapp-Product'
+        #     Product.create_table 250, 50
+        #
+        #     # creates the table 'myapp-products-1'
+        #     Product.create_table 250, 50, :shard_name => 'products-1'
+        #
+        # @param [Integer] read_capacity_units
+        #   See {DynamoDB::TableCollection#create} for more information.
+        #
+        # @param [Integer] write_capacity_units
+        #   See {DynamoDB::TableCollection#create} for more information.
+        #
+        # @param [Hash] options
+        #
+        # @option options [String] :shard_name Defaults to the class name.  The
+        #   shard name will be prefixed with {AWS::Record.table_prefix},
+        #   and that becomes the table name.
+        #
+        # @return [DynamoDB::Table]
+        #
+        def create_table read_capacity_units, write_capacity_units, options = {}
+
+          table_name = dynamo_db_table_name(options[:shard_name])
+
+          create_opts = {}
+          create_opts[:hash_key] = { hash_key => :string }
+
+          dynamo_db.tables.create(
+            table_name,
+            read_capacity_units,
+            write_capacity_units,
+            create_opts)
+
+        end
+
+        # @return [DynamoDB::Table]
+        # @api private
+        def dynamo_db_table shard_name = nil
+          table = dynamo_db.tables[dynamo_db_table_name(shard_name)]
+          table.hash_key = [hash_key, :string]
+          table
+        end
+
+        # @api private
+        def hash_key
+          hash_key_attribute.name
+        end
+
+        # @api private
+        def hash_key_attribute
+          @hash_key_attribute
+        end
+
+        private
+
+        def set_hash_key_attribute(attribute)
+          if
+            hash_key_attribute and
+            hash_key_attribute.options[:default_hash_key_attribute]
+          then
+            remove_attribute(hash_key_attribute)
+          end
+          @hash_key_attribute = attribute
+        end
+
+        def dynamo_db_table_name shard_name = nil
+          "#{Record.table_prefix}#{self.shard_name(shard_name)}"
+        end
+
+        def dynamo_db
+          AWS::DynamoDB.new
+        end
+
+        def add_attribute(attribute)
+          set_hash_key_attribute(attribute) if attribute.options[:hash_key]
+          super(attribute)
+        end
+
+      end
+
+      private
+
+      def populate_id
+        hash_key = self.class.hash_key_attribute
+        if hash_key.options[:default_hash_key_attribute]
+          self[hash_key.name] = SecureRandom.uuid
+        end
+      end
+
+      # @return [DynamoDB::Item] Returns a reference to the item as stored in
+      #   simple db.
+      # @api private
+      private
+      def dynamo_db_item
+        dynamo_db_table.items[hash_key]
+      end
+
+      # @return [SimpleDB::Domain] Returns the domain this record is
+      #   persisted to or will be persisted to.
+      private
+      def dynamo_db_table
+        self.class.dynamo_db_table(shard)
+      end
+
+      private
+      def create_storage
+        dynamo_db_table.items.create(serialize_attributes, opt_lock_conditions)
+      end
+
+      private
+      def update_storage
+        # Only enumerating dirty (i.e. changed) attributes.  Empty
+        # (nil and empty set) values are deleted, the others are replaced.
+        dynamo_db_item.attributes.update(opt_lock_conditions) do |u|
+          changed.each do |attr_name|
+            attribute = self.class.attribute_for(attr_name)
+            value = serialize_attribute(attribute, @_data[attr_name])
+            if value.nil? or value == []
+              u.delete(attr_name)
+            else
+              u.set(attr_name => value)
+            end
+          end
+        end
+      end
+
+      private
+      def delete_storage
+        dynamo_db_item.delete(opt_lock_conditions)
+      end
+
+      private
+      def deserialize_item_data data
+        data.inject({}) do |hash,(attr_name,value)|
+          if attribute = self.class.attributes[attr_name]
+            hash[attr_name] = value.is_a?(Set) ?
+              value.map{|v| attribute.deserialize(v) } :
+              attribute.deserialize(value)
+          end
+          hash
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,195 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+    class HashModel
+      class << self
+
+        # Adds a string attribute to this class.
+        #
+        # @example A standard string attribute
+        #
+        #   class Recipe < AWS::Record::HashModel
+        #     string_attr :name
+        #   end
+        #
+        #   recipe = Recipe.new(:name => "Buttermilk Pancakes")
+        #   recipe.name #=> 'Buttermilk Pancakes'
+        #
+        # @example A string attribute with `:set` set to true
+        #
+        #   class Recipe < AWS::Record::HashModel
+        #     string_attr :tags, :set => true
+        #   end
+        #
+        #   recipe = Recipe.new(:tags => %w(popular dessert))
+        #   recipe.tags #=> #<Set: {"popular", "desert"}>
+        #
+        # @param [Symbol] name The name of the attribute.
+        # @param [Hash] options
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple values.
+        def string_attr name, options = {}
+          add_attribute(Attributes::StringAttr.new(name, options))
+        end
+
+        # Adds an integer attribute to this class.
+        #
+        #     class Recipe < AWS::Record::HashModel
+        #       integer_attr :servings
+        #     end
+        #
+        #     recipe = Recipe.new(:servings => '10')
+        #     recipe.servings #=> 10
+        #
+        # @param [Symbol] name The name of the attribute.
+        # @param [Hash] options
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple values.
+        def integer_attr name, options = {}
+          add_attribute(Attributes::IntegerAttr.new(name, options))
+        end
+
+        # Adds a float attribute to this class.
+        #
+        #     class Listing < AWS::Record::HashModel
+        #       float_attr :score
+        #     end
+        #
+        #     listing = Listing.new(:score => '123.456')
+        #     listing.score # => 123.456
+        #
+        # @param [Symbol] name The name of the attribute.
+        # @param [Hash] options
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple values.
+        def float_attr name, options = {}
+          add_attribute(Attributes::FloatAttr.new(name, options))
+        end
+
+        # Adds a boolean attribute to this class.
+        #
+        # @example
+        #
+        #   class Book < AWS::Record::HashModel
+        #     boolean_attr :read
+        #   end
+        #
+        #   b = Book.new
+        #   b.read? # => false
+        #   b.read = true
+        #   b.read? # => true
+        #
+        #   listing = Listing.new(:score => '123.456'
+        #   listing.score # => 123.456
+        #
+        # @param [Symbol] name The name of the attribute.
+        def boolean_attr name, options = {}
+
+          attr = add_attribute(Attributes::BooleanAttr.new(name, options))
+
+          # add the boolean question mark method
+          define_method("#{attr.name}?") do
+            !!__send__(attr.name)
+          end
+
+        end
+
+        # Adds a datetime attribute to this class.
+        #
+        # @example A standard datetime attribute
+        #
+        #   class Recipe < AWS::Record::HashModel
+        #     datetime_attr :invented
+        #   end
+        #
+        #   recipe = Recipe.new(:invented => Time.now)
+        #   recipe.invented #=> <DateTime ...>
+        #
+        # If you add a datetime_attr for `:created_at` and/or `:updated_at` those
+        # will be automanaged.
+        #
+        # @param [Symbol] name The name of the attribute.
+        #
+        # @param [Hash] options
+        #
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple date times.
+        #
+        def datetime_attr name, options = {}
+          add_attribute(Attributes::DateTimeAttr.new(name, options))
+        end
+
+        # Adds a date attribute to this class.
+        #
+        # @example A standard date attribute
+        #
+        #   class Person < AWS::Record::HashModel
+        #     date_attr :birthdate
+        #   end
+        #
+        #   baby = Person.new
+        #   baby.birthdate = Time.now
+        #   baby.birthdate #=> <Date: ....>
+        #
+        # @param [Symbol] name The name of the attribute.
+        #
+        # @param [Hash] options
+        #
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple dates.
+        #
+        def date_attr name, options = {}
+          add_attribute(Attributes::DateAttr.new(name, options))
+        end
+
+        # Adds a DynamoDB binary attribute to this class.  A binary
+        # attribute acts the same as a string attribute, except
+        #
+        # @param [Symbol] name The name of the attribute.
+        #
+        # @param [Hash] options
+        #
+        # @option options [Boolean] :set (false) When true this attribute
+        #   can have multiple values.
+        #
+        # @note This should not be used for large objects.
+        #
+        def binary_attr name, options = {}
+        end
+
+        # A convenience method for adding the standard two datetime attributes
+        # `:created_at` and `:updated_at`.
+        #
+        # @example
+        #
+        #   class Recipe < AWS::Record::HashModel
+        #     timestamps
+        #   end
+        #
+        #   recipe = Recipe.new
+        #   recipe.save
+        #   recipe.created_at #=> <DateTime ...>
+        #   recipe.updated_at #=> <DateTime ...>
+        #
+        def timestamps
+          c = datetime_attr :created_at
+          u = datetime_attr :updated_at
+          [c, u]
+        end
+
+      end
+    end
+  end
+end