active_mocker 1.3.2 → 1.4.1

data/lib/active_mock/collection.rb

@@ -0,0 +1,52 @@
+module ActiveMock
+
+  class Collection
+
+    include Enumerable
+
+    def initialize(collection=[])
+      @collection = [*collection]
+    end
+
+    def <<(*records)
+      collection.concat(records.flatten)
+    end
+
+    extend Forwardable
+    def_delegators :@collection, :take, :push, :clear, :first, :last, :concat, :replace, :distinct, :uniq, :count, :size, :length, :empty?, :any?, :include?, :delete
+    alias distinct uniq
+
+    def select(&block)
+      collection.select(&block)
+    end
+
+    def each(&block)
+      collection.each do |item|
+        block.call(item)
+      end
+    end
+
+    def map(&block)
+      collection.map do |item|
+        block.call(item)
+      end
+    end
+
+    def to_a
+      @collection
+    end
+
+    def ==(val)
+      return false if val.nil?
+      collection.hash == val.hash
+    end
+
+    private
+
+    def collection
+      @collection
+    end
+
+  end
+
+end

data/lib/active_mock/creators.rb

@@ -0,0 +1,25 @@
+module ActiveMock
+    module Creators
+
+      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
+
+    end
+
+end
+

data/lib/active_mock/do_nothing_active_record_methods.rb

@@ -0,0 +1,51 @@
+module ActiveMock
+module DoNothingActiveRecordMethods
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def transaction
+      yield
+    rescue LocalJumpError => err
+      raise err
+    rescue StandardError => e
+      raise e
+    end
+
+  end
+
+  def readonly?
+    false
+  end
+
+  def errors
+    obj = Object.new
+
+    def obj.[](key)
+      []
+    end
+
+    def obj.full_messages()
+      []
+    end
+
+    obj
+  end
+
+  def valid?
+    true
+  end
+
+  def marked_for_destruction?
+    false
+  end
+
+  def destroyed?
+    false
+  end
+
+end
+end

data/lib/active_mock/has_and_belongs_to_many.rb

@@ -0,0 +1,7 @@
+module ActiveMock
+  class HasAndBelongsToMany < Collection
+
+    include Queries
+
+  end
+end

data/lib/active_mock/has_many.rb

@@ -0,0 +1,54 @@
+module ActiveMock
+
+  class HasMany < Association
+
+    include Queries
+
+    def self.new(collection, foreign_key=nil, foreign_id=nil, relation_class=nil)
+      return Association.new(collection) if relation_class.nil?
+      super(collection, foreign_key, foreign_id, relation_class)
+    end
+
+
+    def initialize(collection, foreign_key=nil, foreign_id=nil, relation_class=nil)
+      @relation_class = relation_class
+      @foreign_key    = foreign_key
+      @foreign_id     = foreign_id
+
+      super(collection)
+    end
+
+    private
+    attr_reader :relation_class, :foreign_key, :foreign_id
+    public
+
+    def build(options={}, &block)
+      new_record = relation_class.new({foreign_key => foreign_id}.merge!(options), &block)
+
+      def new_record.belongs_to(collection, foreign_key)
+        @belongs_to_collection ||={}
+        @belongs_to_collection[foreign_key] = collection
+      end
+
+      new_record.belongs_to(self, foreign_key)
+
+      def new_record.save
+        @belongs_to_collection.each {|k ,v| v << self}
+        super
+      end
+
+      new_record
+    end
+
+    def create(options={}, &block)
+      created_record = relation_class.create({foreign_key => foreign_id}.merge!(options), &block)
+      collection << created_record
+      created_record
+    end
+
+    alias_method :create!, :create
+
+  end
+
+end
+

data/lib/active_mock/next_id.rb

@@ -0,0 +1,16 @@
+class NextId
+
+  def initialize(records)
+    @records = records
+  end
+
+  def next
+    return 1 if max_record.nil?
+    max_record.id.succ if max_record.id.is_a?(Numeric)
+  end
+
+  def max_record
+    @max_record ||= @records.max { |a, b| a.id <=> b.id }
+  end
+
+end

data/lib/active_mock/object_inspect.rb

@@ -0,0 +1,39 @@
+class ObjectInspect
+
+  def initialize(class_name, attributes)
+    @class_name = class_name
+    @attributes = attributes
+    @string     = create_inspections
+  end
+
+  def to_s
+    @string
+  end
+
+  def to_str
+    @string
+  end
+
+  private
+
+  def create_inspections
+    inspection = @attributes.map do |name ,value|
+      "#{name}: #{object_for_inspect(value)}"
+    end
+    "#<#{@class_name} #{inspection.compact.join(", ")}>"
+  end
+
+  def object_for_inspect(value)
+    if value.is_a?(String) && value.length > 50
+      "#{value[0, 50]}...".inspect
+    elsif value.is_a?(Date) || value.is_a?(Time)
+      %("#{value.to_s(:db)}")
+    elsif value.is_a?(Array) && value.size > 10
+      inspected = value.first(10).inspect
+      %(#{inspected[0...-1]}, ...])
+    else
+      value.inspect
+    end
+  end
+
+end

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

@@ -1,10 +1,15 @@
-module ActiveMocker
+module ActiveMock
 
-class RecordNotFound < Exception; end
+  module Queries
 
-module Collection
+    def self.included(klass)
+      @included = klass
+    end
 
-  module Queries
+    def self.included_klass
+      return Relation if @included.name == 'ActiveMocker::Base'
+      @included
+    end
 
     class Find
 
@@ -28,9 +33,9 @@ module Collection
       end
 
       def not(options={})
-        @collection.reject do |record|
+        Queries.included_klass.new(@collection.reject do |record|
           Find.new(record).is_of(options)
-        end
+        end)
       end
     end
 
@@ -42,19 +47,15 @@ module Collection
       delete_all
     end
 
-    def all(options={})
-      if options.has_key?(:conditions)
-        where(options[:conditions])
-      else
-        Relation.new( to_a || [] )
-      end
+    def all
+      Queries.included_klass.new( to_a || [] )
     end
 
     def where(options=nil)
       return WhereNotChain.new(all) if options.nil?
-      all.select do |record|
+      Queries.included_klass.new(all.select do |record|
         Find.new(record).is_of(options)
-      end
+      end)
     end
 
     def find(ids)
@@ -62,7 +63,7 @@ module Collection
       results = ids_array.map do |id|
         where(id: id).first
       end
-      return Relation.new(results) if ids.class == Array
+      return Queries.included_klass.new(results) if ids.class == Array
       results.first
     end
 
@@ -81,7 +82,7 @@ module Collection
     end
 
     def limit(num)
-      Relation.new(all.take(num))
+      Queries.included_klass.new(all.take(num))
     end
 
     def sum(key)
@@ -103,6 +104,14 @@ module Collection
       values_by_key(key).max_by { |i| i }
     end
 
+    def order(key)
+      Queries.included_klass.new(all.sort_by { |item| item.send(key) })
+    end
+
+    def reverse_order
+      Queries.included_klass.new(to_a.reverse)
+    end
+
     private
 
     def values_by_key(key)
@@ -111,6 +120,4 @@ module Collection
 
   end
 
-end
-end
-
+end

data/lib/active_mock/records.rb

@@ -0,0 +1,81 @@
+class Records
+
+  attr_reader :records
+
+  def initialize(records=[])
+    @records = records
+  end
+
+  def insert(record)
+    record.attributes[:id] ||= next_id
+    validate_unique_id(record)
+    add_to_record_index({record.id.to_s => records.length})
+    records << record
+  end
+
+  def delete(record)
+    record_index.delete("#{record.id}")
+    index = records.index(record)
+    records.delete_at(index)
+  end
+
+  def <<(record)
+    records << record
+  end
+
+  def length
+    records.length
+  end
+
+  alias_method :count, :length
+
+  def record_index
+    @record_index ||= {}
+  end
+
+  def add_to_record_index(entry)
+    record_index.merge!(entry)
+  end
+
+  def reset_record_index
+    record_index.clear
+  end
+
+  def clear
+    records.clear
+  end
+
+  def to_a
+    records
+  end
+
+  def reset_all_records
+    reset_record_index
+    clear
+  end
+
+  def next_id
+    NextId.new(records).next
+  end
+
+  def validate_unique_id(record)
+    if record_index.has_key?(record.id.to_s)
+      raise ActiveMock::IdError.new("Duplicate ID found for record #{record.attributes.inspect}")
+    end
+  end
+
+  def exists?(record)
+    if record.id.present?
+      record_index[record.id.to_s].present?
+    end
+  end
+
+  def new_record?(record)
+    !records.include?(record)
+  end
+
+  def persisted?(id)
+    records.map(&:id).include?(id)
+  end
+
+end

data/lib/active_mock/relation.rb

@@ -0,0 +1,8 @@
+module ActiveMock
+
+  class Relation < Collection
+    include Queries
+
+  end
+
+end

data/lib/active_mocker.rb

@@ -19,5 +19,7 @@ require 'active_mocker/active_record/schema'
 require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/reparameterize'
-require 'active_hash/ar_api'
+require 'active_mocker/db_to_ruby_type'
+require 'active_mocker/model_schema'
+require 'active_mocker/model_schema/generate'
 require 'virtus'