tiny_dyno 0.1.0

data/lib/tiny_dyno/fields/standard.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module TinyDyno
+  module Fields
+    class Standard
+
+      # Defines the behaviour for defined fields in the document.
+      # Set readers for the instance variables.
+      attr_accessor :default_val, :label, :name, :options
+
+      # Create the new field with a name and optional additional options.
+      #
+      # @example Create the new field.
+      #   Field.new(:name, :type => String)
+      #
+      # @param [ Hash ] options The field options.
+      #
+      # @option options [ Class ] :type The class of the field.
+      # @option options [ Object ] :default The default value for the field.
+      # @option options [ String ] :label The field's label.
+      #
+      # @since 3.0.0
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+        @label = options[:label]
+        @default_val = options[:default]
+        @type = options[:type]
+      end
+
+      # # Get the type of this field - inferred from the class name.
+      # #
+      # # @example Get the type.
+      # #   field.type
+      # #
+      # # @return [ Class ] The name of the class.
+      # #
+      # # @since 2.1.0
+      # def type
+      #   @type = options[:type]
+      # end
+
+      private
+
+      # Is the field included in the fields that were returned from the
+      # database? We can apply the default if:
+      #   1. The field is included in an only limitation (field: 1)
+      #   2. The field is not excluded in a without limitation (field: 0)
+      #
+      # @example Is the field included?
+      #   field.included?(fields)
+      #
+      # @param [ Hash ] fields The field limitations.
+      #
+      # @return [ true, false ] If the field was included.
+      #
+      # @since 2.4.4
+      def included?(fields)
+        (fields.values.first == 1 && fields[name.to_s] == 1) ||
+            (fields.values.first == 0 && !fields.has_key?(name.to_s))
+      end
+
+    end
+  end
+end

data/lib/tiny_dyno/hash_keys.rb

@@ -0,0 +1,134 @@
+module TinyDyno
+  module HashKeys
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_definitions, :key_schema, :hash_keys
+
+      # TODO :local_secondary_indexes, :global_secondary_indexes
+      self.attribute_definitions = []
+      self.key_schema = []
+      self.hash_keys = []
+      @hash_key_fields = []
+
+    end
+
+    # return all defined hash keys on an instantiated object
+    # for further use in DynamoDB queries
+    #
+    def hash_key_as_selector
+      selector = {}
+      self.class.hash_keys.each { |hk| selector[hk[:attr]] = attributes[hk[:attr]] }
+      selector
+    end
+
+    module ClassMethods
+
+      # Return true/false, depending on whether the provided argument
+      # matches a defined hash key for this document model
+      # @example Hash key is defined?
+      #   Person.hash_key_is_defined?(:id)
+      #
+      # @param [ String ] name, the name of the hash key
+      # @return [ Boolean ] True, False
+      def hash_key_is_defined?(arg = nil)
+        @hash_key_fields.include?(arg)
+      end
+
+      # return the attribute_type as stored in the attribute_definitions
+      def lookup_attribute_type(attribute_name)
+        type = attribute_definitions.collect {|a| a[:attribute_type] if a[:attribute_name] == attribute_name }
+        type.first
+      end
+
+      # Defines all the fields that are accessible on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # @example Define a field.
+      #   field :score, :type => Integer, :default => 0
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The options to pass to the field.
+      #
+      # @option options [ Class ] :type The type of the field.
+      # @option options [ String ] :label The label for the field.
+      # @option options [ Object, Proc ] :default The field's default
+      #
+      # @return [ Field ] The generated field
+      def hash_key(name, options = {})
+        named = name.to_s
+        attribute_definition = build_attribute_definition(named,options[:type])
+        key_schema = build_key_schema(named)
+        unless attribute_definition_meets_spec?(attribute_definition)
+          raise InvalidHashKey.new(self.class, name)
+        end
+        # we need the accessors as well
+        add_field(named, options)
+        self.attribute_definitions << attribute_definition
+        self.key_schema << key_schema
+        # TODO
+        # should separate that out
+        self.hash_keys << {
+            attr: attribute_definition[:attribute_name],
+            attr_type: attribute_definition[:attribute_type],
+            key_type: key_schema[:key_type],
+        }
+        @hash_key_fields << attribute_definition[:attribute_name]
+      end
+
+      # convert a hash key into a format as expected by
+      # put_item and update_item request
+      def as_item_entry(hash_key)
+
+      end
+
+      private
+
+      # Return true or false, depending on whether the attribute_definitions on the model
+      # meet the specification of the Aws Sdk
+      # This is a syntax, not a logic check
+      def attribute_definitions_meet_spec?
+        attribute_definitions.each do |definition|
+          return false unless attribute_definition_meets_spec?(definition)
+        end
+      end
+
+      def attribute_definition_meets_spec?(definition)
+        return (definition.has_key?(:attribute_name) && \
+        definition.has_key?(:attribute_type) && \
+        definition[:attribute_name].class == String && \
+        definition[:attribute_type].class == String && \
+        ['S','N', 'B'].include?(definition[:attribute_type]))
+      end
+
+      def build_attribute_definition(name, key_type)
+        {
+            attribute_name: name,
+            attribute_type: hash_key_type(key_type)
+        }
+      end
+
+      def hash_key_type(key_type = nil)
+        return 'S' if key_type == String
+        return 'N' if key_type == Fixnum or key_type == Integer
+        return nil
+      end
+
+      def build_key_schema(name)
+        {
+            attribute_name: name,
+            key_type: 'HASH'
+        }
+      end
+
+      # convert values in queries to DynamoDB
+      # into types as expected by DynamoDB
+      def dyno_typed_key(key:, val:)
+        typed_class = self.fields[key].options[:type]
+        return (document_typed(klass: typed_class, value: val))
+      end
+
+    end
+  end
+end

data/lib/tiny_dyno/loggable.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module TinyDyno
+
+  # Contains logging behaviour.
+  module Loggable
+
+    # Get the logger.
+    #
+    # @note Will try to grab Rails' logger first before creating a new logger
+    #   with stdout.
+    #
+    # @example Get the logger.
+    #   Loggable.logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 3.0.0
+    def logger
+      return @logger if defined?(@logger)
+      @logger = rails_logger || default_logger
+    end
+
+    # Set the logger.
+    #
+    # @example Set the logger.
+    #   Loggable.logger = Logger.new($stdout)
+    #
+    # @param [ Logger ] The logger to set.
+    #
+    # @return [ Logger ] The new logger.
+    #
+    # @since 3.0.0
+    def logger=(logger)
+      @logger = logger
+    end
+
+    private
+
+    # Gets the default TinyDyno logger - stdout.
+    #
+    # @api private
+    #
+    # @example Get the default logger.
+    #   Loggable.default_logger
+    #
+    # @return [ Logger ] The default logger.
+    #
+    # @since 3.0.0
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    # Get the Rails logger if it's defined.
+    #
+    # @api private
+    #
+    # @example Get Rails' logger.
+    #   Loggable.rails_logger
+    #
+    # @return [ Logger ] The Rails logger.
+    #
+    # @since 3.0.0
+    def rails_logger
+      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+  end
+end

data/lib/tiny_dyno/persistable.rb

@@ -0,0 +1,88 @@
+module TinyDyno
+  module Persistable
+    extend ActiveSupport::Concern
+
+    def save(options = {})
+      if new_record?
+        request_put_item(options)
+      else
+        request_update_item(options)
+      end
+    end
+
+    private
+
+    def request_put_item(options)
+      request = build_put_item_request(options)
+      if TinyDyno::Adapter.put_item(put_item_request: request)
+        @new_record = false
+        @changed_attributes = {}
+        return true
+      else
+        return false
+      end
+    end
+
+    # The target structure as per
+    # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#put_item-instance_method
+    #
+    # resp = client.put_item({
+    #                            table_name: "TableName", # required
+    #                            item: { # required
+    #                                    "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+    #                            },
+    #                            expected: {
+    #                                "AttributeName" => {
+    #                                    value: "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+    #                                    exists: true,
+    #                                    comparison_operator: "EQ", # accepts EQ, NE, IN, LE, LT, GE, GT, BETWEEN, NOT_NULL, NULL, CONTAINS, NOT_CONTAINS, BEGINS_WITH
+    #                                    attribute_value_list: ["value"], # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+    #                                },
+    #                            },
+    #                            return_values: "NONE", # accepts NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
+    #                            return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
+    #                            return_item_collection_metrics: "SIZE", # accepts SIZE, NONE
+    #                            conditional_operator: "AND", # accepts AND, OR
+    #                            condition_expression: "ConditionExpression",
+    #                            expression_attribute_names: {
+    #                                "ExpressionAttributeNameVariable" => "AttributeName",
+    #                            },
+    #                            expression_attribute_values: {
+    #                                "ExpressionAttributeValueVariable" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
+    #                            },
+    #                        })
+    def build_put_item_request(options)
+      {
+          table_name: self.class.table_name,
+          item: build_item_request_entries
+      }
+    end
+
+    def build_item_request_entries
+      item_entries = {}
+      attributes.each do |k,v|
+        item_entries[k] = v
+      end
+      item_entries
+    end
+
+    def request_update_item(options)
+
+    end
+
+    module ClassMethods
+
+      # Prepare a request to be sent to the aws-sdk
+      # in compliance with
+      # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#put_item-instance_method
+
+      def create(attributes = nil, &block)
+        doc = new(attributes, &block)
+        doc.save
+      end
+
+      private
+
+    end
+  end
+end

data/lib/tiny_dyno/range_attributes.rb

@@ -0,0 +1,15 @@
+module TinyDyno
+  module RangeAttributes
+    extend ActiveSupport::Concern
+
+    attr_reader :range_attributes
+
+    included do
+      class_attribute :range_attributes
+
+      self.range_attributes = []
+
+    end
+
+  end
+end

data/lib/tiny_dyno/stateful.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module TinyDyno
+
+  # This module contains the behaviour for getting the various states a
+  # document can transition through.
+  module Stateful
+
+    attr_writer :destroyed, :flagged_for_destroy, :new_record
+
+    # Returns true if the +Document+ has not been persisted to the database,
+    # false if it has. This is determined by the variable @new_record
+    # and NOT if the object has an id.
+    #
+    # @example Is the document new?
+    #   person.new_record?
+    #
+    # @return [ true, false ] True if new, false if not.
+    def new_record?
+      @new_record ||= false
+    end
+
+    # Checks if the document has been saved to the database. Returns false
+    # if the document has been destroyed.
+    #
+    # @example Is the document persisted?
+    #   person.persisted?
+    #
+    # @return [ true, false ] True if persisted, false if not.
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Returns whether or not the document has been flagged for deletion, but
+    # not destroyed yet. Used for atomic pulls of child documents.
+    #
+    # @example Is the document flagged?
+    #   document.flagged_for_destroy?
+    #
+    # @return [ true, false ] If the document is flagged.
+    #
+    # @since 2.3.2
+    def flagged_for_destroy?
+      @flagged_for_destroy ||= false
+    end
+    alias :marked_for_destruction? :flagged_for_destroy?
+
+    # Returns true if the +Document+ has been succesfully destroyed, and false
+    # if it hasn't. This is determined by the variable @destroyed and NOT
+    # by checking the database.
+    #
+    # @example Is the document destroyed?
+    #   person.destroyed?
+    #
+    # @return [ true, false ] True if destroyed, false if not.
+    def destroyed?
+      @destroyed ||= false
+    end
+
+    # Is the document readonly?
+    #
+    # @example Is the document readonly?
+    #   document.readonly?
+    #
+    # @return [ true, false ] If the document is readonly.
+    #
+    # @since 4.0.0
+    def readonly?
+      __selected_fields != nil
+    end
+
+    # Determine if the document can be set.
+    #
+    # @example Is this settable?
+    #   person.settable?
+    #
+    # @return [ true, false ] Is this document a new embeds one?
+    #
+    # @since 2.1.0
+    def settable?
+      new_record?
+    end
+
+    # Is the document updateable?
+    #
+    # @example Is the document updateable?
+    #   person.updateable?
+    #
+    # @return [ true, false ] If the document is changed and persisted.
+    #
+    # @since 2.1.0
+    def updateable?
+      persisted? && changed?
+    end
+  end
+end