commutator 0.1.0

data/lib/commutator/item_modifiers.rb

@@ -0,0 +1,24 @@
+module Commutator
+  class ItemModifiers
+    def initialize(modifiers, factory: false)
+      @modifiers = modifiers
+      @factory = factory
+    end
+
+    def factory?
+      @factory
+    end
+
+    # This is a mess, but I wasn't sure how else to guarantee to
+    # call Procs at the time of collection creation
+    def expand_proc_modifiers
+      return self unless factory?
+
+      self.class.new(@modifiers.map(&:call))
+    end
+
+    def modify(item)
+      @modifiers.each { |modifier| modifier.call(item) }
+    end
+  end
+end

data/lib/commutator/model/attributes.rb

@@ -0,0 +1,72 @@
+module Commutator
+  module Model
+    # This module provides methods related to registering attributes
+    # and generating attr_accessors, ultimately for the purpose of
+    # enabling Commutator::Model to know which attributes to send to the db.
+    module Attributes
+      extend ActiveSupport::Concern
+
+      def assign_attributes(attrs = {})
+        attrs.slice(*attribute_names).each do |attr_name, value|
+          send("#{attr_name}=", value)
+        end
+      end
+
+      def attributes
+        attribute_names.each_with_object({}) do |attr_name, hash|
+          hash[attr_name] = send(attr_name)
+        end
+      end
+
+      def attribute_names
+        self.class.attribute_names
+      end
+
+      private
+
+      def convert_type(value, options)
+        return if options.fetch(:allow_nil, true) && value.nil?
+
+        case options[:type]
+        when :array then value.to_a
+        when :boolean then !!value
+        when :float then value.to_f
+        when :hash then value.to_h
+        when :integer then value.to_i
+        when :set then Set.new(value)
+        when :string then value.to_s
+        else value
+        end
+      end
+
+      # :nodoc:
+      module ClassMethods
+        def attribute(*attr_names)
+          options = attr_names.extract_options!
+
+          attr_names.each do |attr_name|
+            attribute_names << attr_name
+
+            # Skip reader and writer methods entirely
+            next if options[:accessor] == false
+
+            define_writer(attr_name, options) unless options[:writer] == false
+            attr_reader attr_name unless options[:reader] == false
+          end
+        end
+
+        def attribute_names
+          @attribute_names ||= Set.new
+        end
+
+        private
+
+        def define_writer(attr_name, options)
+          define_method "#{attr_name}=" do |value|
+            instance_variable_set("@#{attr_name}", convert_type(value, options))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commutator/model/hooks.rb

@@ -0,0 +1,41 @@
+module Commutator
+  module Model
+    module Hooks
+      extend ActiveSupport::Concern
+
+      def run_before_hooks(operation, options)
+        self.class.before_hooks[operation].each do |method_name|
+          send(method_name, options)
+        end
+
+        options
+      end
+
+      module ClassMethods
+        API_ITEM_OPERATIONS.each do |operation|
+          define_method "before_#{operation}" do |*args|
+            add_before_hook(operation, *args)
+          end
+        end
+
+        def add_before_hook(operation, *method_names)
+          method_names.each do |method_name|
+            before_hooks[operation] << method_name
+          end
+        end
+
+        def before_hooks
+          @before_hooks ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        def run_before_hooks(operation, options)
+          before_hooks[operation].each do |method_name|
+            send(method_name, options)
+          end
+
+          options
+        end
+      end
+    end
+  end
+end

data/lib/commutator/model/table_configuration.rb

@@ -0,0 +1,41 @@
+module Commutator
+  module Model
+    # Some basic configuration related to a Dynamo table
+    module TableConfiguration
+      extend ActiveSupport::Concern
+
+      delegate :primary_key_hash_name,
+               :primary_key_range_name,
+               to: 'self.class'
+
+      def primary_key_hash
+        send(primary_key_hash_name)
+      end
+
+      def primary_key_range
+        send(primary_key_range_name) if primary_key_range_name.present?
+      end
+
+      def table_name
+        self.class.table_name
+      end
+
+      # :nodoc:
+      module ClassMethods
+        attr_reader :primary_key_hash_name,
+                    :primary_key_range_name
+
+        def primary_key(options = {})
+          @primary_key_hash_name = options[:hash]
+          @primary_key_range_name = options[:range]
+        end
+
+        def table_name(table_name = nil)
+          return @table_name unless table_name.present?
+
+          @table_name = table_name
+        end
+      end
+    end
+  end
+end

data/lib/commutator/model.rb

@@ -0,0 +1,239 @@
+require "commutator/model/attributes"
+require "commutator/model/table_configuration"
+require "commutator/model/hooks"
+
+module Commutator
+  # Basic CRUD wrapper for items in a dynamodb table.
+  #
+  # This module is focused on collections of homogenous items within a
+  # single table.
+  #
+  # TODO: support multiple tables
+  #
+  # class Person
+  #   include Commutator::Model
+  #
+  #   attribute :first_name,
+  #             :last_name,
+  #             :email
+  #
+  #   attribute :age, type: :integer
+  #   attribute :favorite_color, writer: false
+  #
+  #
+  #   primary_key hash: :email, range: :age
+  #
+  #   def favorite_color=(color)
+  #     @color = color.downcase
+  #   end
+  # end
+  module Model
+    extend ActiveSupport::Concern
+
+    include ActiveModel::Model
+    include Commutator::Model::Attributes
+    include Commutator::Model::TableConfiguration
+    include Commutator::Model::Hooks
+
+    # These build up some basic Dynamo request options related to a particular
+    # api action so that we don't have to specify them every time. They don't
+    # override any values if they are present.
+    included do
+      before_put_item :configure_default_put_item
+      before_update_item :configure_default_update_item
+      before_delete_item :configure_default_delete_item
+
+      before_query :configure_default_query
+      before_scan :configure_default_scan
+      before_get_item :configure_default_get_item
+
+      class_attribute :collection_item_modifiers, instance_accessor: false
+    end
+
+    delegate :client, :options_class, to: 'self.class'
+
+    def initialize(attrs = {})
+      assign_attributes(attrs.symbolize_keys)
+    end
+
+    def put_item_options
+      self.class.build_options_proxy(:put_item, self)
+    end
+
+    def update_item_options
+      self.class.build_options_proxy(:update_item, self)
+    end
+
+    def delete_item_options
+      self.class.build_options_proxy(:delete_item, self)
+    end
+
+    def put_item(options = nil)
+      dynamo_request(:put_item, options) unless invalid?
+      errors.empty?
+    end
+
+    def update_item(options = nil)
+      dynamo_request(:update_item, options) unless invalid?
+      errors.empty?
+    end
+
+    def delete_item(options = nil)
+      dynamo_request(:delete_item, options)
+      return false if errors.present?
+
+      @deleted = true
+      freeze
+    end
+
+    def deleted?
+      @deleted == true
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        primary_key_hash == other.primary_key_hash &&
+        primary_key_range == other.primary_key_range &&
+        attributes == other.attributes
+    end
+
+    private
+
+    def configure_default_put_item(options)
+      options
+        .table_name(table_name)
+        .item(attributes.stringify_keys)
+    end
+
+    def configure_default_update_item(options)
+      options.table_name(table_name)
+    end
+
+    def configure_default_delete_item(options)
+      options
+        .table_name(table_name)
+        .with_key { |key| key[primary_key_hash_name] = primary_key_hash }
+
+      return unless primary_key_range.present?
+
+      options.with_key { |key| key[primary_key_range_name] = primary_key_range }
+    end
+
+    def dynamo_request(operation, options)
+      options ||= self.class.options_class(operation).new
+      run_before_hooks(operation, options)
+      client.send(operation, options)
+    rescue Aws::DynamoDB::Errors::ValidationException,
+           Aws::DynamoDB::Errors::ServiceError => e
+      errors.add(:base, e.message)
+    end
+
+    # :nodoc:
+    module ClassMethods
+      attr_writer :client
+
+      def inherited(subclass)
+        subclass.attribute_names.merge(attribute_names)
+        before_hooks.each { |k, v| subclass.before_hooks[k] = v.dup }
+
+        subclass.table_name(table_name)
+        subclass.primary_key(hash: primary_key_hash_name,
+                             range: primary_key_range_name)
+
+        scopes = const_defined?("Scopes", false) ? const_get("Scopes") : nil
+        subclass.const_set("Scopes", Module.new { include scopes }) if scopes
+      end
+
+      def client
+        @client ||= ::Commutator::SimpleClient.new
+      end
+
+      def create(attrs)
+        new(attrs).tap { |dp| dp.put_item_options.execute }
+      end
+
+      def modify_collection_items_with(*modifiers, factory: false)
+        self.collection_item_modifiers = [ItemModifiers.new(modifiers, factory: factory)].unshift(*collection_item_modifiers)
+      end
+
+      def get_item_options
+        build_options_proxy(:get_item)
+      end
+
+      def query_options
+        build_options_proxy(:query)
+      end
+
+      def scan_options
+        build_options_proxy(:scan)
+      end
+
+      def get_item(options = build_options_proxy(:get_item))
+        item = client.get_item(options).item
+        new(item) unless item.nil?
+      end
+
+      def query(options = build_options_proxy(:query))
+        collection_for(:query, options)
+      end
+
+      def scan(options = build_options_proxy(:scan))
+        collection_for(:scan, options)
+      end
+
+      def build_options_proxy(operation, context = self)
+        Options::Proxy.new(context, operation)
+      end
+
+      def options_class(operation)
+        @scoped_options ||= Hash.new do |h, k|
+          scopes = self.const_defined?("Scopes", false) ? self.const_get("Scopes") : nil
+          const_name = k.to_s.camelize
+          h[k] = enhance_options(const_name, scopes)
+        end
+        @scoped_options[operation]
+      end
+
+      def method_missing(method, *args)
+        super unless respond_to?(method)
+        query_options.send(method, *args)
+      end
+
+      def respond_to?(method)
+        super || (const_defined?(:Scopes, false) && const_get(:Scopes).method_defined?(method))
+      end
+
+      private
+
+      def enhance_options(const_name, scopes = nil)
+        Class.new(Options.const_get(const_name)) do
+          include ::Commutator::Util::Fluent
+          include scopes if scopes && %w[Query Scan].include?(const_name)
+
+          fluent_accessor :_proxy
+          delegate :context, to: :_proxy
+        end
+      end
+
+      def collection_for(operation, options)
+        Collection.new(
+          client.send(operation, options),
+          self,
+          modifiers: Array(collection_item_modifiers)
+        )
+      end
+
+      def configure_default_query(options)
+        options.table_name(table_name)
+      end
+
+      def configure_default_scan(options)
+        options.table_name(table_name)
+      end
+
+      def configure_default_get_item(options)
+        options.table_name(table_name)
+      end
+    end
+  end
+end

data/lib/commutator/options/delete_item.rb

@@ -0,0 +1,48 @@
+module Commutator
+  module Options
+    class DeleteItem
+      include Util::Fluent
+
+      fluent_accessor :key,
+                      :condition_expression,
+                      :expression_attribute_names,
+                      :expression_attribute_values,
+                      :table_name,
+                      :return_values,
+                      :return_consumed_capacity,
+                      :return_item_collection_metrics
+
+      fluent_wrapper :key,
+                     :condition_expression,
+                     :expression_attribute_names,
+                     :expression_attribute_values
+
+      def initialize
+        @key = {}
+
+        @expression_attribute_names = Expressions::AttributeNames.new
+        @expression_attribute_values = Expressions::AttributeValues.new
+
+        @condition_expression = Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+      end
+
+      def to_h
+        hash = {
+          key: key,
+          table_name: table_name,
+          return_values: return_values,
+          return_consumed_capacity: return_consumed_capacity,
+          return_item_collection_metrics: return_item_collection_metrics,
+          expression_attribute_names: expression_attribute_names.to_h,
+          expression_attribute_values: expression_attribute_values.to_h,
+          condition_expression: condition_expression.to_s(wrap: false)
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/commutator/options/get_item.rb

@@ -0,0 +1,41 @@
+module Commutator
+  module Options
+    class GetItem
+      include Util::Fluent
+
+      fluent_accessor :key,
+                      :projection_expression,
+                      :expression_attribute_names,
+                      :consistent_read,
+                      :table_name,
+                      :return_consumed_capacity
+
+      fluent_wrapper :key,
+                     :projection_expression,
+                     :expression_attribute_names
+
+      def initialize
+        @key = {}
+
+        @expression_attribute_names = Expressions::AttributeNames.new
+
+        @projection_expression = Expressions::ProjectionExpression.new(
+          attribute_names: @expression_attribute_names)
+      end
+
+      def to_h
+        hash = {
+          table_name: table_name,
+          expression_attribute_names: expression_attribute_names.to_h,
+          consistent_read: consistent_read,
+          return_consumed_capacity: return_consumed_capacity,
+          projection_expression: projection_expression.to_s,
+          key: key
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/commutator/options/proxy.rb

@@ -0,0 +1,90 @@
+module Commutator
+  module Options
+    class Proxy
+      attr_reader :proxied_history, :options
+
+      def initialize(context, callback_name)
+        @context = context
+        @callback_name = callback_name
+        @proxied_history = []
+
+        @options = instantiate_options
+      end
+
+      class Operation
+        attr_reader :method, :args, :block
+
+        def initialize(method, args, block)
+          @method = method
+          @args = args
+          @block = block
+        end
+
+        def apply(options, chainable_history = nil)
+          options.send(method, *args, &block).tap do |result|
+            # if result == self then that was a call to #with_context
+            chainable_history << self if chainable_history && result == options
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        super unless options.respond_to?(method_name)
+
+        operation = Operation.new(method_name, args, block)
+        result = operation.apply(@options, @proxied_history)
+        result != options ? result : self
+      end
+
+      def respond_to?(*args)
+        super || options.respond_to?(*args)
+      end
+
+      def context(context)
+        @context = context
+        @options = rehydrate_options
+        self
+      end
+
+      def options
+        @options ||= rehydrate_options
+      end
+
+      def execute
+        @context.send(callback_name, options)
+      end
+
+      def first
+        # TODO: asc / desc only work on Query (not Scan)
+        limit(1).asc.execute.items.first
+      end
+
+      def last
+        # TODO: asc / desc only work on Query (not Scan)
+        limit(1).desc.execute.items.first
+      end
+
+      def count
+        response = @context.client.send(callback_name, options.dup.select("COUNT"))
+        response.inject(0) { |sum, page| sum + page.count }
+      end
+
+      private
+
+      def instantiate_options
+        @context.run_before_hooks(
+          @callback_name,
+          @context.options_class(@callback_name).new._proxy(self)
+        )
+      end
+
+      def rehydrate_options
+        instantiate_options.tap do |options|
+          proxied_history.each { |operation| operation.apply(options) }
+        end
+      end
+
+      attr_reader :callback_name
+    end
+  end
+end

data/lib/commutator/options/put_item.rb

@@ -0,0 +1,46 @@
+module Commutator
+  module Options
+    class PutItem
+      include Util::Fluent
+
+      fluent_accessor :item,
+                      :condition_expression,
+                      :expression_attribute_names,
+                      :expression_attribute_values,
+                      :return_consumed_capacity,
+                      :return_item_collection_metrics,
+                      :return_values,
+                      :table_name
+
+      fluent_wrapper :item,
+                     :condition_expression,
+                     :expression_attribute_names,
+                     :expression_attribute_values
+
+      def initialize
+        @expression_attribute_names ||= Expressions::AttributeNames.new
+        @expression_attribute_values ||= Expressions::AttributeValues.new
+
+        @condition_expression ||= Expressions::ConditionExpression.new(
+          attribute_names: @expression_attribute_names,
+          attribute_values: @expression_attribute_values)
+      end
+
+      def to_h
+        hash = {
+          condition_expression: condition_expression.to_s(wrap: false),
+          expression_attribute_names: expression_attribute_names.to_h,
+          expression_attribute_values: expression_attribute_values.to_h,
+          item: item.to_h,
+          return_consumed_capacity: return_consumed_capacity,
+          return_item_collection_metrics: return_item_collection_metrics,
+          return_values: return_values,
+          table_name: table_name
+        }
+
+        hash.keep_if { |_key, value| value.present? || value == false }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end