active_mocker 1.4.2 → 1.5

data/lib/active_mocker/mock.rb

@@ -0,0 +1,24 @@
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/try'
+require 'virtus'
+
+require 'active_mocker/logger'
+require 'active_mocker/loaded_mocks'
+require 'active_mocker/rspec_helper'
+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/association'
+require 'active_mocker/mock/has_many'
+require 'active_mocker/mock/has_and_belongs_to_many'
+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'
+require 'active_mocker/mock/next_id'
+require 'active_mocker/mock/records'
+require 'active_mocker/mock/object_inspect'
+require 'active_mocker/mock/base'

data/lib/active_mocker/mock/association.rb

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

data/lib/{active_mock → active_mocker/mock}/base.rb

@@ -1,25 +1,11 @@
-module ActiveMock
-
-class RecordNotFound < StandardError
-end
-
-class ReservedFieldError < StandardError
-end
-
-class IdError < StandardError
-end
-
-class FileTypeMismatchError < StandardError
-end
-
-class RejectedParams < Exception
-end
-
+module ActiveMocker
+module Mock
 class Base
 
   include DoNothingActiveRecordMethods
-  extend  ActiveMock::Queries
-  extend  ActiveMock::Creators
+  include MockAbilities
+  include TemplateMethods
+  extend  Queries
 
   def self.inherited(subclass)
     return ActiveMocker::LoadedMocks.add(subclass) if subclass.superclass == Base
@@ -28,6 +14,24 @@ class Base
 
   class << self
 
+    def create(attributes = {}, &block)
+      record = new
+      record.save
+      record.send(:set_properties, attributes) unless block_given?
+      record.send(:set_properties_block, attributes, &block) if block_given?
+      record
+    end
+
+    alias_method :create!, :create
+
+    def find_or_create_by(attributes)
+      find_by(attributes) || create(attributes)
+    end
+
+    def find_or_initialize_by(attributes)
+      find_by(attributes) || new(attributes)
+    end
+
     def records
       @records ||= Records.new
     end
@@ -44,8 +48,8 @@ class Base
     alias_method :destroy, :delete
 
     def delete_all(options=nil)
-      return records.reset_all_records if options.nil?
-      where(options).map { |r| r.delete }.count
+      return records.reset if options.nil?
+      super
     end
 
     alias_method :destroy_all, :delete_all
@@ -58,12 +62,16 @@ class Base
       ActiveMocker::LoadedMocks.find(klass)
     end
 
-    private :classes
+    def new_relation(collection)
+      ScopeRelation.new(collection)
+    end
+
+    private :classes, :build_type, :new_relation
 
     public
 
     def clear_mock
-      @model_class_methods, @model_instance_methods = nil, nil
+      clear_mocked_methods
       delete_all
     end
 
@@ -83,13 +91,9 @@ class Base
   end
 
   def setup_instance_variables
-    {:@model_instance_methods => :model_instance_methods,
-     :@model_class_methods    => :model_class_methods,
-     :@associations           => :associations,
-     :@attributes             => :attributes,
-     :@types                  => :types}.each do |var, value|
-      instance_variable_set(var, self.class.send(value).dup)
-    end
+    @types        = self.class.send(:types)
+    @attributes   = self.class.send(:attributes).dup
+    @associations = self.class.send(:associations).dup
   end
 
   private :setup_instance_variables
@@ -109,7 +113,7 @@ class Base
       begin
         send "#{key}=", value
       rescue NoMethodError
-        raise ActiveMock::RejectedParams, "{:#{key}=>#{value.inspect}} for #{self.class.name}"
+        raise RejectedParams, "{:#{key}=>#{value.inspect}} for #{self.class.name}"
       end
     end
   end
@@ -135,8 +139,14 @@ class Base
     records.delete(self)
   end
 
+  alias_method :destroy, :delete
+
   delegate :[], :[]=, to: :attributes
 
+  def reload
+    self
+  end
+
   def new_record?
     !records.new_record?(self)
   end
@@ -187,64 +197,8 @@ class Base
 
   include PropertiesGetterAndSetter
 
-  module MockAbilities
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def mock_instance_method(method, &block)
-        model_instance_methods[method.to_s] = block
-      end
-
-      def mock_class_method(method, &block)
-        model_class_methods[method.to_s] = block
-      end
-
-      def model_class_methods
-        @model_class_methods ||= HashWithIndifferentAccess.new
-      end
-
-      def model_instance_methods
-        @model_instance_methods ||= HashWithIndifferentAccess.new
-      end
-
-      private :model_class_methods, :model_instance_methods
-
-
-      def is_implemented(val, method)
-        raise "#{method} is not Implemented for Class: #{name}" if val == :not_implemented
-      end
-
-    end
-
-    def mock_instance_method(method, &block)
-      @model_instance_methods[method.to_s] = block
-    end
-
-    def model_instance_methods
-      class_level_mocks = self.class.send(:model_instance_methods)
-      merged_mocks      = class_level_mocks.merge(@model_instance_methods)
-      return class_level_mocks if all_not_implemented?(merged_mocks) && !all_not_implemented?(class_level_mocks)
-      merged_mocks
-    end
-
-    def all_not_implemented?(hash)
-      hash.select { |k, v| v == :not_implemented }.count == hash.count
-    end
-    
-    private :all_not_implemented?
-
-    def model_class_methods
-      self.class.send(:model_class_methods).merge(@model_class_methods)
-    end
-
-    private :model_class_methods, :model_instance_methods
-
+  class ScopeRelation < ::ActiveMocker::Mock::Association
   end
-
-  include MockAbilities
-
 end
 end
+end

data/lib/{active_mock → active_mocker/mock}/collection.rb

@@ -1,4 +1,5 @@
-module ActiveMock
+module ActiveMocker
+module Mock
 
   class Collection
 
@@ -36,17 +37,23 @@ module ActiveMock
       @collection
     end
 
-    def ==(val)
-      return false if val.nil?
-      collection.hash == val.hash
+    def to_ary
+      to_a
     end
 
-    private
+    def hash
+      @collection.hash
+    end
 
-    def collection
-      @collection
+    def ==(val)
+      @collection == val
     end
 
+    protected
+
+    attr_accessor :collection
+
   end
 
+end
 end

data/lib/{active_mock → active_mocker/mock}/do_nothing_active_record_methods.rb

@@ -1,4 +1,5 @@
-module ActiveMock
+module ActiveMocker
+module Mock
 module DoNothingActiveRecordMethods
 
   def self.included(base)
@@ -15,6 +16,10 @@ module DoNothingActiveRecordMethods
       raise e
     end
 
+    def column_names
+      attribute_names
+    end
+
   end
 
   def readonly?
@@ -47,5 +52,6 @@ module DoNothingActiveRecordMethods
     false
   end
 
+end
 end
 end

data/lib/active_mocker/mock/exceptions.rb

@@ -0,0 +1,25 @@
+module ActiveMocker
+module Mock
+  class RecordNotFound < StandardError
+  end
+
+  class ReservedFieldError < StandardError
+  end
+
+  class IdError < StandardError
+  end
+
+  class FileTypeMismatchError < StandardError
+  end
+
+  class RejectedParams < Exception
+  end
+
+  class Unimplemented < Exception
+  end
+
+  class IdNotNumber < Exception
+  end
+
+end
+end

data/lib/active_mocker/mock/has_and_belongs_to_many.rb

@@ -0,0 +1,6 @@
+module ActiveMocker
+module Mock
+  class HasAndBelongsToMany < HasMany
+  end
+end
+end

data/lib/active_mocker/mock/has_many.rb

@@ -0,0 +1,60 @@
+module ActiveMocker
+module Mock
+
+  class HasMany < Association
+
+    include Queries
+
+    def self.new(collection, foreign_key=nil, foreign_id=nil, relation_class=nil)
+      return Relation.new(collection) if relation_class.nil?
+      super
+    end
+
+    def initialize(collection, foreign_key, foreign_id, relation_class)
+      @relation_class = relation_class
+      @foreign_key    = foreign_key
+      @foreign_id     = foreign_id
+      self.class.include "#{relation_class.name}::Scopes".constantize
+      super(collection)
+    end
+
+    private
+    attr_reader :relation_class, :foreign_key, :foreign_id
+    public
+
+    def build(options={}, &block)
+      new_record = relation_class.new(init_options.merge!(options), &block)
+
+      def new_record.belongs_to(collection)
+        @belongs_to_collection = collection
+      end
+
+      new_record.belongs_to(self)
+
+      def new_record.save
+        @belongs_to_collection << self
+        super
+      end
+
+      new_record
+    end
+
+    def create(options={}, &block)
+      created_record = relation_class.create(init_options.merge!(options), &block)
+      collection << created_record
+      created_record
+    end
+
+    alias_method :create!, :create
+
+    def init_options
+      {foreign_key => foreign_id}
+    end
+
+    private :init_options
+
+  end
+
+end
+end
+

data/lib/active_mocker/mock/hash_process.rb

@@ -0,0 +1,19 @@
+module ActiveMocker
+  module Mock
+    class HashProcess
+
+      attr_accessor :hash, :processor
+
+      def initialize(hash, processor)
+        @hash         = hash
+        @processor    = processor
+        @hash_process = {}
+      end
+
+      def [](val)
+        @hash_process[val] ||= processor.call(hash[val])
+      end
+
+    end
+  end
+end

data/lib/active_mocker/mock/mock_abilities.rb

@@ -0,0 +1,98 @@
+module ActiveMocker
+  module Mock
+  module MockAbilities
+
+    module InstanceAndClassMethods
+
+      def mock_instance_method(method, exe_bind=false, &block)
+        mockable_instance_methods[method.to_sym] = MockMethod.new(block, exe_bind)
+      end
+
+      alias_method :stub_instance_method, :mock_instance_method
+
+      def clear_mocked_methods
+        mockable_instance_methods.clear
+        mockable_class_methods.clear
+      end
+
+      private
+
+      def mockable_instance_methods
+        @mockable_instance_methods ||= {}
+      end
+
+      def class_name
+        return name if self.class == Class
+        self.class
+      end
+
+      def is_implemented(val, method, type)
+        raise Unimplemented, "#{type}#{method} is not Implemented for Class: #{class_name}" if val.nil?
+      end
+
+      def execute_block(method)
+        return instance_exec(method.arguments, &method.block) if method.exe_bind
+        method.block.call(*method.arguments)
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      include InstanceAndClassMethods
+
+      def mockable_class_methods
+        @mockable_class_methods ||= {}
+      end
+
+      def mock_class_method(method, exe_bind=false, &block)
+        mockable_class_methods[method.to_sym] = MockMethod.new(block, exe_bind)
+      end
+
+      alias_method :stub_class_method, :mock_class_method
+
+      def call_mock_method(method, *arguments)
+        mock_method = mockable_class_methods[method.to_sym]
+        is_implemented(mock_method, method, '::')
+        mock_method.arguments = arguments
+        execute_block(mock_method)
+      end
+
+      private :call_mock_method
+
+    end
+
+    include InstanceAndClassMethods
+
+    def call_mock_method(method, *arguments)
+      mock_method = mockable_instance_methods[method.to_sym]
+      mock_method = self.class.send(:mockable_instance_methods)[method.to_sym] if mock_method.nil?
+      is_implemented(mock_method, method, '#')
+      mock_method.arguments = arguments
+      execute_block mock_method
+    end
+
+    private :call_mock_method
+
+    def clear_mocked_methods
+      mockable_instance_methods.clear
+    end
+
+    class MockMethod
+
+      attr_accessor :block, :arguments, :exe_bind
+
+      def initialize(block, exe_bind)
+        @block     = block
+        @exe_bind  = exe_bind
+      end
+
+    end
+
+  end
+  end
+end