active_mapper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6a0962e9a48619f43dcd83bd2c1c537d86d431d
+  data.tar.gz: ce7a305b11b716922e48dd4eee63ea31791c7c27
+SHA512:
+  metadata.gz: f7dd85906718afeb6de5c2422e2508ff8449b649a842552df2869fa3aaf3df6120f3b120c2958d68ad2bab818c452cde1bf7f137785ac11b1ca389825194aeee
+  data.tar.gz: bbfe65e3421d429cebad52d4fc04e59578619dfe856f18cd695a8819ec8d422fd0a478a18b46e72ed18c532b54a82c8802be20460f8e6a3af05817e3bef39c2b

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.ruby-gemset

@@ -0,0 +1 @@
+active_mapper

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_mapper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Artin Boghosian
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# ActiveMapper
+
+[![Code Climate](https://codeclimate.com/github/artinboghosian/active_mapper.png)](https://codeclimate.com/github/artinboghosian/active_mapper)
+
+ActiveMapper is a data-mapper using ActiveRecord/Arel as a backend. It allows you to create models using PORO and comes with a Memory adapter which you can use during testing to make your tests faster and not reliant on a database. The only requirements are that your models have an id attribute (auto-incrementing int) and respond to a valid? and .model_name ( ActiveSupport::Name). These can easily be injected into your models by including ActiveModel::Model.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_mapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_mapper
+
+## Usage
+
+    class Post
+        include ActiveModel::Model
+        
+        attr_accessor :id, :title, :content, :status, :created_at, :updated_at
+        
+        def persisted?
+            id
+        end
+    end
+    
+    post = Post.new(title: 'Post', content: 'My First Post')
+    
+    # ActiveMapper[Class] will automatically create and wire up the mapper
+    # if it does not exist. The only requirement is that the table exists
+    # with the proper columns (e.g. use ActiveRecord migrations).
+    ActiveMapper[Post].save(post)
+    
+    record = ActiveMapper[Post].find(post.id)
+### Querying
+    mapper = ActiveMapper[Post]
+    
+    # some methods return an ActiveMapper::Relation which will not execute
+    # any queries until #to_a, #each or #map are called.
+    
+    mapper.select { |post| post.title.starts_with('Post') }
+    mapper.reject { |post| post.status == 'draft' }
+    
+    # some methods actually execute the query immediately
+    
+    mapper.first { |post| !(post.status == 'draft') }
+    mapper.last { |post| (post.status == 'published') & (post.created_at > 5.days.ago) }
+    mapper.all { |post| (post.content.contains('monkey')) & (post.status == 'published) }
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/active_mapper/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/active_mapper.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_mapper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_mapper"
+  spec.version       = ActiveMapper::VERSION
+  spec.authors       = ["Artin Boghosian"]
+  spec.email         = ["artinboghosian@gmail.com"]
+  spec.summary       = %q{Data mapper using ActiveRecord for data access}
+  spec.description   = %q{Data mapper using ActiveRecord for data access}
+  spec.homepage      = "https://github.com/artinboghosian/active_mapper"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activerecord"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/active_mapper/adapter/active_record/order/attribute.rb

@@ -0,0 +1,34 @@
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      class Order
+        class Attribute
+          def initialize(name)
+            @name = name
+            @direction = :asc
+          end
+
+          def -@
+            @direction = :desc
+            self
+          end
+
+          def reverse
+            @direction = asc? ? :desc : :asc
+            self
+          end
+
+          def to_sql
+            { @name => @direction }
+          end
+
+          private
+
+          def asc?
+            @direction == :asc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/active_record/order.rb

@@ -0,0 +1,30 @@
+require 'active_mapper/adapter/active_record/order/attribute'
+
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      class Order
+        def initialize(&block)
+          @block = block
+        end
+
+        def to_sql
+          [attributes].flatten.inject({}) do |memo, attribute|
+            memo = memo.merge(attribute.to_sql)
+            memo
+          end
+        end
+
+        def method_missing(name, *args, &block)
+          Attribute.new(name)
+        end
+
+        private
+
+        def attributes
+          @block ? @block.call(self) : []
+        end
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/active_record/query/attribute.rb

@@ -0,0 +1,63 @@
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      class Query
+        class Attribute
+          def initialize(attribute)
+            @attribute = attribute
+          end
+
+          def in(*collection)
+            Expression.new(@attribute, :in, collection)
+          end
+
+          def not_in(*collection)
+            Expression.new(@attribute, :not_in, collection)
+          end
+
+          def starts_with(value)
+            matches("#{value}%")
+          end
+
+          def contains(value)
+            matches("%#{value}%")
+          end
+
+          def ends_with(value)
+            matches("%#{value}")
+          end
+
+          def ==(value)
+            Expression.new(@attribute, :eq, value)
+          end
+
+          def !=(value)
+            Expression.new(@attribute, :not_eq, value)
+          end
+
+          def >(value)
+            Expression.new(@attribute, :gt, value)
+          end
+
+          def >=(value)
+            Expression.new(@attribute, :gteq, value)
+          end
+
+          def <(value)
+            Expression.new(@attribute, :lt, value)
+          end
+
+          def <=(value)
+            Expression.new(@attribute, :lteq, value)
+          end
+
+          private
+
+          def matches(value)
+            Expression.new(@attribute, :matches, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/active_record/query/expression.rb

@@ -0,0 +1,63 @@
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      class Query
+        class Expression
+          def initialize(attribute, comparator, value)
+            @attribute = attribute
+            @comparator = comparator
+            @value = value
+          end
+
+          def to_sql
+            @attribute.send(@comparator, @value)
+          end
+
+          def !
+            NotExpression.new(self)
+          end
+
+          def &(expression)
+            AndExpression.new(self, expression)
+          end
+
+          def |(expression)
+            OrExpression.new(self, expression)
+          end
+        end
+
+        class NotExpression < Expression
+          def initialize(expression)
+            @expression = expression
+          end
+
+          def to_sql
+            @expression.to_sql.not
+          end
+        end
+
+        class AndExpression < Expression
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+
+          def to_sql
+            @left.to_sql.and(@right.to_sql)
+          end
+        end
+
+        class OrExpression < Expression
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+
+          def to_sql
+            @left.to_sql.or(@right.to_sql)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'active_mapper/adapter/active_record/query/attribute'
+require 'active_mapper/adapter/active_record/query/expression'
+
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      class Query
+        def initialize(table, &block)
+          @table = table
+          @block = block
+        end
+
+        def to_sql
+          @block ? @block.call(self).to_sql : {}
+        end
+
+        def method_missing(name, *args, &block)
+          Attribute.new(@table[name])
+        end
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/active_record.rb

@@ -0,0 +1,96 @@
+require 'active_record'
+require 'active_mapper/adapter/active_record/query'
+require 'active_mapper/adapter/active_record/order'
+
+module ActiveMapper
+  module Adapter
+    class ActiveRecord
+      def initialize
+        @collection = {}
+      end
+
+      def find(klass, id)
+        collection(klass).find_by(id: id)
+      end
+
+      def where(klass, options = {}, &block)
+        active_record = collection(klass)
+        query = Query.new(active_record.arel_table, &block)
+        order = Order.new(&options[:order])
+
+        records = active_record.where(query.to_sql)
+        records = records.limit(options[:limit]) if options[:limit]
+        records = records.offset(options[:offset]) if options[:offset]
+        records = records.order(order.to_sql)
+
+        records
+      end
+
+      def count(klass, &block)
+        where(klass, &block).count
+      end
+
+      def minimum(klass, attribute, &block)
+        calculate(:minimum, klass, attribute, &block)
+      end
+
+      def maximum(klass, attribute, &block)
+        calculate(:maximum, klass, attribute, &block)
+      end
+
+      def average(klass, attribute, &block)
+        calculate(:average, klass, attribute, &block)
+      end
+
+      def sum(klass, attribute, &block)
+        calculate(:sum, klass, attribute, &block)
+      end
+
+      def insert(klass, object)
+        active_record = collection(klass)
+        attributes = serialize(klass, object)
+
+        record = active_record.new(attributes)
+        record.save
+        record.id
+      end
+
+      def update(klass, object)
+        find(klass, object.id).update_columns(serialize(klass, object))
+      end
+
+      def serialize(klass, object)
+        collection(klass).column_names.dup.inject({}) do |memo, attribute|
+          memo[attribute] = object.send(attribute)
+          memo
+        end
+      end
+
+      def unserialize(klass, object)
+        klass.new(serialize(klass, object))
+      end
+
+      def delete(klass, object)
+        find(klass, object.id).delete
+      end
+
+      def delete_all(klass, &block)
+        where(klass, &block).delete_all
+      end
+
+      private
+
+      def collection(klass)
+        @collection[klass] ||= begin
+          active_record = Class.new(::ActiveRecord::Base)
+          active_record.table_name = klass.model_name.plural
+          active_record
+        end
+      end
+
+      def calculate(operation, klass, attribute, &block)
+        where(klass, &block).send(operation, attribute)
+      end
+    end
+  end
+end

data/lib/active_mapper/adapter/memory/order/attribute.rb

@@ -0,0 +1,40 @@
+module ActiveMapper
+  module Adapter
+    class Memory
+      class Order
+        class Attribute
+          def initialize(name)
+            @name = name
+            @direction = :asc
+          end
+
+          def -@
+            @direction = :desc
+            self
+          end
+
+          def reverse
+            @direction = asc? ? :desc : :asc
+            self
+          end
+
+          def to_proc
+            proc do |x,y|
+              if asc?
+                x.send(@name) <=> y.send(@name)
+              else
+                y.send(@name) <=> x.send(@name)
+              end
+            end
+          end
+
+          private
+
+          def asc?
+            @direction == :asc
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'active_mapper/adapter/memory/order/attribute'
+
+module ActiveMapper
+  module Adapter
+    class Memory
+      class Order
+        def initialize(&block)
+          @block = block
+        end
+
+        def to_proc
+          proc do |x,y|
+            [attributes].flatten.sum do |attribute|
+              attribute.to_proc.call(x,y)
+            end
+          end
+        end
+
+        def method_missing(name, *args, &block)
+          Attribute.new(name)
+        end
+
+        private
+
+        def attributes
+          @block ? @block.call(self) : [id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module ActiveMapper
+  module Adapter
+    class Memory
+      class Attribute
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def in(*collection)
+          InvertedExpression.new(collection, :include?, @attribute)
+        end
+
+        def not_in(*collection)
+          !(self.in(*collection))
+        end
+
+        def starts_with(value)
+          matches(/^#{value}/i)
+        end
+
+        def contains(value)
+          matches(/#{value}/i)
+        end
+
+        def ends_with(value)
+          matches(/#{value}$/i)
+        end
+
+        def ==(value)
+          Expression.new(@attribute, :==, value)
+        end
+
+        def !=(value)
+          Expression.new(@attribute, :!=, value)
+        end
+
+        def >(value)
+          Expression.new(@attribute, :>, value)
+        end
+
+        def >=(value)
+          Expression.new(@attribute, :>=, value)
+        end
+
+        def <(value)
+          Expression.new(@attribute, :<, value)
+        end
+
+        def <=(value)
+          Expression.new(@attribute, :<=, value)
+        end
+
+        private
+
+        def matches(regexp)
+          Expression.new(@attribute, :match, regexp)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module ActiveMapper
+  module Adapter
+    class Memory
+      class Expression
+        def initialize(attribute, comparator, value)
+          @attribute = attribute
+          @comparator = comparator
+          @value = value
+        end
+
+        def to_proc
+          proc do |object|
+            object.send(@attribute).send(@comparator, @value)
+          end
+        end
+
+        def !
+          NotExpression.new(self)
+        end
+
+        def &(expression)
+          AndExpression.new(self, expression)
+        end
+
+        def |(expression)
+          OrExpression.new(self, expression)
+        end
+      end
+
+      class InvertedExpression < Expression
+        def initialize(value, comparator, attribute)
+          super(attribute, comparator, value)
+        end
+
+        def to_proc
+          proc do |object|
+            @value.send(@comparator, object.send(@attribute))
+          end
+        end
+      end
+
+      class NotExpression < Expression
+        def initialize(expression)
+          @expression = expression
+        end
+
+        def to_proc
+          proc do |object|
+            !@expression.to_proc.call(object)
+          end
+        end
+      end
+
+      class AndExpression < Expression
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        def to_proc
+          proc do |object|
+            @left.to_proc.call(object) && @right.to_proc.call(object)
+          end
+        end
+      end
+
+      class OrExpression < Expression
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        def to_proc
+          proc do |object|
+            @left.to_proc.call(object) || @right.to_proc.call(object)
+          end
+        end
+      end
+    end
+  end
+end