active_repository 0.2.7 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 605ad373409e52ed436bd85e89904760fe97e049
+  data.tar.gz: 39716333dfbdaa9d447bb8be5f384148d8815b4d
+SHA512:
+  metadata.gz: 2841548917d159c2ac40c46fc2aaea7d724cd3479a4842b6e71ce53b7ed076e3781539a5a2e54391b83cc9bae310267450ac179b9340057a767de655944e7b14
+  data.tar.gz: cd3890fb5aa63a1cbcd90c533121710eb2b68a9839b92dcbdd0b4db0d267d7c0dce11e2e6eb625b6193faf50e64c03bb6213deac7c924fff2175cd4d8cac9381

data/active_repository.gemspec

@@ -24,16 +24,18 @@ Gem::Specification.new do |gem|
     "Gemfile",
     "spec/active_repository/base_spec.rb",
     "spec/active_repository/associations_spec.rb",
+    "spec/active_repository/result_set_spec.rb",
     "spec/support/shared_examples.rb",
     "spec/spec_helper.rb"
   ]
 
-  gem.add_runtime_dependency(%q<active_hash>, [">= 0.9.12"])
-  gem.add_runtime_dependency(%q<activemodel>, [">= 3.2.6"])
-  gem.add_runtime_dependency(%q<sql_query_executor>, [">= 0.0.1"])
+  gem.add_runtime_dependency(%q<active_hash>, [">= 1.2.3"])
+  gem.add_runtime_dependency(%q<activemodel>, [">= 3.2"])
+  gem.add_runtime_dependency(%q<sql_query_executor>, [">= 0.3.1"])
+  gem.add_development_dependency(%q<pry>)
   gem.add_development_dependency(%q<rspec>, [">= 2.2.0"])
-  gem.add_development_dependency(%q<activerecord>, [">= 3.2.6"])
-  gem.add_development_dependency(%q<mongoid>, [">= 3.0.11"])
+  gem.add_development_dependency(%q<activerecord>, [">= 3.2"])
+  gem.add_development_dependency(%q<mongoid>, [">= 3.1"])
   gem.add_development_dependency('rake', [">= 10.0.0"])
   gem.add_development_dependency('coveralls')
   gem.add_development_dependency(%q<sqlite3>) unless RUBY_PLATFORM == 'java'

data/lib/active_repository/adapters/default_adapter.rb

@@ -5,7 +5,7 @@ class DefaultAdapter
     end
 
     def delete(klass, id)
-      object = klass.get_model_class.find_by_id(id)
+      object = klass.get_model_class.where(id: id).first
       object.delete if object
     end
 
@@ -18,6 +18,8 @@ class DefaultAdapter
     end
 
     def find(klass, id)
+      id = normalize_id(id) if id
+
       klass.get_model_class.find(id)
     end
 
@@ -49,9 +51,21 @@ class DefaultAdapter
       [ret, object]
     end
 
-    def where(klass, args)
-      # raise args.inspect
-      klass.get_model_class.where(args)
+    def where(klass, query)
+      klass.get_model_class.where(query.to_sql)
+    end
+
+  private
+    def normalize_id(args)
+      return args if args.is_a?(Array)
+      
+      id = (args.is_a?(Hash) ? args[:id] : args)
+
+      convertable?(id) ? id.to_i : id
+    end
+
+    def convertable?(id)
+      id.respond_to?(:to_i) && id.to_s == id.to_i.to_s
     end
   end
 end

data/lib/active_repository/adapters/mongoid_adapter.rb

@@ -46,8 +46,8 @@ class MongoidAdapter < DefaultAdapter
   #     [ret, object]
   #   end
 
-  #   def where(klass, args)
-  #     klass.where(args)
-  #   end
+    def where(klass, query)
+      klass.get_model_class.where(query.selector)
+    end
   end
 end

data/lib/active_repository/adapters/persistence_adapter.rb

@@ -1,4 +1,3 @@
-require 'active_repository/adapters/active_hash_adapter'
 require 'active_repository/adapters/default_adapter'
 require 'active_repository/adapters/mongoid_adapter'
 
@@ -8,10 +7,6 @@ class PersistenceAdapter
       modules = klass.get_model_class.included_modules.map(&:to_s)
       if modules.include?("Mongoid::Document")
         MongoidAdapter
-      elsif modules.map(&:to_s).include?("DataMapper::Resource")
-        DataMapperAdapter
-      # elsif modules.map(&:to_s).include?("MongoMapper::Document")
-      #   MongoMapperAdapter
       else
         DefaultAdapter
       end

data/lib/active_repository/associations.rb

@@ -1,42 +1,14 @@
-# Defines the relations between ActiveRepository objects and/or ActiveRecord Models.
+# Defines the relations between ActiveRepository objects.
 #
 # Author::    Caio Torres  (mailto:efreesen@gmail.com)
 # License::   GPL
 
 module ActiveRepository
   module Associations
-    #:nodoc:
-    module ActiveRecordExtensions
-      # Defines belongs to type relation between ActiveRepository objects and ActivRecord Models.
-      def belongs_to_active_repository(association_id, options = {})
-        options = {
-          class_name:  association_id.to_s.classify,
-          foreign_key: association_id.to_s.foreign_key
-        }.merge(options)
-
-        define_method(association_id) do
-          options[:class_name].constantize.find_by_id(send(options[:foreign_key]))
-        end
-
-        define_method("#{association_id}=") do |new_value|
-          send "#{options[:foreign_key]}=", new_value ? new_value.id : nil
-        end
-
-        create_reflection(
-            :belongs_to,
-            association_id.to_sym,
-            options,
-            options[:class_name].constantize
-          )
-      end
-    end
-
-    #:nodoc:
     def self.included(base)
       base.extend Methods
     end
 
-    #:nodoc:
     module Methods
       # Defines "has many" type relation between ActiveRepository objects
       def has_many(association_id, options = {})
@@ -49,11 +21,7 @@ module ActiveRepository
           klass = options[:class_name].constantize
           objects = []
 
-          if klass.respond_to?(:scoped)
-            objects = klass.scoped(:conditions => {options[:foreign_key] => id})
-          else
-            objects = klass.send("find_all_by_#{options[:foreign_key]}", id)
-          end
+          klass.where(options[:foreign_key] => id)
         end
       end
 
@@ -67,11 +35,11 @@ module ActiveRepository
 
           scope = options[:class_name].constantize
 
-          if scope.respond_to?(:scoped) && options[:conditions]
-            scope = scope.scoped(:conditions => options[:conditions])
-          end
-          
-          scope.send("find_by_#{options[:foreign_key]}", id)
+          scope = scope.where(options[:conditions]) if options[:conditions]
+
+          send_params = scope.respond_to?(:find_by) ? ["find_by", id: id] : ["find_by_id", id]
+
+          scope.send(*send_params)
         end
       end
 
@@ -89,7 +57,7 @@ module ActiveRepository
           id    = send(options[:foreign_key])
 
           if id.present?
-            object = klass.find_by_id(id)
+            object = klass.respond_to?(:find_by) ? klass.find_by(id: id) : klass.find_by_id(id)
           else
             nil
           end

data/lib/active_repository/base.rb

@@ -5,6 +5,7 @@ require 'sql_query_executor'
 require 'active_repository/finders'
 require 'active_repository/writers'
 require 'active_repository/adapters/persistence_adapter'
+require 'active_repository/result_set'
 
 begin
   klass = Module.const_get(Mongoid::Document)
@@ -84,7 +85,7 @@ module ActiveRepository
 
     # Checks the existence of a persisted object with the specified id
     def self.exists?(id)
-      repository? ? find_by_id(id).present? : PersistenceAdapter.exists?(self, id)
+      repository? ? find_by(id: id).present? : PersistenceAdapter.exists?(self, id)
     end
 
     # Returns the Class responsible for persisting the objects
@@ -93,12 +94,29 @@ module ActiveRepository
       save_in_memory? ? self : self.model_class
     end
 
+    # Searches all objects that matches #field_name field with the #args value(s)
+    def self.find_by(args)
+      raise ArgumentError("Argument must be a Hash") unless args.is_a?(Hash)
+
+      objects = where(args)
+
+      objects.first
+    end
+
+    # Searches all objects that matches #field_name field with the #args value(s)
+    def self.find_by!(args)
+      object = find_by(args)
+
+      raise ActiveHash::RecordNotFound unless object
+      object
+    end
+
     # Converts Persisted object(s) to it's ActiveRepository counterpart
     def self.serialize!(other)
       case other.class.to_s
       when "Hash", "ActiveSupport::HashWithIndifferentAccess" then self.new.serialize!(other)
       when "Array"                                            then other.map { |o| serialize!(o.attributes) }
-      when "Moped::BSON::Document"                            then self.new.serialize!(other)
+      when "Moped::BSON::Document", "BSON::Document"          then self.new.serialize!(other)
       else self.new.serialize!(other.attributes)
       end
     end
@@ -113,11 +131,6 @@ module ActiveRepository
       self.model_class = value if model_class.nil?
 
       self.set_save_in_memory(repository?)
-
-      field_names.each do |field_name|
-        define_custom_find_by_field(field_name)
-        define_custom_find_all_by_field(field_name)
-      end
     end
 
     # Sets the class attribute save_in_memory, set it to true to ignore model_class attribute
@@ -134,19 +147,25 @@ module ActiveRepository
     #   * RelatedClass.where(:name => "Peter")
     #   * RelatedClass.where("name = 'Peter'")
     def self.where(*args)
-      raise ArgumentError.new("wrong number of arguments (0 for 1)") if args.empty?
+      raise ArgumentError.new("must pass at least one argument") if args.empty?
 
-      if repository?
-        args = args.first if args.try(:first).is_a?(Array)
-        query_executor = SqlQueryExecutor::Base.new(all)
-        query_executor.where(args)
-      else
-        objects = PersistenceAdapter.where(self, sanitize_args(args)).map do |object|
-          self.serialize!(object.attributes)
-        end
+      result_set = ActiveRepository::ResultSet.new(self)
 
-        objects
-      end
+      # binding.pry
+
+      result_set.where(args)
+
+      # if repository?
+      #   args = args.first if args.respond_to?(:size) && args.size == 1
+      #   query_executor = SqlQueryExecutor::Base.new(all)
+      #   query_executor.where(args)
+      # else
+      #   objects = PersistenceAdapter.where(self, sanitize_args(args)).map do |object|
+      #     self.serialize!(object.attributes)
+      #   end
+
+      #   objects
+      # end
     end
 
     def get_model_class
@@ -163,14 +182,16 @@ module ActiveRepository
 
     # Gathers the persisted object from database and updates self with it's attributes.
     def reload
-      object = self.id.present? ? get_model_class.find(self.id) : self
+      object = self.id.present? ? 
+                 get_model_class.where(id: self.id).first_or_initialize : 
+                 self
 
       serialize! object.attributes
     end
 
     def save(force=false)
       if self.class == get_model_class
-        object = get_model_class.find(self.id)
+        object = get_model_class.where(id: self.id).first_or_initialize
 
         if force || self.id.nil?
           self.id = nil if self.id.nil?
@@ -221,29 +242,10 @@ module ActiveRepository
       end
 
     private
-
-      # Checks if model_class is a Mongoid model
-      def self.mongoid?
-        get_model_class.included_modules.include?(Mongoid::Document)
-      end
-
       def self.repository?
         self == get_model_class
       end
 
-      def self.sanitize_args(args)
-        args.first.is_a?(Hash) ? args.first : (args.first.is_a?(Array) ? args.first : args)
-      end
-
-      def repository?
-        self.class.repository?
-      end
-
-      # Checks if model_class is a Mongoid model
-      def mongoid?
-        self.class.mongoid?
-      end
-
       # Updates created_at and updated_at
       def set_timestamps
         if self.errors.empty?

data/lib/active_repository/finders.rb

@@ -1,43 +1,13 @@
 # Module containing methods responsible for searching ActiveRepository objects
 module ActiveRepository #:nodoc:
   module Finders #:nodoc:
-    # Defines fiend_by_field methods for the Class
-    def define_custom_find_by_field(field_name)
-      method_name = :"find_by_#{field_name}"
-      the_meta_class.instance_eval do
-        define_method(method_name) do |*args|
-          object = nil
-
-          object = self.where(field_name.to_sym => args).first
-
-          object.nil? ? nil : serialize!(object.attributes)
-        end
-      end
-    end
-
-    # Defines fiend_all_by_field methods for the Class
-    def define_custom_find_all_by_field(field_name)
-      method_name = :"find_all_by_#{field_name}"
-      the_meta_class.instance_eval do
-        define_method(method_name) do |*args|
-          objects = []
-
-          objects = self.find_all_by_field(field_name.to_sym, args)
-
-          objects.empty? ? [] : objects.map{ |object| serialize!(object.attributes) }
-        end
-      end
-    end
-
     # Searches for a object containing the id in #id
     def find(id)
       begin
         if repository?
           super(id)
         else
-          object = (id == :all) ? all : PersistenceAdapter.find(self, id)
-
-          serialize!(object)
+          serialize!(PersistenceAdapter.find(self, id))
         end
       rescue Exception => e
         message = "Couldn't find #{self} with ID=#{id}"
@@ -47,51 +17,6 @@ module ActiveRepository #:nodoc:
       end
     end
 
-    # Searches all objects that matches #field_name field with the #args value(s)
-    def find_all_by_field(field_name, args)
-      objects = []
-
-      # raise "field: #{field_name}; values: #{args.first.inspect}; all: #{get_model_class.all.inspect}"
-
-      if repository?
-        objects = self.where(field_name.to_sym => args.first)
-      else
-        objects = PersistenceAdapter.where(self, field_name.to_sym => args.first)
-        # if mongoid?
-        #   objects = get_model_class.where(field_name.to_sym => args.first)
-        # else
-        #   method_name = :"find_all_by_#{field_name}"
-        #   objects = get_model_class.send(method_name, args)
-        # end
-      end
-
-      objects
-    end
-
-    # Searches first object that matches #field_name field with the #args value(s)
-    # def find_by_field(field_name, args)
-    #   self.find_all_by_field(field_name, args).first.dup
-    # end
-
-    # Searches for an object that has id with #id value, if none is found returns nil
-    def find_by_id(id)
-      if repository?
-        object = super(id)
-
-        object.nil? ? nil : object.dup
-      else
-        object = PersistenceAdapter.where(self, :id => id).first
-
-        # if mongoid?
-        #   object = get_model_class.where(:id => id).entries.first
-        # else
-        #   object = get_model_class.find_by_id(id)
-        # end
-
-        object.nil? ? nil : serialize!(object.attributes)
-      end
-    end
-
     # Returns first persisted object
     def first
       repository? ? super : get(:first)

data/lib/active_repository/result_set.rb

@@ -0,0 +1,76 @@
+class ActiveRepository::ResultSet
+	def initialize(klass, query={}, attributes={})
+    @klass = klass
+    convert_query(query)
+    @attributes = query.is_a?(Hash) ? attributes.merge(query) : attributes
+  end
+
+  def all
+    @query ? get_result(@query) : @klass.all
+  end
+
+  def count
+    all.size
+  end
+
+  def first
+    @query ? all.first : @klass.all.first
+  end
+
+  def first_or_initialize
+    object = all.first
+
+    object ? object : @klass.new(@attributes)
+  end
+
+  def first_or_create
+    object = first_or_initialize
+
+    object.new_record? ? object.save : object
+
+    object.reload
+  end
+
+  def last
+    @query ? all.last : @klass.all.last
+  end
+
+  def where(query)
+    @attributes = @attributes.merge(query) if query.is_a?(Hash)
+    query = join_query(query, 'and')
+
+    ActiveRepository::ResultSet.new(@klass, query, @attributes)
+  end
+  alias_method :and, :where
+
+  def or(query)
+    query = join_query(query, 'or')
+
+    ActiveRepository::ResultSet.new(@klass, query, @attributes)
+  end
+
+private
+  def convert_query(query)
+    @query = SqlQueryExecutor::Query::QueryNormalizer.clean_query(query)
+  end
+
+  def get_result(args)
+    if @klass.repository?
+      args = args.first if args.is_a?(Array) && args.size == 1
+      query_executor = SqlQueryExecutor::Base.new(@klass.all, args)
+      query_executor.execute!
+    else
+      query = SqlQueryExecutor::Base.new([], args)
+      objects = PersistenceAdapter.where(@klass, query).map do |object|
+        @klass.serialize!(object.attributes)
+      end
+
+      objects
+    end
+  end
+
+  def join_query(query, separator)
+    query = SqlQueryExecutor::Query::QueryNormalizer.clean_query(query)
+    query.blank? ? @query : (@query.blank? ? query : "(#{@query}) #{separator} (#{query})")
+  end
+end

data/lib/active_repository/version.rb

@@ -1,3 +1,3 @@
 module ActiveRepository
-  VERSION = "0.2.7"
+  VERSION = "0.3.0"
 end

data/lib/active_repository/write_support.rb

@@ -40,32 +40,17 @@ module ActiveHash
       end
     end
 
-    def self.where(query)
-      if query.is_a?(String)
-        return ActiveHash::SQLQueryExecutor.execute(self, query)
-      else
-        (@records || []).select do |record|
-          query.all? { |col, match| record[col] == match }
-        end
-      end
-    end
-
     def self.validate_unique_id(record)
       raise IdError.new("Duplicate Id found for record #{record.attributes}") if record_index.has_key?(record.id.to_s)
     end
 
-    def update_attribute(key, value)
-      self.send("#{key}=", value)
-      self.save(:validate => false)
-    end
-
     def readonly?
       false
     end
 
     def save(*args)
       if self.valid?
-        record = self.class.find_by_id(self.id)
+        record = self.class.find_by(id: self.id)
 
         self.class.insert(self) if record.nil? && record != self
 
@@ -77,11 +62,11 @@ module ActiveHash
     end
 
     def delete
-      record = self.class.find_by_id(self.id)
+      record = self.class.find_by(id: self.id)
 
       self.class.remove(self)
 
-      self.class.find_by_id(self.id).nil?
+      self.class.find_by(id: self.id).nil?
     end
 
     def to_param
@@ -89,7 +74,7 @@ module ActiveHash
     end
 
     def persisted?
-      other = self.class.find_by_id(id)
+      other = self.class.find_by(id: id)
       other.present?
     end
 

data/lib/active_repository/writers.rb

@@ -23,25 +23,6 @@ module ActiveRepository
       new_object
     end
 
-    # Searches for an object that matches the attributes on the parameter, if none is found
-    # it creates one with the defined attributes.
-    def find_or_create(attributes)
-      object = where(attributes).first
-
-      object.nil? ? create(attributes) : object
-    end
-
-    def find_or_initialize(attributes)
-      attributes = attributes.symbolize_keys if attributes.respond_to?(:symbolize_keys)
-      object     = where(attributes).first || self.new(attributes)
-
-      attributes.each do |key, value|
-        object.send("#{key}=", value)
-      end
-
-      serialize!(object.attributes)
-    end
-
     #:nodoc:
     module InstanceMethods
       # Assigns new_attributes parameter to the attributes in self.
@@ -67,7 +48,7 @@ module ActiveRepository
         key = key.to_sym
 
         if self.class == get_model_class
-          object = self.class.find_or_initialize(:id => self.id)
+          object = self.class.where(:id => self.id).first_or_initialize
 
           self.send("#{key}=", value)