active_mocker 1.4.2 → 1.5

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

@@ -1,4 +1,5 @@
-module ActiveMock
+module ActiveMocker
+module Mock
 class NextId
 
   def initialize(records)
@@ -7,12 +8,16 @@ class NextId
 
   def next
     return 1 if max_record.nil?
-    max_record.id.succ if max_record.id.is_a?(Numeric)
+    return max_record.id.succ if max_record.id.is_a?(Numeric)
+    raise IdNotNumber
   end
 
+  private
+
   def max_record
     @max_record ||= @records.max { |a, b| a.id <=> b.id }
   end
 
+end
 end
 end

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

@@ -1,4 +1,5 @@
-module ActiveMock
+module ActiveMocker
+module Mock
 class ObjectInspect
 
   def initialize(class_name, attributes)
@@ -37,5 +38,6 @@ class ObjectInspect
     end
   end
 
+end
 end
 end

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

@@ -1,16 +1,8 @@
-module ActiveMock
+module ActiveMocker
+module Mock
 
   module Queries
 
-    def self.included(klass)
-      @included = klass
-    end
-
-    def self.included_klass
-      return Relation if @included.name == 'ActiveMocker::Base'
-      @included
-    end
-
     class Find
 
       def initialize(record)
@@ -28,47 +20,47 @@ module ActiveMock
 
     class WhereNotChain
 
-      def initialize(collection)
-        @collection = collection
+      def initialize(collection, parent_class)
+        @collection   = collection
+        @parent_class = parent_class
       end
 
       def not(options={})
-        Queries.included_klass.new(@collection.reject do |record|
+        @parent_class.call(@collection.reject do |record|
           Find.new(record).is_of(options)
         end)
       end
     end
 
-    def delete_all
-      all.map(&:delete)
+    def delete_all(options=nil)
+      if options.nil?
+        to_a.map(&:delete)
+        return to_a.clear
+      end
+      where(options).map { |r| r.delete }.count
     end
 
     def destroy_all
       delete_all
     end
 
-    def all
-      Queries.included_klass.new( to_a || [] )
-    end
-
     def where(options=nil)
-      return WhereNotChain.new(all) if options.nil?
-      Queries.included_klass.new(all.select do |record|
+      return WhereNotChain.new(all, method(:new_relation)) if options.nil?
+      new_relation(to_a.select do |record|
         Find.new(record).is_of(options)
       end)
     end
 
     def find(ids)
-      ids_array = [*ids]
-      results = ids_array.map do |id|
+      results = [*ids].map do |id|
         where(id: id).first
       end
-      return Queries.included_klass.new(results) if ids.class == Array
+      return new_relation(results) if ids.class == Array
       results.first
     end
 
     def update_all(options)
-      all.each{ |i| i.update(options)}
+      all.each { |i| i.update(options) }
     end
 
     def find_by(options = {})
@@ -82,7 +74,7 @@ module ActiveMock
     end
 
     def limit(num)
-      Queries.included_klass.new(all.take(num))
+      new_relation(all.take(num))
     end
 
     def sum(key)
@@ -97,7 +89,7 @@ module ActiveMock
     end
 
     def minimum(key)
-      values_by_key(key).min_by{|i| i }
+      values_by_key(key).min_by { |i| i }
     end
 
     def maximum(key)
@@ -105,11 +97,15 @@ module ActiveMock
     end
 
     def order(key)
-      Queries.included_klass.new(all.sort_by { |item| item.send(key) })
+      new_relation(all.sort_by { |item| item.send(key) })
     end
 
     def reverse_order
-      Queries.included_klass.new(to_a.reverse)
+      new_relation(to_a.reverse)
+    end
+
+    def all
+      new_relation(to_a || [])
     end
 
     private
@@ -118,6 +114,13 @@ module ActiveMock
       all.map { |obj| obj.send(key) }
     end
 
+    def new_relation(collection)
+      duped = self.dup
+      duped.collection = collection
+      duped
+    end
+
   end
 
+  end
 end

data/lib/active_mocker/mock/records.rb

@@ -0,0 +1,62 @@
+module ActiveMocker
+module Mock
+class Records
+
+  extend Forwardable
+  def_delegators :records, :<<, :count, :length, :to_a
+
+  attr_reader :records, :record_index
+  private     :records, :record_index
+  def initialize(records = [])
+    @records      ||= records
+    @record_index ||= {}
+  end
+
+  def insert(record)
+    record.attributes[:id] ||= next_id
+    validate_unique_id(record)
+    add_to_record_index(record)
+    records << record
+  end
+
+  def delete(record)
+    raise RecordNotFound, 'Record has not been created.' if new_record?(record)
+    record_index.delete("#{record.id}")
+    index = records.index(record)
+    records.delete_at(index)
+  end
+
+  def exists?(record)
+    records.include?(record)
+  end
+
+  def new_record?(record)
+    !exists?(record)
+  end
+
+  def persisted?(id)
+    records.map(&:id).include?(id)
+  end
+
+  def reset
+    record_index.clear
+    records.clear
+  end
+
+  private
+
+  def next_id
+    NextId.new(records).next
+  end
+
+  def add_to_record_index(record)
+    record_index.merge!({record.id.to_s => records.length})
+  end
+
+  def validate_unique_id(record)
+    raise IdError, "Duplicate ID found for record #{record.inspect}" if record_index.has_key?(record.id.to_s)
+  end
+
+end
+end
+end

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

@@ -1,8 +1,9 @@
-module ActiveMock
-
+module ActiveMocker
+module Mock
   class Relation < Collection
+
     include Queries
 
   end
-
+end
 end

data/lib/active_mocker/mock/template_methods.rb

@@ -0,0 +1,39 @@
+module ActiveMocker
+module Mock
+  module TemplateMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def attributes
+        raise Mock::Unimplemented
+      end
+
+      def types
+        raise Mock::Unimplemented
+      end
+
+      def associations
+        raise Mock::Unimplemented
+      end
+
+      def mocked_class
+        raise Mock::Unimplemented
+      end
+
+      def attribute_names
+        raise Mock::Unimplemented
+      end
+
+      def primary_key
+        raise Mock::Unimplemented
+      end
+
+    end
+
+  end
+end
+end

data/lib/active_mocker/mock_template.erb

@@ -1,10 +1,16 @@
-require 'active_mocker/active_mock'
+require 'active_mocker/mock'
 Object.send(:remove_const, "<%= class_name + @mock_append_name %>") if Object.const_defined?("<%= class_name + @mock_append_name %>")
 
-class <%= class_name + @mock_append_name %> < ActiveMock::Base
-<% constants.each do |constant| %>
+class <%= class_name + @mock_append_name %> < ActiveMocker::Mock::Base
+<% constants.each do |constant| -%>
   <%= constant.first %> = <%= constant.last.inspect %>
 <% end -%>
+<% modules[:included].each do |constant| -%>
+  prepend <%= constant %>
+<% end -%>
+<% modules[:extended].each do |constant| -%>
+  extend  <%= constant %>
+<% end -%>
 
   class << self
 
@@ -13,29 +19,17 @@ class <%= class_name + @mock_append_name %> < ActiveMock::Base
     end
 
     def types
-      @types ||= <%= types_hash %>
+      @types ||= ActiveMocker::Mock::HashProcess.new(<%= types_hash %>, method(:build_type))
     end
 
     def associations
       @associations ||= <%= associations %>
     end
 
-    def model_instance_methods
-      @model_instance_methods ||= <%= instance_method_not_implemented %>
-    end
-
-    def model_class_methods
-      @model_class_methods ||= <%= class_method_not_implemented %>
-    end
-
     def mocked_class
       '<%= class_name %>'
     end
 
-    def column_names
-      attribute_names
-    end
-
     def attribute_names
       @attribute_names ||= <%= attribute_names %>
     end
@@ -90,7 +84,7 @@ class <%= class_name + @mock_append_name %> < ActiveMock::Base
 <% association = relation_find(:name, meth.name).first -%>
 <% if association -%>
     association = classes('<%= association.class_name %>').try(:create,attributes, &block)
-    write_association(:<%= meth.name %>, nil) unless association.nil?
+    write_association(:<%= meth.name %>, association) unless association.nil?
 <% end -%>
   end
   alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
@@ -115,7 +109,7 @@ class <%= class_name + @mock_append_name %> < ActiveMock::Base
   def create_<%= meth.name %>(attributes={}, &block)
 <% association = relation_find(:name, meth.name).first -%>
 <% if association -%>
-    write_association(:<%= meth.name %>,classes('<%= association.class_name %>').create(attributes, &block)) if classes('<%= association.class_name %>')
+    write_association(:<%= meth.name %>, classes('<%= association.class_name %>').new(attributes, &block)) if classes('<%= association.class_name %>')
 <% end -%>
   end
   alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
@@ -124,40 +118,60 @@ class <%= class_name + @mock_append_name %> < ActiveMock::Base
 <%= '# has_many' unless has_many.empty? -%>
 <% has_many.each do |meth| %>
   def <%= meth.name %>
-    @associations[:<%= meth.name %>] ||= ActiveMock::HasMany.new([],'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
+    @associations[:<%= meth.name %>] ||= ActiveMocker::Mock::HasMany.new([],'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
   end
 
   def <%= meth.name %>=(val)
-    @associations[:<%= meth.name %>] ||= ActiveMock::HasMany.new(val,'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
+    @associations[:<%= meth.name %>] ||= ActiveMocker::Mock::HasMany.new(val,'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
   end
 <% end -%>
 <%= '# has_and_belongs_to_many' unless has_and_belongs_to_many.empty? -%>
 <% has_and_belongs_to_many.each do |meth| %>
   def <%= meth.name %>
-    @associations[:<%= meth.name %>] ||= ActiveMock::HasAndBelongsToMany.new
+    @associations[:<%= meth.name %>] ||= ActiveMocker::Mock::HasAndBelongsToMany.new([])
   end
 
   def <%= meth.name %>=(val)
-    @associations[:<%= meth.name %>] = ActiveMock::HasAndBelongsToMany.new(val)
+    @associations[:<%= meth.name %>] = ActiveMocker::Mock::HasAndBelongsToMany.new(val)
   end
 <% end -%>
 
+  module Scopes
+
+<% scope_methods.each do |method| -%>
+    def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
+      ActiveMocker::LoadedMocks.find('<%= class_name %>').send(:call_mock_method, '<%= method.name %>', <%= method.arguments.passable %>)
+    end
+
+<% end -%>
+  end
+
+  extend Scopes
+
+  class ScopeRelation < ActiveMocker::Mock::Association
+    include <%= class_name + @mock_append_name %>::Scopes
+  end
+
+  private
+
+  def self.new_relation(collection)
+    <%= class_name + @mock_append_name %>::ScopeRelation.new(collection)
+  end
+
+  public
+
   ##################################
-  #  Model Methods getter/setters  #
+  #        Model Methods           #
   ##################################
 
 <% instance_methods.each do |method| %>
-  def <%= method.name %>(<%= method.arguments %>)
-    block =  model_instance_methods['<%= method.name %>']
-    self.class.is_implemented(block, '#<%= method.name %>')
-    block.call(*[<%= method.arguments.passable %>])
+  def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
+    call_mock_method :<%= method.name %><%= ', ' unless method.arguments.empty? %><%= method.arguments.passable %>
   end
 <% end -%>
 <% class_methods.each do |method| %>
-  def self.<%= method.name %>(<%= method.arguments %>)
-    block =  model_class_methods['<%= method.name %>']
-    is_implemented(block, '::<%= method.name %>')
-    block.call(*[<%= method.arguments.passable %>])
+  def self.<%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
+    call_mock_method :<%= method.name %><%= ', ' unless method.arguments.empty? %><%= method.arguments.passable %>
   end
 <% end -%>
 

data/lib/active_mocker/model_reader.rb

@@ -25,6 +25,12 @@ module ActiveMocker
         begin
           m = Module.new
           m.module_eval(read_file, file_path)
+        rescue SyntaxError => e
+          Logger.error "ActiveMocker :: Error loading Model: #{model_name} \n \t\t\t\t\t\t\t\t`#{e}` \n"
+          puts "ActiveMocker :: Error loading Model: #{model_name} \n \t\t\t\t\t\t\t\t`#{e}` \n"
+          Logger.error "\t\t\t\t\t\t\t\t #{file_path}\n"
+          puts "\t\t\t\t\t\t\t\t #{file_path}\n"
+          failure = true
         rescue Exception => e
           Logger.error "ActiveMocker :: Error loading Model: #{model_name} \n \t\t\t\t\t\t\t\t`#{e}` \n"
           Logger.error "\t\t\t\t\t\t\t\t #{file_path}\n"
@@ -34,6 +40,10 @@ module ActiveMocker
       return false
     end
 
+    def real
+      model_name.classify.constantize
+    end
+
     def read_file
       file_reader.read(file_path)
     end
@@ -46,6 +56,16 @@ module ActiveMocker
       klass.methods(false)
     end
 
+    def scopes
+      klass.get_named_scopes
+    end
+
+    def scopes_with_arguments
+      scopes.map do |name, proc|
+        {name => proc.parameters, :proc => proc}
+      end
+    end
+
     def class_methods_with_arguments
       class_methods.map do |m|
         {m => klass.method(m).parameters }
@@ -111,6 +131,15 @@ module ActiveMocker
       const
     end
 
+    def modules
+      {included:  process_module_names(klass._included),
+       extended: process_module_names(klass._extended)}
+    end
+
+    def process_module_names(names)
+      names.reject { |m| /#{klass.inspect}/ =~ m.name }.map(&:inspect)
+    end
+
   end
 
 end