active_mocker 1.5.2 → 1.6

data/lib/active_mocker/active_record/scope.rb

@@ -1,12 +1,22 @@
-module Scope
+module ActiveMocker
 
-  def scope(method_name, proc)
-    get_named_scopes[method_name] = proc
-  end
+  module ActiveRecord
+
+    module Scope
+
+      def scope(method_name, proc)
+        get_named_scopes[method_name] = proc
+      end
+
+      def get_named_scopes
+        @scope_methods ||= {}
+      end
+
+    end
 
-  def get_named_scopes
-    @scope_methods ||= {}
   end
 
 end
 
+
+

data/lib/active_mocker/active_record/unknown_class_method.rb

@@ -1,9 +1,13 @@
 module ActiveMocker
 
-  module UnknownClassMethod
+  module ActiveRecord
+
+    module UnknownClassMethod
+
+      def method_missing(meth, *args)
+        Logger.debug "ActiveMocker :: DEBUG :: #{meth} called from class #{self.name} is unknown and will not be available in mock.\n"
+      end
 
-    def method_missing(meth, *args)
-      Logger.debug "ActiveMocker :: DEBUG :: #{meth} called from class #{self.name} is unknown and will not be available in mock.\n"
     end
 
   end

data/lib/active_mocker/active_record/unknown_module.rb

@@ -1,26 +1,31 @@
 module ActiveMocker
 
-  module UnknownModule
+  module ActiveRecord
 
-    def include(_module)
-      try_and_log('include', _module, caller)
-    end
+    module UnknownModule
 
-    def extend(_module)
-      try_and_log('extend', _module, caller)
-    end
+      def include(_module)
+        try_and_log('include', _module, caller)
+      end
 
-    private
+      def extend(_module)
+        try_and_log('extend', _module, caller)
+      end
 
-    def try_and_log(type, name, _caller)
-      begin
-        super _module
-      rescue => e
-        Logger.debug "ActiveMocker :: Debug :: Can't #{type} module #{name} from class #{self.name}.\n\t\t\t\t\t\t\t\t#{_caller}\n"
-        Logger.debug "\t\t\t\t\t\t\t\t#{e}"
+      private
+
+      def try_and_log(type, name, _caller)
+        begin
+          super _module
+        rescue => e
+          Logger.debug "ActiveMocker :: Debug :: Can't #{type} module #{name} from class #{self.name}.\n\t\t\t\t\t\t\t\t#{_caller}\n"
+          Logger.debug "\t\t\t\t\t\t\t\t#{e}"
+        end
       end
+
     end
 
   end
 
+
 end

data/lib/active_mocker/db_to_ruby_type.rb

@@ -1,4 +1,5 @@
 module ActiveMocker
+  # @api private
   class DBToRubyType
 
     def self.call(type)

data/lib/active_mocker/field.rb

@@ -1,5 +1,5 @@
 module ActiveMocker
-
+  # @api private
   class Field
 
     attr_accessor :name, :type, :options

data/lib/{file_reader.rb → active_mocker/file_reader.rb}

@@ -1,7 +1,12 @@
+module ActiveMocker
+# @api private
 class FileReader
 
   def self.read(file_and_path)
     File.open(file_and_path).read
   end
 
+end
+
+  private_constant :FileReader
 end

data/lib/active_mocker/generate.rb

@@ -27,10 +27,13 @@ class Generate
     config(&block)
   end
 
+  # Method will be deprecated in v2
   def self.mock(model_name, force_reload: false)
     load_mock(model_name)
   end
 
+  private
+
   def self.load_mock(model_name)
     load File.join(mock_dir, "#{model_name.tableize.singularize}_mock.rb")
     "#{model_name}Mock".constantize
@@ -58,11 +61,13 @@ class Generate
 
   def create_template
     mocks_created = 0
+    FileUtils.rm_rf("#{mock_dir}/", secure: true)
+    FileUtils::mkdir_p mock_dir unless File.directory? mock_dir
     generate_model_schema.each do |model|
       begin
 
       klass_str = model.render(File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read, mock_append_name)
-      FileUtils::mkdir_p mock_dir unless File.directory? mock_dir
+
       File.open(File.join(mock_dir,"#{model.table_name.singularize}_mock.rb"), 'w').write(klass_str)
       logger.info "saving mock #{model.class_name} to #{mock_dir}"
 

data/lib/active_mocker/loaded_mocks.rb

@@ -4,47 +4,65 @@ module ActiveMocker
     
     class << self
 
-      def add(mocks_to_add)
-        mocks.merge!({mocks_to_add.name => mocks_to_add})
-      end
-
-      def add_subclass(subclass)
-        subclasses.merge!({subclass.mocked_class => subclass})
-      end
-
-      def subclasses
-        @subclasses ||= {}
-      end
-
-      def clear_subclasses
-        subclasses.clear
-      end
-
-      def mocks
-        @mocks ||= {}
-      end
-
+      # Input ActiveRecord Model as String returns ActiveMock equivalent class.
+      #   +find('User')+ => UserMock
       def find(klass)
         class_name_to_mock[klass]
       end
 
+      # Returns Hash key being a string of the active_record class name
+      # and the value being the mocked class.
+      #   ActiveMocker::LoadedMocks.all
+      #      => {'PersonMock' => PersonMock}
       def all
         mocks
       end
 
+      # Calls clear_all for all mocks, which deletes all saved records and removes mock_class/instance_method.
+      #   It will also clear any sub classed mocks from the list
+      #   Method will be deprecated in v2 because mocking is deprecated
       def clear_all
         all_mocks.each { |m| m.clear_mock }
         clear_subclasses
       end
 
+      # Calls delete_all for all mocks, which deletes all saved records.
+      #
       def delete_all
         all_mocks.each { |m| m.delete_all }
       end
 
+      # Reloads the mocks file from disk.
+      # === Experimental Feature
       def reload_all
         all_mocks.each { |m| m.send(:reload) }
       end
 
+      # Returns Hash +{"ActiveRecordModel" => MockVersion}+, key being a string of the active_record class name
+      # and the value being the mocked class. Any sub classed mocked will override the original mock until clear_all is called.
+      #
+      #   ActiveMocker::LoadedMocks.class_name_to_mock
+      #       => {'Person' => PersonMock}
+      def class_name_to_mock
+        mocks.values.each_with_object({}) do |mock_constant, hash|
+          hash[mock_constant.send(:mocked_class)] = mock_constant
+        end.merge(subclasses)
+      end
+
+      private
+
+      def add(mocks_to_add)
+        mocks.merge!({mocks_to_add.name => mocks_to_add})
+      end
+
+      def add_subclass(subclass)
+        subclasses.merge!({subclass.send(:mocked_class) => subclass})
+      end
+
+      def mocks
+        @mocks ||= {}
+      end
+
       def undefine_all
         all_mocks_as_str.each do |n|
           Object.send(:remove_const, n) if Object.const_defined?(n)
@@ -55,21 +73,19 @@ module ActiveMocker
         mocks.keys + subclasses.keys
       end
 
-      def class_name_to_mock
-        hash = mocks.values.each_with_object({}) do |mock_constant, hash|
-          hash[mock_constant.mocked_class] = mock_constant
-        end
-        hash.merge(subclasses)
+      def subclasses
+        @subclasses ||= {}
       end
 
-      private
+      def clear_subclasses
+        subclasses.clear
+      end
 
       def internal_clear
         clear_subclasses
         mocks.clear
       end
 
-
       def all_mocks
         mocks.values + subclasses.values
       end

data/lib/active_mocker/logger.rb

@@ -1,4 +1,5 @@
 module ActiveMocker
+  # @api private
   class Logger
 
     def self.set(logger)

data/lib/active_mocker/mock/base.rb

@@ -8,52 +8,96 @@ class Base
   extend  Queries
 
   def self.inherited(subclass)
-    return ActiveMocker::LoadedMocks.add(subclass) if subclass.superclass == Base
-    ActiveMocker::LoadedMocks.add_subclass(subclass)
+    return ActiveMocker::LoadedMocks.send(:add, subclass) if subclass.superclass == Base
+    ActiveMocker::LoadedMocks.send(:add_subclass, subclass)
   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)
-      record = new
-      record.save
-      record.send(:set_properties, attributes) unless block_given?
-      record.send(:set_properties_block, attributes, &block) if block_given?
-      record
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| create(attr, &block) }
+      else
+        record = new
+        record.save
+        record.assign_attributes(attributes, &block)
+        record
+      end
     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
 
     private :records
 
-    delegate :count, :insert, :exists?, :to_a, :to => :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)
-      find(id).delete
+      if id.is_a?(Array)
+        id.map { |one_id| delete(one_id) }
+      else
+        find(id).delete
+      end
     end
 
     alias_method :destroy, :delete
 
-    def delete_all(options=nil)
-      return records.reset if options.nil?
+    # 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
 
     alias_method :destroy_all, :delete_all
 
+    # @api private
+    def from_limit?
+      false
+    end
+
     def build_type(type)
       Virtus::Attribute.build(type)
     end
@@ -85,9 +129,17 @@ class Base
 
   attr_reader :associations, :types, :attributes
 
+  # 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)
     setup_instance_variables
-    set_properties_block(attributes, &block)
+    assign_attributes(attributes, &block)
   end
 
   def setup_instance_variables
@@ -98,27 +150,35 @@ class Base
 
   private :setup_instance_variables
 
-  def set_properties_block(attributes = {}, &block)
-    yield self if block_given?
-    set_properties(attributes)
-  end
-  private :set_properties_block
-
   def update(attributes={})
-    set_properties(attributes)
+    assign_attributes(attributes)
   end
 
-  def set_properties(attributes={})
-    attributes.each do |key, value|
-      begin
-        send "#{key}=", value
-      rescue NoMethodError
-        raise RejectedParams, "{:#{key}=>#{value.inspect}} for #{self.class.name}"
-      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
 
-  private :set_properties
+  alias attributes= assign_attributes
+
+  # @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 save(*args)
     unless self.class.exists?(self)
@@ -135,6 +195,7 @@ class Base
 
   private :records
 
+
   def delete
     records.delete(self)
   end
@@ -143,20 +204,52 @@ class Base
 
   delegate :[], :[]=, to: :attributes
 
-  def reload
-    self
-  end
-
+  # Returns true if this object hasn't been saved yet; otherwise, returns false.
   def new_record?
-    !records.new_record?(self)
+    records.new_record?(self)
   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
 
-  def to_hash
-    attributes
+  # 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
+
+  # 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
 
   def inspect
@@ -175,18 +268,26 @@ class Base
 
   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
 
+    # 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
 
+    # @api private
     def read_association(attr)
       @associations[attr]
     end
 
+    # @api private
     def write_association(attr, value)
       @associations[attr] = value
     end
@@ -199,6 +300,16 @@ class Base
 
   class ScopeRelation < ::ActiveMocker::Mock::Association
   end
+
+end
+
+def self.config
+  @config ||= Config.new
 end
+
+class Config
+  attr_accessor :experimental
+end
+
 end
 end