active_mapper 0.0.1

data/lib/active_mapper/adapter/memory/query.rb

@@ -0,0 +1,22 @@
+require 'active_mapper/adapter/memory/query/attribute'
+require 'active_mapper/adapter/memory/query/expression'
+
+module ActiveMapper
+  module Adapter
+    class Memory
+      class Query
+        def initialize(&block)
+          @block = block
+        end
+
+        def to_proc
+          @block ? @block.call(self).to_proc : proc { true }
+        end
+
+        def method_missing(name, *args, &block)
+          Attribute.new(name)
+        end
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/memory.rb

@@ -0,0 +1,80 @@
+require 'active_mapper/adapter/memory/query'
+require 'active_mapper/adapter/memory/order'
+
+module ActiveMapper
+  module Adapter
+    class Memory
+      def initialize
+        @collection = {}
+      end
+
+      def find(klass, id)
+        collection(klass)[id]
+      end
+
+      def where(klass, options = {}, &block)
+        query = Query.new(&block)
+        order = Order.new(&options[:order])
+
+        records = collection(klass).values.select(&query.to_proc)
+        records = records.sort(&order.to_proc)
+        records = records.drop(options[:offset]) if options[:offset]
+        records = records.take(options[:limit]) if options[:limit]
+
+        records
+      end
+
+      def count(klass, &block)
+        where(klass, &block).count
+      end
+
+      def minimum(klass, attribute, &block)
+        where(klass, order: proc { |object| [object.send(attribute)] }, &block).first.send(attribute)
+      end
+
+      def maximum(klass, attribute, &block)
+        where(klass, order: proc { |object| [-object.send(attribute)] }, &block).first.send(attribute)
+      end
+
+      def average(klass, attribute, &block)
+        sum(klass, attribute, &block).to_f / count(klass, &block)
+      end
+
+      def sum(klass, attribute, &block)
+        where(klass, &block).sum(&:"#{attribute}")
+      end
+
+      def insert(klass, object)
+        object = object.dup
+        object.id = (collection(klass).keys.last || 0) + 1
+
+        collection(klass)[object.id] = object
+        object.id
+      end
+
+      def update(klass, object)
+        collection(klass)[object.id] = object.dup
+      end
+
+      def delete(klass, object)
+        collection(klass).delete(object.id)
+      end
+
+      def delete_all(klass, &block)
+        where(klass, &block).each do |object|
+          delete(klass, object)
+        end
+      end
+      
+      def unserialize(klass, object)
+        object
+      end
+
+      private
+
+      def collection(klass)
+        @collection[klass] ||= {}
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter.rb

@@ -0,0 +1,7 @@
+require 'active_mapper/adapter/memory'
+require 'active_mapper/adapter/active_record'
+
+module ActiveMapper
+  module Adapter
+  end
+end

data/lib/active_mapper/mapper.rb

@@ -0,0 +1,107 @@
+module ActiveMapper
+  class Mapper
+    attr_reader :mapped_class, :adapter
+
+    def initialize(mapped_class, adapter)
+      @mapped_class = mapped_class
+      @adapter = adapter
+    end
+
+    def all?(&block)
+      count == count(&block)
+    end
+
+    def any?(&block)
+      select(&block).any?
+    end
+
+    def none?(&block)
+      select(&block).none?
+    end
+
+    def one?(&block)
+      select(&block).one?
+    end
+
+    def count(&block)
+      select(&block).count
+    end
+
+    def min(attribute)
+      find_all.min(attribute)
+    end
+    alias :min_by :min
+    alias :minimum :min
+
+    def max(attribute)
+      find_all.max(attribute)
+    end
+    alias :max_by :max
+    alias :maximum :max
+
+    def minmax(attribute)
+      find_all.minmax(attribute)
+    end
+    alias :minmax_by :minmax
+
+    def avg(attribute)
+      find_all.avg(attribute)
+    end
+    alias :average :avg
+
+    def sum(attribute)
+      find_all.sum(attribute)
+    end
+
+    def find(id = nil, &block)
+      id ? first { |object| object.id == id } : first(&block)
+    end
+
+    def first(&block)
+      select(&block).first
+    end
+    alias :detect :first
+
+    def last(&block)
+      select(&block).last
+    end
+
+    def select(&block)
+      Relation.new(mapped_class, adapter, &block)
+    end
+    alias :find_all :select
+
+    def reject(&block)
+      select { |object| !block.call(object) }
+    end
+
+    def save(object)
+      return false unless object.valid?
+
+      if object.id
+        adapter.update(mapped_class, object)
+      else
+        object.id = adapter.insert(mapped_class, object)
+      end
+
+      object
+    end
+
+    def delete(object)
+      adapter.delete(mapped_class, object)
+    end
+
+    def delete_if(&block)
+      adapter.delete_all(mapped_class, &block)
+    end
+
+    def keep_if(&block)
+      delete_if { |object| !block.call(object) }
+    end
+
+    def clear
+      adapter.delete_all(mapped_class)
+    end
+    alias :delete_all :clear
+  end
+end

data/lib/active_mapper/relation.rb

@@ -0,0 +1,133 @@
+require 'delegate'
+
+module ActiveMapper
+  class Relation
+    extend Forwardable
+
+    def_delegators :to_a, :each, :map
+
+    def initialize(mapped_class, adapter, &block)
+      @mapped_class = mapped_class
+      @adapter = adapter
+      @block = block
+    end
+
+    def initialize_copy(other)
+      super
+      @to_a = nil
+    end
+
+    def any?
+      count > 0
+    end
+
+    def none?
+      !any?
+    end
+    alias :empty? :none?
+
+    def one?
+      count == 1
+    end
+
+    def count
+      @count ||= @adapter.count(@mapped_class, &@block)
+    end
+    alias :length :count
+    alias :size :count
+
+    def min(attribute)
+      @min ||= @adapter.minimum(@mapped_class, attribute, &@block)
+    end
+    alias :minimum :min
+
+    def max(attribute)
+      @max ||= @adapter.maximum(@mapped_class, attribute, &@block)
+    end
+    alias :maximum :max
+
+    def minmax(attribute)
+      [min(attribute), max(attribute)]
+    end
+
+    def avg(attribute)
+      @avg ||= @adapter.average(@mapped_class, attribute, &@block)
+    end
+    alias :average :avg
+
+    def sum(attribute)
+      @sum ||= @adapter.sum(@mapped_class, attribute, &@block)
+    end
+
+    def drop(number)
+      @offset = number
+      dup
+    end
+
+    def take(number)
+      @limit = number
+      dup
+    end
+
+    def select(&block)
+      if @block
+        query = @block.dup
+        
+        @block = proc { |object| (query.call(object)) & block.call(object) }
+      else
+        @block = block
+      end
+
+      dup
+    end
+
+    def reject(&block)
+      select { |object| !block.call(object) }
+    end
+
+    def first(number = 1)
+      objects = drop(0).take(number).to_a
+
+      if number == 1
+        objects.first
+      else
+        objects
+      end
+    end
+
+    def last(number = 1)
+      objects = drop(0).take(number).reverse.to_a
+
+      if number == 1
+        objects.first
+      else
+        objects
+      end
+    end
+
+    def sort_by(&block)
+      @order = block
+      dup
+    end
+
+    def reverse
+      if @order
+        block = @order.dup
+
+        sort_by { |object| [block.call(object)].flatten.map(&:reverse) }
+      else
+        sort_by { |object| -object.id }
+      end
+    end
+
+    def to_a
+      @to_a ||= @adapter.where(@mapped_class, options, &@block).map { |record| @adapter.unserialize(@mapped_class, record) }
+    end
+
+    private
+
+    def options
+      { offset: @offset, limit: @limit, order: @order }
+    end
+  end
+end

data/lib/active_mapper/version.rb

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

data/lib/active_mapper.rb

@@ -0,0 +1,24 @@
+require 'active_mapper/mapper'
+require 'active_mapper/relation'
+require 'active_mapper/adapter'
+require 'active_mapper/version'
+
+module ActiveMapper
+  def self.[](klass)
+    mappers[klass] ||= Class.new(ActiveMapper::Mapper).new(klass, adapter)
+  end
+
+  def self.adapter
+    @adapter ||= ActiveMapper::Adapter::Memory.new
+  end
+
+  def self.adapter=(adapter)
+    @adapter = adapter
+  end
+
+  private
+
+  def self.mappers
+    @mappers ||= {}
+  end
+end

data/spec/active_mapper/adapter/active_record/order_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ActiveMapper::Adapter::ActiveRecord::Order do
+  let(:order) { described_class.new { |object| [object.name, -object.age] } }
+
+  describe '#to_sql' do
+    it 'converts attributes to hash' do
+      expect(order.to_sql).to eq({ name: :asc, age: :desc })
+    end
+  end
+end

data/spec/active_mapper/adapter/active_record_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe ActiveMapper::Adapter::ActiveRecord do
+  let(:user) { User.new(name: 'user', age: 28) }
+  let(:other_user) { User.new(name: 'other', age: 35) }
+  let(:adapter) { ActiveMapper::Adapter::ActiveRecord.new }
+
+  setup_active_record('active_record')
+
+  before do
+    user.id = adapter.insert(User, user)
+    other_user.id = adapter.insert(User, other_user)
+  end
+
+  after { adapter.delete_all(User) }
+
+  describe '#find' do
+    it 'finds the record with the matching id' do
+      record = adapter.find(User, user.id)
+
+      expect(record.id).to eq(user.id)
+    end
+  end
+
+  describe '#where' do
+    it 'finds the matching records' do
+      ids = adapter.where(User) { |u| u.age < 35 }.load.map(&:id)
+
+      expect(ids).to include(user.id)
+      expect(ids).to_not include(other_user.id)
+    end
+
+    it 'finds and sorts the matching records in ascending order' do
+      records = adapter.where(User, order: proc { |object| [object.name] })
+
+      expect(records.first.id).to eq(other_user.id)
+      expect(records.last.id).to eq(user.id)
+    end
+
+    it 'finds and sorts the matching records in descending order' do
+      records = adapter.where(User, order: proc { |object| [-object.age] })
+
+      expect(records.first.id).to eq(other_user.id)
+      expect(records.last.id).to eq(user.id)
+    end
+
+    it 'limits the number of matching records' do
+      records = adapter.where(User, limit: 1)
+
+      expect(records.count).to eq(1)
+    end
+
+    it 'offsets the matching records' do
+      ids = adapter.where(User, offset: 1).load.map(&:id)
+
+      expect(ids).to include(other_user.id)
+      expect(ids).to_not include(user.id)
+    end
+  end
+
+  describe '#count' do
+    it 'counts the number of total records' do
+      expect(adapter.count(User)).to eq(2)
+    end
+
+    it 'counts the number of matching records' do
+      expect(adapter.count(User) { |u| u.age < 35 }).to eq(1)
+    end
+  end
+
+  describe '#minimum' do
+    it 'calculates the minimum value' do
+      expect(adapter.minimum(User, :age)).to eq(28)
+    end
+
+    it 'calculates the minimum value of a subset of records' do
+      expect(adapter.minimum(User, :age) { |user| user.age > 30 }).to eq(35)
+    end
+  end
+
+  describe '#maximum' do
+    it 'calculates the maximum value' do
+      expect(adapter.maximum(User, :age)).to eq(35)
+    end
+
+    it 'calculates the maximum value of a subset of records' do
+      expect(adapter.maximum(User, :age) { |user| user.age < 30 }).to eq(28)
+    end
+  end
+
+  describe '#average' do
+    it 'calculates the average value' do
+      expect(adapter.average(User, :age)).to eq(31.5)
+    end
+
+    it 'calculates the avarage value of a subset of records' do
+      expect(adapter.average(User, :age) { |user| user.age < 35 }).to eq(28)
+    end
+  end
+
+  describe '#sum' do
+    it 'calculates the total value' do
+      expect(adapter.sum(User, :age)).to eq(63)
+    end
+
+    it 'calculates the total value of a subset of records' do
+      expect(adapter.sum(User, :age) { |user| user.age < 35 }).to eq(28)
+    end
+  end
+
+  describe '#insert' do
+    it 'inserts the record into the database' do
+      user = User.new(name: 'test', age: 18)
+      id = adapter.insert(User, user)
+      record = adapter.find(User, id)
+
+      expect(record.id).to eq(id)
+    end
+  end
+
+  describe '#update' do
+    it 'updates the record in the database' do
+      user.name = 'Changed'
+      user.age = 18
+      adapter.update(User, user)
+      record = adapter.find(User, user.id)
+
+      expect(record.name).to eq('Changed')
+      expect(record.age).to eq(18)
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes the record from the database' do
+      adapter.delete(User, user)
+
+      expect(adapter.find(User, user.id)).to be_nil
+    end
+  end
+
+  describe '#delete_all' do
+    it 'deletes all the records' do
+      adapter.delete_all(User)
+
+      expect(adapter.count(User)).to eq(0)
+    end
+
+    it 'deletes the matching records' do
+      adapter.delete_all(User) { |u| u.name == 'user' }
+
+      expect(adapter.find(User, user.id)).to be_nil
+      expect(adapter.find(User, other_user.id)).to_not be_nil
+    end
+  end
+
+  describe '#unserialize' do
+    it 'unserializes the object' do
+      record = adapter.find(User, user.id)
+      unserialized = adapter.unserialize(User, record)
+
+      expect(unserialized).to eq(user)
+    end
+  end
+end

data/spec/active_mapper/adapter/memory_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe ActiveMapper::Adapter::Memory do
+  let(:user) { User.new(name: 'user', age: 28) }
+  let(:other_user) { User.new(name: 'other', age: 35) }
+  let(:adapter) { ActiveMapper::Adapter::Memory.new }
+
+  before do
+    user.id = adapter.insert(User, user)
+    other_user.id = adapter.insert(User, other_user)
+  end
+
+  describe '#find' do
+    it 'finds the record with the matching id' do
+      expect(adapter.find(User, user.id)).to eq(user)
+    end
+  end
+
+  describe '#where' do
+    it 'finds the matching records' do
+      records = adapter.where(User) { |u| u.age < 35 }
+
+      expect(records).to include(user)
+      expect(records).to_not include(other_user)
+    end
+
+    it 'finds and sorts the matching records in ascending order' do
+      records = adapter.where(User, order: proc { |object| [object.name] })
+
+      expect(records.first).to eq(other_user)
+      expect(records.last).to eq(user)
+    end
+
+    it 'finds and sorts the matching records in descending order' do
+      records = adapter.where(User, order: proc { |object| [-object.age] })
+
+      expect(records.first).to eq(other_user)
+      expect(records.last).to eq(user)
+    end
+
+    it 'limits the number of matching records' do
+      records = adapter.where(User, limit: 1)
+
+      expect(records.count).to eq(1)
+    end
+
+    it 'offsets the matching records' do
+      records = adapter.where(User, offset: 1)
+
+      expect(records).to include(other_user)
+      expect(records).to_not include(user)
+    end
+  end
+
+  describe '#count' do
+    it 'counts the number of total records' do
+      expect(adapter.count(User)).to eq(2)
+    end
+
+    it 'counts the number of matching records' do
+      expect(adapter.count(User) { |u| u.age < 35 }).to eq(1)
+    end
+  end
+
+  describe '#minimum' do
+    it 'calculates the minimum value' do
+      expect(adapter.minimum(User, :age)).to eq(28)
+    end
+
+    it 'calculates the minimum value of a subset of records' do
+      expect(adapter.minimum(User, :age) { |user| user.age > 30 }).to eq(35)
+    end
+  end
+
+  describe '#maximum' do
+    it 'calculates the maximum value' do
+      expect(adapter.maximum(User, :age)).to eq(35)
+    end
+
+    it 'calculates the maximum value of a subset of records' do
+      expect(adapter.maximum(User, :age) { |user| user.age < 30 }).to eq(28)
+    end
+  end
+
+  describe '#average' do
+    it 'calculates the average value' do
+      expect(adapter.average(User, :age)).to eq(31.5)
+    end
+
+    it 'calculates the average value of a subset of records' do
+      expect(adapter.average(User, :age) { |user| user.age < 35 }).to eq(28)
+    end
+  end
+
+  describe '#sum' do
+    it 'calculates the total value' do
+      expect(adapter.sum(User, :age)).to eq(63)
+    end
+
+    it 'calculates the total value of a subset of records' do
+      expect(adapter.sum(User, :age) { |user| user.age < 35 }).to eq(28)
+    end
+  end
+
+  describe '#insert' do
+    it 'inserts the record into the collection' do
+      user = User.new(name: 'test', age: 18)
+      id = adapter.insert(User, user)
+      record = adapter.find(User, id)
+
+      expect(record.id).to eq(id)
+    end
+  end
+
+  describe '#update' do
+    it 'updates the record in the collection' do
+      user.name = 'Changed'
+      user.age = 18
+      adapter.update(User, user)
+      record = adapter.find(User, user.id)
+
+      expect(record.name).to eq('Changed')
+      expect(record.age).to eq(18)
+    end
+  end
+
+  describe '#delete' do
+    it 'deletes the record from the collection' do
+      adapter.delete(User, user)
+
+      expect(adapter.find(User, user.id)).to be_nil
+    end
+  end
+
+  describe '#delete_all' do
+    it 'deletes all the records' do
+      adapter.delete_all(User)
+
+      expect(adapter.count(User)).to eq(0)
+    end
+
+    it 'deletes the matching records' do
+      adapter.delete_all(User) { |u| u.name == 'user' }
+
+      expect(adapter.find(User, user.id)).to be_nil
+      expect(adapter.find(User, other_user.id)).to eq(other_user)
+    end
+  end
+
+  describe '#unserialize' do
+    it 'unserializes the object' do
+      record = adapter.find(User, user.id)
+      unserialized = adapter.unserialize(User, record)
+
+      expect(unserialized).to eq(user)
+    end
+  end
+end