ormivore 0.0.1

data/lib/ormivore/errors.rb

@@ -0,0 +1,21 @@
+require 'nested_exceptions'
+
+module ORMivore
+  class NotImplementedYet < StandardError; end
+
+  class ORMivoreError < StandardError
+    include NestedExceptions
+  end
+
+  class BadArgumentError < ORMivoreError; end
+  class BadAttributesError < BadArgumentError; end
+  class BadConditionsError < BadArgumentError; end
+
+  class InvalidStateError < ORMivoreError; end
+
+  class AbstractMethodError < ORMivoreError; end
+
+  class StorageError < ORMivoreError; end
+  class RecordNotFound < StorageError; end
+  class RecordAlreadyExists < StorageError; end
+end

data/lib/ormivore/memory_adapter.rb

@@ -0,0 +1,99 @@
+module ORMivore
+  module MemoryAdapter
+    module ClassMethods
+      attr_reader :default_converter_class
+
+      private
+      attr_writer :default_converter_class
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(converter = nil)
+      @converter = converter || self.class.default_converter_class.new
+    end
+
+    def find(conditions, attributes_to_load, options = {})
+      order = options.fetch(:order, {})
+
+      reorder(
+        filter_from_storage(conditions, attributes_to_load),
+        order
+      )
+    end
+
+    def create(attrs)
+      id = attrs[:id]
+      if id
+        raise RecordAlreadyExists if storage.any? { |o| o[:id] == id }
+      else
+        id = next_id
+      end
+      attrs.merge(id: id).tap { |attrs_with_id|
+        storage << attrs_with_id
+      }
+    end
+
+    def update(attrs, conditions)
+      select_from_storage(conditions).each { |record|
+        record.merge!(attrs)
+      }.length
+    end
+
+    # open for tests, not to be used by any other code
+    def storage
+      @storage ||= []
+    end
+
+    private
+
+    def select_from_storage(conditions)
+      storage.select { |o|
+        conditions.all? { |k, v|
+          if v.is_a?(Enumerable)
+            v.include?(o[k])
+          else
+            o[k] == v
+          end
+        }
+      }
+    end
+
+    def filter_from_storage(conditions, attributes_to_load)
+      select_from_storage(conditions).map { |record|
+        record.select { |k, v| attributes_to_load.include?(k) }
+      }
+    end
+
+    def reorder(records, order)
+      return records if order.empty?
+
+      records.sort { |x, y|
+        order.inject(0) { |acc, (k, v)|
+          break unless acc.zero?
+
+          multiplier =
+            case v
+            when :ascending
+              1
+            when :descending
+              -1
+            else
+              raise BadArgumentError, "Order direction #{v} is invalid"
+            end
+          (x[k] <=> y[k]) * multiplier
+        }
+      }
+    end
+
+    attr_reader :converter
+
+    def next_id
+      (@next_id ||= 1).tap { |current_id|
+        @next_id = current_id + 1
+      }
+    end
+  end
+end

data/lib/ormivore/port.rb

@@ -0,0 +1,95 @@
+# TODO maybe add validations for conditions, if not attributes
+# TODO add support for transactions
+module ORMivore
+  module Port
+    module ClassMethods
+      attr_reader :attributes
+
+      private
+      attr_writer :attributes
+
+=begin
+      def finders(*methods)
+        methods.each do |method|
+          instance_eval <<-EOS
+            def #{method}(*args, &block)
+              storage.__send__(:#{method}, *args, &block)
+            end
+          EOS
+        end
+      end
+=end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    # a good place to add generic storage functionality,
+    # like 'around' logging/performance monitoring/notifications/etc
+    # first obvious candidate is exception handling
+
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def find(conditions, attributes_to_load, options = {})
+      # TODO verify conditions to contain only keys that match attribute names and value of proper type
+      validate_finder_options(options, attributes_to_load)
+
+      adapter.find(conditions, attributes_to_load, options)
+    end
+
+    def create(attrs)
+      begin
+        adapter.create(attrs)
+      rescue => e
+        raise ORMivore::StorageError, e.message
+      end
+    end
+
+    def update(attrs, conditions)
+      adapter.update(attrs, conditions)
+    rescue => e
+      raise ORMivore::StorageError, e.message
+    end
+
+    private
+
+    attr_reader :adapter
+
+=begin
+    def attributes
+      self.class.attributes
+    end
+
+    def validate_conditions(conditions)
+      extra = conditions.keys - attributes.keys
+      raise BadConditionsError, extra.join("\n") unless extra.empty?
+    end
+=end
+
+    def validate_finder_options(options, attributes_to_load)
+      options = options.dup
+      valid = true
+
+      # TODO how about other finder options, like limit and offset?
+      order = options.delete(:order) || {}
+      valid = false unless options.empty?
+
+      raise ORMivore::BadArgumentError, "Invalid finder options #{options.inspect}" unless valid
+
+      validate_order(order, attributes_to_load)
+
+      nil
+    end
+
+    def validate_order(order, attributes_to_load)
+      # TODO matching agains attributes_to_load is not good, sometimes user wants to sort on non-loaded attribute
+      return if order.empty?
+
+      unless order.keys.all? { |k| attributes_to_load.include?(k) }
+        raise BadArgumentError, "Invalid order key in #{order.inspect}"
+      end
+    end
+  end
+end

data/lib/ormivore/repo.rb

@@ -0,0 +1,58 @@
+module ORMivore
+  module Repo
+    module ClassMethods
+      attr_reader :default_entity_class
+
+      private
+      attr_writer :default_entity_class
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(port, entity_class = nil)
+      @port = port
+      @entity_class = entity_class || self.class.default_entity_class
+    end
+
+    def find_by_id(id, options = {})
+      quiet = options.fetch(:quiet, false)
+
+      attrs_to_entity(port.find(
+          { id: id },
+          [:id].concat(entity_class.attributes_list),
+          {}
+        ).first
+     ).tap { |record|
+       raise RecordNotFound, "#{entity_class.name} with id #{id} was not found" if record.nil? && !quiet
+     }
+    end
+
+    def persist(entity)
+      if entity.id
+        count = port.update(entity.changes, { :id => entity.id })
+        raise ORMivore::StorageError, 'No records updated' if count.zero?
+        raise ORMivore::StorageError, 'WTF' if count > 1
+
+        entity_class.construct(entity.attributes, entity.id)
+      else
+        attrs_to_entity(port.create(entity.changes))
+      end
+    end
+
+    private
+
+    attr_reader :port, :entity_class
+
+    def attrs_to_entity(attrs)
+      if attrs
+        entity_id = attrs.delete(:id)
+        attrs.reject! {|k,v| v.nil? }
+        entity_class.construct(attrs, entity_id)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/ormivore/version.rb

@@ -0,0 +1,3 @@
+module ORMivore
+  VERSION = "0.0.1"
+end

data/spec/adapters/account_storage_ar_adapter_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+require_relative 'shared_account'
+require_relative 'ar_helpers'
+
+describe App::AccountStorageArAdapter, :relational_db do
+  include ArHelpers
+
+  let(:entity_table) { 'accounts' }
+  let(:adapter) { App::AccountStorageArAdapter.new }
+
+  it_behaves_like 'an account adapter'
+end

data/spec/adapters/account_storage_memory_adapter_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+require_relative 'shared_account'
+require_relative 'memory_helpers'
+
+describe App::AccountStorageMemoryAdapter do
+  include MemoryHelpers
+
+  let(:adapter) { App::AccountStorageMemoryAdapter.new }
+
+  it_behaves_like 'an account adapter'
+end

data/spec/adapters/address_storage_ar_adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+require_relative 'shared_address'
+require_relative 'ar_helpers'
+
+describe App::AddressStorageArAdapter, :relational_db do
+  include ArHelpers
+
+  let(:account_adapter) { App::AccountStorageArAdapter.new }
+  let(:entity_table) { 'addresses' }
+  let(:adapter) { App::AddressStorageArAdapter.new }
+
+  it_behaves_like 'an address adapter'
+end

data/spec/adapters/address_storage_memory_adapter_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+require_relative 'shared_address'
+require_relative 'memory_helpers'
+
+describe App::AddressStorageMemoryAdapter do
+  include MemoryHelpers
+
+  let(:account_adapter) { App::AccountStorageMemoryAdapter.new }
+  let(:adapter) { App::AddressStorageMemoryAdapter.new }
+
+  it_behaves_like 'an address adapter'
+end

data/spec/adapters/ar_helpers.rb

@@ -0,0 +1,9 @@
+module ArHelpers
+  def execute_simple_string_query(query)
+    ActiveRecord::Base.connection.execute(query).first[0]
+  end
+
+  def load_test_value(id)
+    execute_simple_string_query( "select #{test_attr.to_s} from #{entity_table} where id = #{id}")
+  end
+end

data/spec/adapters/memory_helpers.rb

@@ -0,0 +1,5 @@
+module MemoryHelpers
+  def load_test_value(id)
+    adapter.storage.first { |o| o[:id] = id }[test_attr]
+  end
+end

data/spec/adapters/shared.rb

@@ -0,0 +1,146 @@
+shared_examples_for 'an adapter' do
+  let(:test_value) { 'Foo' }
+
+  let(:attrs_list) { [:id].concat(attrs.keys) }
+
+  subject { adapter } # only 1 instance of adapter, please
+
+  def create_entity(overrides = {})
+    FactoryGirl.create(
+      factory_name, factory_attrs.merge(adapter: subject, test_attr => test_value).merge(overrides)
+    ).attributes.symbolize_keys
+  end
+
+  it 'responds to find' do
+    subject.should respond_to(:find)
+  end
+
+  describe '#find' do
+    context 'when conditions are empty' do
+      it 'returns all available records' do
+        subject.find({}, attrs_list).should be_empty
+        create_entity
+        subject.find({}, attrs_list).should have(1).record
+        create_entity
+        subject.find({}, attrs_list).should have(2).records
+      end
+    end
+
+    context 'when conditions points to non-existing entity' do
+      it 'returns empty array' do
+        subject.find({id: 123456789}, attrs_list).should be_empty
+      end
+    end
+
+    context 'when conditions point to existing entity' do
+      it 'returns entity id' do
+        entity = create_entity
+        data = subject.find({id: entity[:id]}, attrs_list)
+        data.first[:id].should == entity[:id]
+      end
+
+      it 'returns proper entity attrs' do
+        entity = create_entity
+        data = subject.find({id: entity[:id]}, attrs_list)
+        data.should_not be_nil
+        data.first[test_attr].should == entity[test_attr]
+      end
+
+      it 'returns only required entity attrs' do
+        entity = create_entity
+        data = subject.find({id: entity[:id]}, [test_attr]).first
+        data.should == { test_attr => entity[test_attr] }
+      end
+    end
+
+    context 'when conditions point to multiple entities' do
+      before do
+        create_entity(test_attr => 'v1')
+        create_entity(test_attr => 'v2')
+      end
+
+      it 'returns array of attributes' do
+        subject.find({}, attrs_list).should have(2).records
+      end
+
+      context 'when ordering criteria is provided' do
+        it 'sorts records in ascending order' do
+          subject.find(
+            {}, attrs_list, order: { test_attr => :ascending }
+          ).map { |o| o[test_attr] }.should == ['v1', 'v2']
+        end
+
+        it 'sorts records in descending order' do
+          subject.find(
+            {}, attrs_list, order: { test_attr => :descending }
+          ).map { |o| o[test_attr] }.should == ['v2', 'v1']
+        end
+
+        it 'raises error if unknown ordering is provided' do
+          expect {
+            subject.find({}, attrs_list, order: { test_attr => :foo })
+          }.to raise_error ORMivore::BadArgumentError
+        end
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when attempting to create record with id that is already present in database' do
+      it 'raises error' do
+        expect {
+          subject.create(subject.create(attrs))
+        }.to raise_error ORMivore::StorageError
+      end
+    end
+
+    context 'when record does not have an id' do
+      it 'returns back attributes including new id' do
+        data = subject.create(attrs)
+        data.should include(attrs)
+        data[:id].should be_kind_of(Integer)
+      end
+
+      it 'inserts record in database' do
+        data = subject.create(attrs)
+
+        load_test_value(data[:id]).should == test_value
+      end
+    end
+  end
+
+  describe '#update' do
+    context 'when record did not exist' do
+      it 'returns 0 update count' do
+        create_entity
+        subject.update(attrs, id: 123).should == 0
+      end
+    end
+
+    context 'when record existed' do
+      it 'returns update count 1' do
+        entity = create_entity
+
+        subject.update(attrs, id: entity[:id]).should == 1
+      end
+
+      it 'updates record attributes' do
+        entity = create_entity
+
+        subject.update({test_attr => 'Bar'}, id: entity[:id])
+
+        load_test_value(entity[:id]).should == 'Bar'
+      end
+    end
+
+    context 'when 2 matching records existed' do
+      it 'returns update count 2' do
+        entity_ids = []
+        entity_ids << create_entity[:id]
+        entity_ids << create_entity[:id]
+
+        subject.update(attrs, id: entity_ids).should == 2
+      end
+    end
+  end
+end