tiny_dyno 0.1.0

data/lib/tiny_dyno/document.rb

@@ -0,0 +1,100 @@
+require 'tiny_dyno/document_composition'
+
+module TinyDyno
+  module Document
+
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+    include ActiveModel::Dirty
+    include ActiveModel::Model
+
+    include DocumentComposition
+
+    included do
+      TinyDyno.register_model(self)
+    end
+
+    # Instantiate a new +Document+, setting the Document's attributes if
+    # given. If no attributes are provided, they will be initialized with
+    # an empty +Hash+.
+    #
+    # The Hash Key must currently be provided from the applicationIf a HashKey is defined, the document's id will be set to that key,
+    #
+    # @example Create a new document.
+    #   Person.new(hash_key: hash_key, title: "Sir")
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    #
+    # @return [ Document ] A new document.
+    # @since 1.0.0
+    def initialize(attrs = nil)
+      @new_record = true
+      @attributes ||= {}
+      process_attributes(attrs) do
+        yield(self) if block_given?
+      end
+      # run_callbacks(:initialize) unless _initialize_callbacks.empty?
+      # raise ::TinyDyno::Errors::MissingHashKey.new(self.name) unless @hash_key.is_a?(Hash)
+    end
+
+    def delete
+      request_delete
+    end
+
+    private
+
+    def request_delete
+      request = {
+          table_name: self.class.table_name,
+          key: hash_key_as_selector
+      }
+      TinyDyno::Adapter.delete_item(request: request)
+    end
+
+    module ClassMethods
+
+      def where(options = {})
+        valid_option_keys(options)
+        get_query = build_where_query(options)
+        attributes = TinyDyno::Adapter.get_item(get_item_request: get_query)
+        if attributes.nil?
+          return false
+        else
+          self.new(attributes)
+        end
+      end
+
+      private
+
+      # minimimum implementation for now
+      # check that each option key relates to a hash_key present on the model
+      # do not permit scan queries
+      def valid_option_keys(options)
+        options.keys.each do |name|
+          named = name.to_s
+          raise TinyDyno::Errors::HashKeysOnly.new(klass: self.class, name: named) unless hash_key_is_defined?(named)
+        end
+      end
+
+      # minimimum implementation for now
+      # build simple query to retrieve document
+      # via get_item
+      # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#get_item-instance_method
+      def build_where_query(options)
+        query_keys = {}
+        options.each do |k,v|
+          # as expected by DynamoDB
+          typed_key = k.to_s
+          query_keys[typed_key] = dyno_typed_key(key: typed_key, val: v)
+        end
+        {
+            table_name: self.table_name,
+            attributes_to_get: attribute_names,
+            key: query_keys
+        }
+      end
+
+    end
+
+  end
+end

data/lib/tiny_dyno/document_composition.rb

@@ -0,0 +1,49 @@
+require 'tiny_dyno/attributes'
+require 'tiny_dyno/changeable'
+require 'tiny_dyno/fields'
+require 'tiny_dyno/stateful'
+require 'tiny_dyno/tables'
+require 'tiny_dyno/hash_keys'
+require 'tiny_dyno/persistable'
+
+module TinyDyno
+  module DocumentComposition
+    extend ActiveSupport::Concern
+
+    include Attributes
+    include Changeable
+    include Fields
+    include HashKeys
+    include Persistable
+    include Stateful
+    include Tables
+
+
+    MODULES = [
+        Attributes,
+        Changeable,
+        Fields,
+        HashKeys,
+        Persistable,
+        Stateful,
+        Tables,
+    ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including TinyDyno::Document.
+      #
+      # @example Bad thing!
+      #   TinyDyno::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map(&:to_sym)
+        end
+      end
+    end
+
+  end
+end

data/lib/tiny_dyno/errors.rb

@@ -0,0 +1,4 @@
+require 'tiny_dyno/errors/tiny_dyno_error'
+
+require 'tiny_dyno/errors/attribute_errors'
+require 'tiny_dyno/errors/hash_key_errors'

data/lib/tiny_dyno/errors/attribute_errors.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module TinyDyno
+  module Errors
+
+    # This error is raised when trying to set a value in TinyDyno that is not
+    # already set with dynamic attributes or the field is not defined.
+    class UnknownAttribute < TinyDynoError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   UnknownAttribute.new(Person, "gender")
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String, Symbol ] name The name of the attribute.
+      #
+      # @since 3.0.0
+      def initialize(klass, name)
+        super(
+            compose_message("unknown_attribute", { klass: klass.name, name: name })
+        )
+      end
+    end
+  end
+end

data/lib/tiny_dyno/errors/hash_key_errors.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+module TinyDyno
+  module Errors
+
+    # This error is raised when trying to set a value in Mongoid that is not
+    # already set with dynamic attributes or the field is not defined.
+    class InvalidHashKey < TinyDynoError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   UnknownAttribute.new(Person, "gender")
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String, Symbol ] name The name of the attribute.
+      #
+      # @since 3.0.0
+      def initialize(klass:, name:)
+        super(
+            compose_message("invalid hash_key", { klass: klass.name, name: name })
+        )
+      end
+    end
+  end
+end
+
+# encoding: utf-8
+module TinyDyno
+  module Errors
+
+    # This error is raised when trying to set a value in Mongoid that is not
+    # already set with dynamic attributes or the field is not defined.
+    class MissingHashKey < TinyDynoError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   UnknownAttribute.new(Person, "gender")
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String, Symbol ] name The name of the attribute.
+      #
+      # @since 3.0.0
+      def initialize(klass:)
+        super(
+            compose_message("no hash key specified", { klass: klass.name })
+        )
+      end
+    end
+  end
+end
+
+
+# encoding: utf-8
+module TinyDyno
+  module Errors
+
+    # This error is raised, when a query is performed with fields specified
+    # that are not HashKeys, which would result in a table scan
+    class HashKeysOnly < TinyDynoError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   HashKeysOnly.new(Person, "gender")
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String, Symbol ] name The name of the attribute.
+      #
+      # @since 3.0.0
+      def initialize(klass:, name:)
+        super(
+            compose_message("only search for hash keys", { klass: klass.name, name: name })
+        )
+      end
+    end
+  end
+end

data/lib/tiny_dyno/errors/tiny_dyno_error.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module TinyDyno::Errors
+  class TinyDynoError < StandardError
+
+    BASE_KEY = "tiny_dyno.errors.messages"
+
+    # Compose the message.
+    #
+    # @example Create the message
+    #   error.compose_message
+    #
+    # @return [ String ] The composed message.
+    def compose_message(key, attributes)
+      @problem = problem(key, attributes)
+      @summary = summary(key, attributes)
+      @resolution = resolution(key, attributes)
+
+      "\nProblem:\n  #{@problem}"+
+          "\nSummary:\n  #{@summary}"+
+          "\nResolution:\n  #{@resolution}"
+    end
+
+    private
+
+    # Given the key of the specific error and the options hash, translate the
+    # message.
+    #
+    # @example Translate the message.
+    #   error.translate("errors", :key => value)
+    #
+    # @param [ String ] key The key of the error in the locales.
+    # @param [ Hash ] options The objects to pass to create the message.
+    #
+    # @return [ String ] A localized error message string.
+    def translate(key, options)
+      ::I18n.translate("#{BASE_KEY}.#{key}", options)
+    end
+
+    # Create the problem.
+    #
+    # @example Create the problem.
+    #   error.problem("error", {})
+    #
+    # @param [ String, Symbol ] key The error key.
+    # @param [ Hash ] attributes The attributes to interpolate.
+    #
+    # @return [ String ] The problem.
+    #
+    # @since 3.0.0
+    def problem(key, attributes)
+      translate("#{key}.message", attributes)
+    end
+
+    # Create the summary.
+    #
+    # @example Create the summary.
+    #   error.summary("error", {})
+    #
+    # @param [ String, Symbol ] key The error key.
+    # @param [ Hash ] attributes The attributes to interpolate.
+    #
+    # @return [ String ] The summary.
+    #
+    # @since 3.0.0
+    def summary(key, attributes)
+      translate("#{key}.summary", attributes)
+    end
+
+    # Create the resolution.
+    #
+    # @example Create the resolution.
+    #   error.resolution("error", {})
+    #
+    # @param [ String, Symbol ] key The error key.
+    # @param [ Hash ] attributes The attributes to interpolate.
+    #
+    # @return [ String ] The resolution.
+    #
+    # @since 3.0.0
+    def resolution(key, attributes)
+      translate("#{key}.resolution", attributes)
+    end
+
+  end
+end

data/lib/tiny_dyno/extensions.rb

@@ -0,0 +1 @@
+require 'tiny_dyno/extensions/module'

data/lib/tiny_dyno/extensions/module.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module TinyDyno
+  module Extensions
+    module Module
+
+      # Redefine the method. Will undef the method if it exists or simply
+      # just define it.
+      #
+      # @example Redefine the method.
+      #   Object.re_define_method("exists?") do
+      #     self
+      #   end
+      #
+      # @param [ String, Symbol ] name The name of the method.
+      # @param [ Proc ] block The method body.
+      #
+      # @return [ Method ] The new method.
+      #
+      # @since 3.0.0
+      def re_define_method(name, &block)
+        undef_method(name) if method_defined?(name)
+        define_method(name, &block)
+      end
+    end
+  end
+end
+
+::Module.__send__(:include, TinyDyno::Extensions::Module)

data/lib/tiny_dyno/fields.rb

@@ -0,0 +1,299 @@
+require 'tiny_dyno/fields/standard'
+
+module TinyDyno
+  module Fields
+    extend ActiveSupport::Concern
+
+    TYPE_MAPPINGS= {
+        # binary_blob: 'B',
+        # bool: Boolean,
+        # binary_set: Array,
+        list: Array,
+        map: Hash,
+        number: Integer,
+        number_set: Array,
+        # null: Null,
+        string: String,
+        string_set: Array,
+        time: Time,
+    }
+
+    SUPPORTED_FIELD_TYPES = [Array, Hash, Integer, Array, String, Time].freeze
+
+    included do
+      class_attribute :fields
+
+      self.fields = {}
+
+    end
+
+    class << self
+
+      # Stores the provided block to be run when the option name specified is
+      # defined on a field.
+      #
+      # No assumptions are made about what sort of work the handler might
+      # perform, so it will always be called if the `option_name` key is
+      # provided in the field definition -- even if it is false or nil.
+      #
+      # @example
+      #   TinyDyno::Fields.option :required do |model, field, value|
+      #     model.validates_presence_of field if value
+      #   end
+      #
+      # @param [ Symbol ] option_name the option name to match against
+      # @param [ Proc ] block the handler to execute when the option is
+      #   provided.
+      #
+      # @since 2.1.0
+
+      def option(option_name, &block)
+        options[option_name] = block
+      end
+
+      # Return a map of custom option names to their handlers.
+      #
+      # @example
+      #   TinyDyno::Fields.options
+      #   # => { :required => #<Proc:0x00000100976b38> }
+      #
+      # @return [ Hash ] the option map
+      #
+      # @since 2.1.0
+      def options
+        @options ||= {}
+      end
+    end
+
+    # Get the name of the provided field as it is stored in the database.
+    # Used in determining if the field is aliased or not.
+    #
+    # @example Get the database field name.
+    #   model.database_field_name(:authorization)
+    #
+    # @param [ String, Symbol ] name The name to get.
+    #
+    # @return [ String ] The name of the field as it's stored in the db.
+    #
+    # @since 3.0.7
+    def database_field_name(name)
+      self.class.database_field_name(name)
+    end
+
+    module ClassMethods
+
+      # Returns an array of names for the attributes available on this object.
+      #
+      # Provides the field names in an ORM-agnostic way. Rails v3.1+ uses this
+      # method to automatically wrap params in JSON requests.
+      #
+      # @example Get the field names
+      #   Model.attribute_names
+      #
+      # @return [ Array<String> ] The field names
+      #
+      # @since 3.0.0
+      def attribute_names
+        fields.keys
+      end
+
+      # Get the name of the provided field as it is stored in the database.
+      # Used in determining if the field is aliased or not.
+      #
+      # @example Get the database field name.
+      #   Model.database_field_name(:authorization)
+      #
+      # @param [ String, Symbol ] name The name to get.
+      #
+      # @return [ String ] The name of the field as it's stored in the db.
+      #
+      # @since 3.0.7
+      def database_field_name(name)
+        return nil unless name
+        normalized = name.to_s
+      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 field(name, options = {})
+        named = name.to_s
+        added = add_field(named, options)
+        added
+      end
+
+      protected
+
+      # Define a field attribute for the +Document+.
+      #
+      # @example Set the field.
+      #   Person.add_field(:name, :default => "Test")
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The hash of options.
+      def add_field(name, options = {})
+        field = field_for(name, options)
+        fields[name] = field
+        create_accessors(name, name, options)
+        process_options(field)
+        field
+      end
+
+      # Run through all custom options stored in TinyDyno::Fields.options and
+      # execute the handler if the option is provided.
+      #
+      # @example
+      #   TinyDyno::Fields.option :custom do
+      #     puts "called"
+      #   end
+      #
+      #   field = TinyDyno::Fields.new(:test, :custom => true)
+      #   Person.process_options(field)
+      #   # => "called"
+      #
+      # @param [ Field ] field the field to process
+      def process_options(field)
+        field_options = field.options
+
+        Fields.options.each_pair do |option_name, handler|
+          if field_options.key?(option_name)
+            handler.call(self, field, field_options[option_name])
+          end
+        end
+      end
+
+      def field_for(name, options)
+        opts = options.merge(klass: self)
+        Fields::Standard.new(name, opts)
+      end
+
+      # Create the field accessors.
+      #
+      # @example Generate the accessors.
+      #   Person.create_accessors(:name, "name")
+      #   person.name #=> returns the field
+      #   person.name = "" #=> sets the field
+      #   person.name? #=> Is the field present?
+      #   person.name_before_type_cast #=> returns the field before type cast
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Symbol ] meth The name of the accessor.
+      # @param [ Hash ] options The options.
+      #
+      # @since 2.0.0
+      def create_accessors(name, meth, options = {})
+        field = fields[name]
+
+        create_field_getter(name, meth, field)
+        create_field_setter(name, meth, field)
+        create_field_check(name, meth)
+
+      end
+
+      # Create the getter method for the provided field.
+      #
+      # @example Create the getter.
+      #   Model.create_field_getter("name", "name", field)
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      # @param [ Field ] field The field.
+      def create_field_getter(name, meth, field)
+        generated_methods.module_eval do
+          re_define_method(meth) do
+            raw = read_attribute(name)
+            value = typed_value_for(name, raw)
+            attribute_will_change!(value)
+            value
+          end
+        end
+      end
+
+      # Create the getter_before_type_cast method for the provided field. If
+      # the attribute has been assigned, return the attribute before it was
+      # type cast. Otherwise, delegate to the getter.
+      #
+      # @example Create the getter_before_type_cast.
+      # Model.create_field_getter_before_type_cast("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      def create_field_getter_before_type_cast(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}_before_type_cast") do
+            if has_attribute_before_type_cast?(name)
+              read_attribute_before_type_cast(name)
+            else
+              send meth
+            end
+          end
+        end
+      end
+      # Create the setter method for the provided field.
+      #
+      # @example Create the setter.
+      #   Model.create_field_setter("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      # @param [ Field ] field The field.
+      def create_field_setter(name, meth, field)
+        generated_methods.module_eval do
+          re_define_method("#{meth}=") do |value|
+            val = write_attribute(name, value)
+            val
+          end
+        end
+      end
+
+      # Create the check method for the provided field.
+      #
+      # @example Create the check.
+      #   Model.create_field_check("name", "name")
+      #
+      # @param [ String ] name The name of the attribute.
+      # @param [ String ] meth The name of the method.
+      #
+      # @since 2.4.0
+      def create_field_check(name, meth)
+        generated_methods.module_eval do
+          re_define_method("#{meth}?") do
+            attr = read_attribute(name)
+            attr == true || attr.present?
+          end
+        end
+      end
+
+      # Include the field methods as a module, so they can be overridden.
+      #
+      # @example Include the fields.
+      #   Person.generated_methods
+      #
+      # @return [ Module ] The module of generated methods.
+      #
+      # @since 2.0.0
+      def generated_methods
+        @generated_methods ||= begin
+          mod = Module.new
+          include(mod)
+          mod
+        end
+      end
+
+    end
+
+  end
+end