active_mocker 2.0.0.beta1 → 2.0.0.pre1

data/lib/active_mocker/mock.rb

@@ -7,19 +7,18 @@ require 'active_support/core_ext'
 require 'virtus'
 
 require 'active_mocker/version'
-require 'active_mocker/logger'
 require 'active_mocker/loaded_mocks'
 require 'active_mocker/mock/hash_process'
 require 'active_mocker/mock/collection'
 require 'active_mocker/mock/queries'
 require 'active_mocker/mock/relation'
+require 'active_mocker/mock/mock_relation'
 require 'active_mocker/mock/association'
 require 'active_mocker/mock/has_many'
 require 'active_mocker/mock/single_relation'
 require 'active_mocker/mock/has_one'
 require 'active_mocker/mock/has_and_belongs_to_many'
 require 'active_mocker/mock/belongs_to'
-require 'active_mocker/mock/mock_abilities'
 require 'active_mocker/mock/exceptions'
 require 'active_mocker/mock/template_methods'
 require 'active_mocker/mock/do_nothing_active_record_methods'

data/lib/active_mocker/mock/association.rb

@@ -1,6 +1,4 @@
 module ActiveMocker
-module Mock
   class Association < Relation
   end
-end
 end

data/lib/active_mocker/mock/base.rb

@@ -1,325 +1,339 @@
 module ActiveMocker
-  module Mock
-    class Base
+  class Base
+    include DoNothingActiveRecordMethods
+    include TemplateMethods
+    extend Queries
 
-      include DoNothingActiveRecordMethods
-      include MockAbilities
-      include TemplateMethods
-      extend Queries
-
-      def self.inherited(subclass)
-        return ActiveMocker::LoadedMocks.send(:add, subclass) if subclass.superclass == Base
-      end
-
-      class << self
-
-        # Creates an object (or multiple objects) and saves it to memory.
-        #
-        # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
-        # attributes on the objects that are to be created.
-        #
-        # ==== Examples
-        #   # Create a single new object
-        #   User.create(first_name: 'Jamie')
-        #
-        #   # Create an Array of new objects
-        #   User.create([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }])
-        #
-        #   # Create a single object and pass it into a block to set other attributes.
-        #   User.create(first_name: 'Jamie') do |u|
-        #     u.is_admin = false
-        #   end
-        #
-        #   # Creating an Array of new objects using a block, where the block is executed for each object:
-        #   User.create([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }]) do |u|
-        #     u.is_admin = false
-        #   end
-        def create(attributes = {}, &block)
-          if attributes.is_a?(Array)
-            attributes.collect { |attr| create(attr, &block) }
-          else
-            record = new(id: attributes[:id] || attributes['id'])
-            record.save
-            record.assign_attributes(attributes, &block)
-            record._create_caller_locations = caller_locations
-            record
-          end
-        end
+    def self.inherited(subclass)
+      return ActiveMocker::LoadedMocks.send(:add, subclass) if subclass.superclass == Base
+    end
 
-        alias_method :create!, :create
+    class << self
 
-        def records
-          @records ||= Records.new
+      # Creates an object (or multiple objects) and saves it to memory.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      #
+      # ==== Examples
+      #   # Create a single new object
+      #   User.create(first_name: 'Jamie')
+      #
+      #   # Create an Array of new objects
+      #   User.create([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }])
+      #
+      #   # Create a single object and pass it into a block to set other attributes.
+      #   User.create(first_name: 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Creating an Array of new objects using a block, where the block is executed for each object:
+      #   User.create([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def create(attributes = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, &block) }
+        else
+          record = new(id: attributes.delete(:id) || attributes.delete("id"))
+          record.save
+          record.assign_attributes(attributes, &block)
+          record._create_caller_locations = caller_locations
+          record
         end
+      end
 
-        private :records
-
-        delegate :insert, :exists?, :to_a, :to => :records
-        delegate :first, :last, :to => :all
-
-        # Delete an object (or multiple objects) that has the given id.
-        #
-        # This essentially finds the object (or multiple objects) with the given id and then calls delete on it.
-        #
-        # ==== Parameters
-        #
-        # * +id+ - Can be either an Integer or an Array of Integers.
-        #
-        # ==== Examples
-        #
-        #   # Destroy a single object
-        #   TodoMock.delete(1)
-        #
-        #   # Destroy multiple objects
-        #   todos = [1,2,3]
-        #   TodoMock.delete(todos)
-        def delete(id)
-          if id.is_a?(Array)
-            id.map { |one_id| delete(one_id) }
-          else
-            find(id).delete
-          end
-        end
+      alias_method :create!, :create
 
-        alias_method :destroy, :delete
+      def records
+        @records ||= Records.new
+      end
 
-        # Deletes the records matching +conditions+.
-        #
-        #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
-        def delete_all(conditions=nil)
-          return records.reset if conditions.nil?
-          super
-        end
+      private :records
 
-        alias_method :destroy_all, :delete_all
+      delegate :insert, :exists?, :to_a, :to => :records
+      delegate :first, :last, :to => :all
 
-        # @api private
-        def from_limit?
-          false
+      # Delete an object (or multiple objects) that has the given id.
+      #
+      # This essentially finds the object (or multiple objects) with the given id and then calls delete on it.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - Can be either an Integer or an Array of Integers.
+      #
+      # ==== Examples
+      #
+      #   # Destroy a single object
+      #   TodoMock.delete(1)
+      #
+      #   # Destroy multiple objects
+      #   todos = [1,2,3]
+      #   TodoMock.delete(todos)
+      def delete(id)
+        if id.is_a?(Array)
+          id.map { |one_id| delete(one_id) }
+        else
+          find(id).delete
         end
+      end
 
-        def abstract_class?
-          true
-        end
+      alias_method :destroy, :delete
 
-        def build_type(type)
-          @@built_types       ||= {}
-          @@built_types[type] ||= Virtus::Attribute.build(type)
-        end
+      # Deletes the records matching +conditions+.
+      #
+      #   Post.where(person_id: 5).where(category: ['Something', 'Else']).delete_all
+      def delete_all(conditions=nil)
+        return records.reset if conditions.nil?
+        super
+      end
 
-        def classes(klass)
-          ActiveMocker::LoadedMocks.find(klass)
-        end
+      alias_method :destroy_all, :delete_all
 
-        def new_relation(collection)
-          ScopeRelation.new(collection)
-        end
+      # @api private
+      def from_limit?
+        false
+      end
 
-        private :classes, :build_type, :new_relation
+      def abstract_class?
+        true
+      end
 
-        public
+      def build_type(type)
+        @@built_types       ||= {}
+        @@built_types[type] ||= Virtus::Attribute.build(type)
+      end
 
-        def clear_mock
-          clear_mocked_methods
-          delete_all
-        end
+      def classes(klass)
+        ActiveMocker::LoadedMocks.find(klass)
+      end
 
-        def _find_associations_by_class(klass_name)
-          associations_by_class[klass_name.to_s]
-        end
+      # @param [Array<ActiveMocker::Base>] collection, an array of mock instances
+      # @return [ScopeRelation] for the given mock so that it will include any scoped methods
+      def __new_relation__(collection)
+        ScopeRelation.new(collection)
+      end
 
-        def created_with(version)
-          raise UpdateMocksError.new(self.name, version, ActiveMocker::VERSION) if version != ActiveMocker::VERSION
-        end
+      private :classes, :build_type, :__new_relation__
 
-        private :created_with
+      public
 
+      # @deprecated
+      def clear_mock
+        delete_all
       end
 
-      def classes(klass)
-        self.class.send(:classes, klass)
+      def _find_associations_by_class(klass_name)
+        associations_by_class[klass_name.to_s]
       end
 
-      private :classes
+      private
 
-      attr_reader :associations, :types, :attributes
-      attr_accessor :_create_caller_locations
-      # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with
-      # attributes but not yet saved (pass a hash with key names matching the associated table column names).
-      # In both instances, valid attribute keys are determined by the column names of the associated table --
-      # hence you can't have attributes that aren't part of the table columns.
-      #
-      # ==== Example:
-      #   # Instantiates a single new object
-      #   UserMock.new(first_name: 'Jamie')
-      def initialize(attributes = {}, &block)
-        if self.class.abstract_class?
-          raise NotImplementedError, "#{self.class.name} is an abstract class and cannot be instantiated."
-        end
-        setup_instance_variables
-        assign_attributes(attributes, &block)
+      def created_with(version)
+        raise UpdateMocksError.new(self.name, version, ActiveMocker::VERSION) if version != ActiveMocker::VERSION
       end
 
-      def setup_instance_variables
-        @types        = self.class.send(:types)
-        @attributes   = self.class.send(:attributes).dup
-        @associations = self.class.send(:associations).dup
+      # @deprecated
+      def call_mock_method(method:, caller:, arguments: [])
+        is_implemented(method, '::', caller)
       end
 
-      private :setup_instance_variables
-
-      def update(attributes={})
-        assign_attributes(attributes)
+      # @deprecated
+      def is_implemented(method, type, call_stack)
+        raise NotImplementedError, "#{type}#{method} for Class: #{name}. To continue stub the method.", call_stack
       end
+    end
 
-      # @api private
-      def assign_attributes(new_attributes, &block)
-        yield self if block_given?
-        unless new_attributes.respond_to?(:stringify_keys)
-          raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
-        end
-        return nil if new_attributes.blank?
-        attributes = new_attributes.stringify_keys
-        attributes.each do |k, v|
-          _assign_attribute(k, v)
-        end
-      end
+    # @deprecated
+    def call_mock_method(method:, caller:, arguments: [])
+      self.class.send(:is_implemented, method, '#', caller)
+    end
 
-      alias attributes= assign_attributes
+    private :call_mock_method
 
-      # @api private
-      def _assign_attribute(k, v)
-        public_send("#{k}=", v)
-      rescue NoMethodError
-        if respond_to?("#{k}=")
-          raise
-        else
-          raise UnknownAttributeError.new(self, k)
-        end
-      end
+    def classes(klass)
+      self.class.send(:classes, klass)
+    end
 
-      def save(*args)
-        unless self.class.exists?(self)
-          self.class.send(:insert, self)
-        end
-        true
+    private :classes
+
+    attr_reader :associations, :types, :attributes
+    # @private
+    attr_accessor :_create_caller_locations
+    # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with
+    # attributes but not yet saved (pass a hash with key names matching the associated table column names).
+    # In both instances, valid attribute keys are determined by the column names of the associated table --
+    # hence you can't have attributes that aren't part of the table columns.
+    #
+    # ==== Example:
+    #   # Instantiates a single new object
+    #   UserMock.new(first_name: 'Jamie')
+    def initialize(attributes = {}, &block)
+      if self.class.abstract_class?
+        raise NotImplementedError, "#{self.class.name} is an abstract class and cannot be instantiated."
       end
+      setup_instance_variables
+      assign_attributes(attributes, &block)
+    end
 
-      alias save! save
+    def setup_instance_variables
+      @types        = self.class.send(:types)
+      @attributes   = self.class.send(:attributes).dup
+      @associations = self.class.send(:associations).dup
+    end
 
-      def records
-        self.class.send(:records)
-      end
+    private :setup_instance_variables
 
-      private :records
+    def update(attributes={})
+      assign_attributes(attributes)
+    end
 
-      def delete
-        records.delete(self)
+    # @api private
+    def assign_attributes(new_attributes, &block)
+      yield self if block_given?
+      unless new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
       end
+      return nil if new_attributes.blank?
+      attributes = new_attributes.stringify_keys
+      attributes.each do |k, v|
+        _assign_attribute(k, v)
+      end
+    end
 
-      alias_method :destroy, :delete
-
-      delegate :[], :[]=, to: :attributes
+    alias attributes= assign_attributes
 
-      # Returns true if this object hasn't been saved yet; otherwise, returns false.
-      def new_record?
-        records.new_record?(self)
+    # @api private
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v)
+    rescue NoMethodError
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise UnknownAttributeError.new(self, k)
       end
+    end
 
-      # Indicates if the model is persisted. Default is +false+.
-      #
-      #  person = Person.new(id: 1, name: 'bob')
-      #  person.persisted? # => false
-      def persisted?
-        records.persisted?(id)
+    def save(*args)
+      unless self.class.exists?(self)
+        self.class.send(:insert, self)
       end
+      true
+    end
 
-      # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
-      #
-      #   person = Person.new
-      #   person.has_attribute?(:name)    # => true
-      #   person.has_attribute?('age')    # => true
-      #   person.has_attribute?(:nothing) # => false
-      def has_attribute?(attr_name)
-        @attributes.has_key?(attr_name.to_s)
-      end
+    alias save! save
 
-      # Returns +true+ if the specified +attribute+ has been set and is neither +nil+ nor <tt>empty?</tt> (the latter only applies
-      # to objects that respond to <tt>empty?</tt>, most notably Strings). Otherwise, +false+.
-      # Note that it always returns +true+ with boolean attributes.
-      #
-      #   person = Task.new(title: '', is_done: false)
-      #   person.attribute_present?(:title)   # => false
-      #   person.attribute_present?(:is_done) # => true
-      #   person.name = 'Francesco'
-      #   person.is_done = true
-      #   person.attribute_present?(:title)   # => true
-      #   person.attribute_present?(:is_done) # => true
-      def attribute_present?(attribute)
-        value = read_attribute(attribute)
-        !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
-      end
+    def records
+      self.class.send(:records)
+    end
 
-      # Returns an array of names for the attributes available on this object.
-      #
-      #   person = Person.new
-      #   person.attribute_names
-      #   # => ["id", "created_at", "updated_at", "name", "age"]
-      def attribute_names
-        self.class.attribute_names
-      end
+    private :records
 
-      def inspect
-        ObjectInspect.new(self.class.name, attributes).to_s
-      end
+    def delete
+      records.delete(self)
+    end
 
-      # Will not allow attributes to be changed
-      #
-      # Will freeze attributes forever. Querying for the record again will not unfreeze it because records exist in memory
-      # and are not initialized upon a query. This behaviour differs from ActiveRecord, beware of any side effect this may
-      # have when using this method.
-      def freeze
-        @attributes.freeze; self
-      end
+    alias_method :destroy, :delete
 
-      module PropertiesGetterAndSetter
+    delegate :[], :[]=, to: :attributes
 
-        # Returns the value of the attribute identified by <tt>attr_name</tt> after
-        # it has been typecast (for example, "2004-12-12" in a date column is cast
-        # to a date object, like Date.new(2004, 12, 12))
-        def read_attribute(attr)
-          @attributes[attr]
-        end
+    # Returns true if this object hasn't been saved yet; otherwise, returns false.
+    def new_record?
+      records.new_record?(self)
+    end
 
-        # Updates the attribute identified by <tt>attr_name</tt> with the
-        # specified +value+. Empty strings for fixnum and float columns are
-        # turned into +nil+.
-        def write_attribute(attr, value)
-          @attributes[attr] = types[attr].coerce(value)
-        end
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      records.persisted?(id)
+    end
 
-        # @api private
-        def read_association(attr, assign_if_value_nil=nil)
-          @associations[attr.to_sym] ||= assign_if_value_nil.try(:call)
-        end
+    # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
+    #
+    #   person = Person.new
+    #   person.has_attribute?(:name)    # => true
+    #   person.has_attribute?('age')    # => true
+    #   person.has_attribute?(:nothing) # => false
+    def has_attribute?(attr_name)
+      @attributes.has_key?(attr_name.to_s)
+    end
 
-        # @api private
-        def write_association(attr, value)
-          @associations[attr.to_sym] = value
-        end
+    # Returns +true+ if the specified +attribute+ has been set and is neither +nil+ nor <tt>empty?</tt> (the latter only applies
+    # to objects that respond to <tt>empty?</tt>, most notably Strings). Otherwise, +false+.
+    # Note that it always returns +true+ with boolean attributes.
+    #
+    #   person = Task.new(title: '', is_done: false)
+    #   person.attribute_present?(:title)   # => false
+    #   person.attribute_present?(:is_done) # => true
+    #   person.name = 'Francesco'
+    #   person.is_done = true
+    #   person.attribute_present?(:title)   # => true
+    #   person.attribute_present?(:is_done) # => true
+    def attribute_present?(attribute)
+      value = read_attribute(attribute)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    # Returns an array of names for the attributes available on this object.
+    #
+    #   person = Person.new
+    #   person.attribute_names
+    #   # => ["id", "created_at", "updated_at", "name", "age"]
+    def attribute_names
+      self.class.attribute_names
+    end
 
-        protected :read_attribute, :write_attribute, :read_association, :write_association
+    def inspect
+      ObjectInspect.new(self.class.name, attributes).to_s
+    end
+
+    # Will not allow attributes to be changed
+    #
+    # Will freeze attributes forever. Querying for the record again will not unfreeze it because records exist in memory
+    # and are not initialized upon a query. This behaviour differs from ActiveRecord, beware of any side effect this may
+    # have when using this method.
+    def freeze
+      @attributes.freeze; self
+    end
+
+    module PropertiesGetterAndSetter
 
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a date column is cast
+      # to a date object, like Date.new(2004, 12, 12))
+      def read_attribute(attr)
+        @attributes[attr]
       end
 
-      include PropertiesGetterAndSetter
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for fixnum and float columns are
+      # turned into +nil+.
+      def write_attribute(attr, value)
+        @attributes[attr] = types[attr].coerce(value)
+      end
 
-      class ScopeRelation < Association
+      # @api private
+      def read_association(attr, assign_if_value_nil=nil)
+        @associations[attr.to_sym] ||= assign_if_value_nil.try(:call)
       end
 
-      module Scopes
+      # @api private
+      def write_association(attr, value)
+        @associations[attr.to_sym] = value
       end
 
+      protected :read_attribute, :write_attribute, :read_association, :write_association
+
+    end
+
+    include PropertiesGetterAndSetter
+
+    class ScopeRelation < Association
+    end
+
+    module Scopes
     end
   end
 end