tiny_dyno 0.1.0

data/lib/tiny_dyno.rb

@@ -0,0 +1,44 @@
+require 'active_model'
+require 'aws-sdk'
+
+if ENV['RACK_ENV'] == 'development'
+require 'pry'
+require 'awesome_print'
+end
+
+require 'tiny_dyno/extensions'
+
+require 'tiny_dyno/version'
+require 'tiny_dyno/loggable'
+require 'tiny_dyno/errors'
+require 'tiny_dyno/document'
+require 'tiny_dyno/adapter'
+
+I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+
+module TinyDyno
+  extend Loggable
+  extend self
+
+  # Register a model in the application with TinyDyno.
+  #
+  # @example Register a model.
+  #   config.register_model(Band)
+  #
+  # @param [ Class ] klass The model to register.
+  def register_model(klass)
+    models.push(klass) unless models.include?(klass)
+  end
+
+  # Get all the models in the application - this is everything that includes
+  # TinyDyno::Document.
+  #
+  # @example Get all the models.
+  #   config.models
+  #
+  # @return [ Array<Class> ] All the models in the application.
+  def models
+    @models ||= []
+  end
+
+end

data/lib/tiny_dyno/adapter.rb

@@ -0,0 +1,48 @@
+require 'aws-sdk'
+
+require 'tiny_dyno/adapter/tables'
+require 'tiny_dyno/adapter/items'
+
+module TinyDyno
+
+  # Interactions with the DynamoDB store through aws-sdk-v2
+  module Adapter
+    extend ActiveSupport::Concern
+    extend self
+
+    attr_reader :table_names
+
+    @table_names = []
+
+    def connect
+      connection
+      connected?
+    end
+
+    def connected?
+      begin
+        connection.list_tables(limit: 1)
+      rescue Errno::ECONNREFUSED, Aws::DynamoDB::Errors::UnrecognizedClientException => e
+        return false
+      end
+      return true if @connection.class == Aws::DynamoDB::Client
+      return false
+    end
+
+    def disconnect!
+      @connection = nil
+    end
+
+    protected
+
+    def connection
+      unless @connection
+        TinyDyno.logger.info 'setting up new connection ... ' if TinyDyno.logger
+        @connection =  Aws::DynamoDB::Client.new
+        update_table_cache
+      end
+      @connection
+    end
+
+  end
+end

data/lib/tiny_dyno/adapter/items.rb

@@ -0,0 +1,27 @@
+module TinyDyno
+  module Adapter
+    extend self
+
+    def update_item(update_item_request:)
+      connection.update_item(update_item_request).successful?
+    end
+
+    def put_item(put_item_request:)
+      connection.put_item(put_item_request).successful?
+    end
+
+    def get_item(get_item_request:)
+      resp = connection.get_item(get_item_request)
+      if resp.respond_to?(:item)
+        resp.item
+      else
+        false
+      end
+    end
+
+    def delete_item(request:)
+      connection.delete_item(request).successful?
+    end
+
+  end
+end

data/lib/tiny_dyno/adapter/tables.rb

@@ -0,0 +1,103 @@
+module TinyDyno
+  module Adapter
+    extend self
+
+    # Terminology in here is directly derived from the aws sdk language
+    #
+    # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#create_table-instance_method
+    #
+    # The current implementation is a strict 1:1 relation of 1 Model to 1 table
+
+    # Answer, whether a table is present, first by cache lookup and if miss on datastore
+    #
+    # @example Does the table exists?
+    #   TinyDyno::Adapter.table_exists?(table_name: Person.table_name)
+    # @return [ true ] if the table is present
+
+    def table_exists?(table_name:)
+      return true if @table_names.include?(table_name)
+      update_table_cache
+      @table_names.include?(table_name)
+    end
+
+    # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#create_table-instance_method
+    # expect create_table_request to conform to above schema
+    #
+    # Send the actual table creation to DynamoDB
+    #
+    # @example Create the table for the class
+    #   Person.create_table
+    #
+    # @return [ true ] if the operation succeeds
+
+    def create_table(create_table_request)
+      table_settings = {
+          provisioned_throughput: {
+              read_capacity_units: 200,
+              write_capacity_units: 200,
+          },
+      }.merge!(create_table_request)
+
+      # Should or shouldn't we?
+      # begin
+      #   resp = connection.describe_table(table_name: table_settings[:table_name])
+      # rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+      # ensure
+      #   if resp.respond_to?(:table)
+      #     p "Warning, table was already present : #{ table_settings[:table_name]}"
+      #   end
+      # end
+      connection.create_table(table_settings)
+      if wait_on_table_status(table_status: :table_exists, table_name: table_settings[:table_name])
+        update_table_cache
+        return true
+      else
+        return false
+      end
+    end
+
+    def delete_table(table_name:)
+      begin
+        connection.describe_table(table_name: table_name)
+      rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+        # table not there anyway
+        return true
+      end
+      if wait_on_table_status(table_status: :table_exists, table_name: table_name)
+        connection.delete_table(table_name: table_name)
+      else
+        return false
+      end
+      wait_on_table_status(table_status: :table_not_exists, table_name: table_name)
+      update_table_cache
+      return true unless table_exists?(table_name: table_name)
+      return false
+    end
+
+    # Hold a cache of available table names in an instance variable
+    #
+    def update_table_cache
+      return unless connected?
+      new_table_names = connection.list_tables.table_names
+      @table_names = new_table_names
+    end
+
+    private
+
+    # Use the aws-sdk provided waiter methods to wait on either
+    # table_exists, table_not_exists
+    def wait_on_table_status(table_status:, table_name:)
+      begin
+        connection.wait_until(table_status, table_name: table_name) do |w|
+          w.interval = 1
+          w.max_attempts = 10
+        end
+      rescue Aws::Waiters::Errors => e
+        p "Waiter failed: #{ e .inspect }"
+        return false
+      end
+      return true
+    end
+
+  end
+end

data/lib/tiny_dyno/attributes.rb

@@ -0,0 +1,157 @@
+require 'active_model/attribute_methods'
+
+require 'tiny_dyno/attributes/readonly'
+
+module TinyDyno
+  module Attributes
+
+    extend ActiveSupport::Concern
+
+    include Readonly
+
+    attr_reader :attributes
+
+    # Read a value from the document attributes. If the value does not exist
+    # it will return nil.
+    #
+    # @example Read an attribute.
+    #   person.read_attribute(:title)
+    #
+    # @example Read an attribute (alternate syntax.)
+    #   person[:title]
+    #
+    # @param [ String, Symbol ] name The name of the attribute to get.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @since 1.0.0
+    def read_attribute(name)
+      normalized = database_field_name(name.to_s)
+      if attribute_missing?(normalized)
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'."
+      end
+      attributes[normalized]
+    end
+    alias :[] :read_attribute
+
+
+    # Write a single attribute to the document attribute hash. This will
+    # also fire the before and after update callbacks, and perform any
+    # necessary typecasting.
+    # called from within ActiveModel
+    #
+    # @example Write the attribute.
+    #   person.write_attribute(:title, "Mr.")
+    #
+    # @example Write the attribute (alternate syntax.)
+    #   person[:title] = "Mr."
+    #
+    # @param [ String, Symbol ] name The name of the attribute to update.
+    # @param [ Object ] value The value to set for the attribute.
+    #
+    # @since 1.0.0
+    def write_attribute(name, value)
+      access = database_field_name(name.to_s)
+      typed_value = typed_value_for(access, value)
+      if attribute_writable?(access)
+        unless attributes[access] == typed_value|| attribute_changed?(access)
+          attribute_will_change!(access)
+        end
+        attributes[access] = typed_value
+        typed_value
+      end
+    end
+    alias :[]= :write_attribute
+
+    # Process the provided attributes casting them to their proper values if a
+    # field exists for them on the document. This will be limited to only the
+    # attributes provided in the suppied +Hash+ so that no extra nil values get
+    # put into the document's attributes.
+    #
+    # @example Process the attributes.
+    #   person.process_attributes(:title => "sir", :age => 40)
+    #
+    # @param [ Hash ] attrs The attributes to set.
+    #
+    # @since 2.0.0.rc.7
+    def process_attributes(attrs = nil)
+      attrs ||= {}
+      if !attrs.empty?
+        attrs.each_pair do |key, value|
+          process_attribute(key, value)
+        end
+      end
+      # context?
+      # yield self if block_given?
+    end
+
+    # If the attribute is dynamic, add a field for it with a type of object
+    # and then either way set the value.
+    #
+    # @example Process the attribute.
+    #   document.process_attribute(name, value)
+    #
+    # @param [ Symbol ] name The name of the field.
+    # @param [ Object ] value The value of the field.
+    #
+    # @since 2.0.0.rc.7
+    def process_attribute(name, value)
+      responds = respond_to?("#{name}=", true)
+      raise TinyDyno::Errors::UnknownAttribute.new(self.class, name) unless responds
+      send("#{name}=", value)
+    end
+
+    # Return the typecasted value for a field.
+    # Based on the field option, type
+    # which is mandatory
+    #
+    # @example Get the value typecasted.
+    #   person.typed_value_for(:title, :sir)
+    #
+    # @param [ String, Symbol ] key The field name.
+    # @param [ Object ] value The uncast value.
+    #
+    # @return [ Object ] The cast value.
+    #
+    # @since 1.0.0
+    def typed_value_for(key, value)
+      # raise MissingAttributeError if fields[key].nil? and hash_keys.find_index { |a| a[:attr] == key }.nil?
+      raise MissingAttributeError if fields[key].nil?
+      typed_class = self.fields[key].options[:type]
+      return (self.class.document_typed(klass: typed_class, value: value))
+    end
+
+    # Determine if the attribute is missing from the document, due to loading
+    # it from the database with missing fields.
+    #
+    # @example Is the attribute missing?
+    #   document.attribute_missing?("test")
+    #
+    # @param [ String ] name The name of the attribute.
+    #
+    # @return [ true, false ] If the attribute is missing.
+    #
+    # @since 4.0.0
+    def attribute_missing?(name)
+      return (!self.fields.keys.include?(name))
+    end
+
+    private
+
+
+    module ClassMethods
+
+      # convert to the type used on the Document
+      def document_typed(klass:, value: )
+        if klass == String
+          value.blank? ? nil : value.to_s
+        elsif (klass == Integer or klass == Fixnum )
+          value.to_i
+        else
+          value
+        end
+      end
+    end
+
+  end
+end

data/lib/tiny_dyno/attributes/readonly.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module TinyDyno
+  module Attributes
+
+    # This module defines behaviour for readonly attributes.
+    module Readonly
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :readonly_attributes
+        self.readonly_attributes = ::Set.new
+      end
+
+      # Are we able to write the attribute with the provided name?
+      #
+      # @example Can we write the attribute?
+      #   model.attribute_writable?(:title)
+      #
+      # @param [ String, Symbol ] name The name of the field.
+      #
+      # @return [ true, false ] If the document is new, or if the field is not
+      #   readonly.
+      #
+      # @since 3.0.0
+      def attribute_writable?(name)
+        new_record? || !readonly_attributes.include?(database_field_name(name))
+      end
+
+      module ClassMethods
+
+        # Defines an attribute as readonly. This will ensure that the value for
+        # the attribute is only set when the document is new or we are
+        # creating. In other cases, the field write will be ignored with the
+        # exception of #remove_attribute and #update_attribute, where an error
+        # will get raised.
+        #
+        # @example Flag fields as readonly.
+        #   class Band
+        #     include TinyDyno::Document
+        #     field :name, type: String
+        #     field :genre, type: String
+        #     attr_readonly :name, :genre
+        #   end
+        #
+        # @param [ Array<Symbol> ] names The names of the fields.
+        #
+        # @since 3.0.0
+        def attr_readonly(*names)
+          names.each do |name|
+            readonly_attributes << database_field_name(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiny_dyno/changeable.rb

@@ -0,0 +1,68 @@
+module TinyDyno
+
+  # Defines behaviour for dirty tracking.
+  #
+  # @since 4.0.0
+  module Changeable
+    extend ActiveSupport::Concern
+
+    # Get the changed attributes for the document.
+    #
+    # @example Get the changed attributes.
+    #   model.changed
+    #
+    # @return [ Array<String> ] The changed attributes.
+    #
+    # @since 2.4.0
+    def changed
+      changed_attributes.keys.select { |attr| attribute_change(attr) }
+    end
+
+    # Get the attribute changes.
+    #
+    # @example Get the attribute changes.
+    #   model.changed_attributes
+    #
+    # @return [ Hash<String, Object> ] The attribute changes.
+    #
+    # @since 2.4.0
+    def changed_attributes
+      @changed_attributes ||= {}
+    end
+
+    # Get all the changes for the document.
+    #
+    # @example Get all the changes.
+    #   model.changes
+    #
+    # @return [ Hash<String, Array<Object, Object> ] The changes.
+    #
+    # @since 2.4.0
+    def changes
+      _changes = {}
+      changed.each do |attr|
+        change = attribute_change(attr)
+        _changes[attr] = change if change
+      end
+      _changes
+    end
+
+    private
+
+    # Get the old and new value for the provided attribute.
+    #
+    # @example Get the attribute change.
+    #   model.attribute_change("name")
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ Array<Object> ] The old and new values.
+    #
+    # @since 2.1.0
+    def attribute_change(attr)
+      attr = database_field_name(attr)
+      [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
+    end
+
+  end
+end