active_mocker 2.4.0.pre5 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f21e27c6d5e3d3826ffd754a682e7e35a247cd23
-  data.tar.gz: 6105da23915b21ac5c3d216ee96ad6e969f1dee4
+  metadata.gz: a77d43b16f10346cb55967ea8dcb22e2f0e3474d
+  data.tar.gz: d6b4efa5cff2e6a9f3c60ff80120ca9a7b1473d4
 SHA512:
-  metadata.gz: bb14e0c20c5ef33a7e55575c0f8b14dfdf42f20d8f07fc0f511993d3819c93b9c202573cade177eac21f7c6ba0c478a93729af388baac83865ec449d22bbc02f
-  data.tar.gz: d5aca0cb872f5adea5267c8d356b40cffce5bf661cb19d2c7b6f8afd827c54eec941c51c0587c962d013efeeb5b802da81dd12ad1f78d0cdd656ebf453cfe0e1
+  metadata.gz: f8f488dc87b52e8ee02a96a3e1428d38fddaa37601cdf666667f6ee0dc569a18989a8a5d0ca5dcdfb1f31e92d519d767d440a3b2efbb2b6e8b070d91628c3b89
+  data.tar.gz: 69d308aa84a28cc683d063cda2483f0051055748476de80e811b6fda30bc852835e6d7845e701d0bf87aeb11e59ac97df0f687d3fb1839cb8de29d5859c55abf

data/README.md

@@ -196,13 +196,38 @@ Use theses defaults if you are starting fresh
 ```ruby
 ActiveMocker::LoadedMocks.features.enable(:timestamps)
 ActiveMocker::LoadedMocks.features.enable(:delete_all_before_example)
+ActiveMocker::LoadedMocks.features.enable(:stub_active_record_exceptions)
 ```
 
 ### timestamps
-Enables created_at and updated_at to be update on save and create
+
+  Enables created_at and updated_at to be update on save and create
 
 ### delete_all_before_example
-When using "active_mocker/rspec_helper" it delete all records from all mocks before each example.
+
+  When using "active_mocker/rspec_helper" it delete all records from all mocks before each example.
+
+### stub_active_record_exceptions
+
+  When requiring "active_mocker/rspec_helper", and adding `active_mocker: true` to the describe metadata, these errors will be auto stubbed:
+  
+  * ActiveRecord::RecordNotFound
+  * ActiveRecord::RecordNotUnique
+  * ActiveRecord::UnknownAttributeError
+    
+### Copy over Mock safe methods into the generated mock
+  
+  Adding the comment `ActiveMocker.safe_methods` at the top of a class marks it as safe to copy to the mock.
+  Be careful that it does not contain anything that ActiveMocker cannot run.
+  
+  ```ruby
+  # ActiveMocker.safe_methods :full_name
+  class User
+    def full_name
+      "#{first_name} + #{last_name}
+    end
+  end
+  ```
 
 ## Mocking Methods
 
@@ -382,7 +407,6 @@ See [Documentation](http://rdoc.info/github/zeisler/active_mocker/master/ActiveM
   * create_< association >!
   * < association >.create
   * < association >.build
-  
 
 ### Schema/Migration Option Support
 * A db/schema.rb is not required.

data/lib/active_mocker.rb

@@ -25,6 +25,13 @@ require "active_mocker/progress"
 require "active_mocker/parent_class"
 require "active_mocker/template_creator"
 require "active_mocker/mock_creator"
+require "active_mocker/mock_creator/associations"
+require "active_mocker/mock_creator/attributes"
+require "active_mocker/mock_creator/class_methods"
+require "active_mocker/mock_creator/defined_methods"
+require "active_mocker/mock_creator/modules_constants"
+require "active_mocker/mock_creator/recreate_class_method_calls"
+require "active_mocker/mock_creator/scopes"
 require "active_mocker/error_object"
 require "active_mocker/display_errors"
 require "active_mocker/generate"

data/lib/active_mocker/file_writer.rb

@@ -98,9 +98,9 @@ module ActiveMocker
 
     def enabled_partials
       if config.disable_modules_and_constants
-        MockCreator.enabled_partials_default - [*:modules_constants]
+        MockCreator::ENABLED_PARTIALS_DEFAULT - [*:modules_constants]
       else
-        MockCreator.enabled_partials_default
+        MockCreator::ENABLED_PARTIALS_DEFAULT
       end
     end
 

data/lib/active_mocker/loaded_mocks/features.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 require "singleton"
+require "active_mocker/mock/exceptions"
 
 module ActiveMocker
   class LoadedMocks
     class Features
       include Singleton
-      DEFAULTS = {
-        timestamps:                false,
-        delete_all_before_example: false,
+      STUB_ACTIVE_RECORD_EXCEPTIONS = {
+        "ActiveRecord::RecordNotFound"        => ActiveMocker::RecordNotFound,
+        "ActiveRecord::RecordNotUnique"       => ActiveMocker::RecordNotUnique,
+        "ActiveRecord::UnknownAttributeError" => ActiveMocker::UnknownAttributeError,
+      }
+      DEFAULTS                      = {
+        timestamps:                    false,
+        delete_all_before_example:     false,
+        stub_active_record_exceptions: STUB_ACTIVE_RECORD_EXCEPTIONS,
       }.freeze
 
       def initialize

data/lib/active_mocker/mock/base.rb

@@ -133,6 +133,14 @@ module ActiveMocker
         associations_by_class[klass_name.to_s]
       end
 
+      # Not fully Implemented
+      # Returns association reflections names with nil values
+      #
+      #   #=> { "user" => nil, "order" => nil }
+      def reflections
+        associations.each_with_object({}) { |(k, _), h| h[k.to_s] = nil }
+      end
+
       private
 
       def created_with(version)

data/lib/active_mocker/mock/do_nothing_active_record_methods.rb

@@ -6,7 +6,7 @@ module ActiveMocker
     end
 
     module ClassMethods
-      def transaction
+      def transaction(*)
         yield
       rescue LocalJumpError => err
         raise err

data/lib/active_mocker/mock/exceptions.rb

@@ -4,6 +4,8 @@ module ActiveMocker
   end
   class RecordNotFound < BaseError
   end
+  class RecordNotUnique < BaseError
+  end
 
   module Mock
     # @deprecated

data/lib/active_mocker/mock_creator.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
-
 require "active_mocker/inspectable"
 
 module ActiveMocker
   class MockCreator
-
     using ActiveMocker::Inspectable
+    ENABLED_PARTIALS_DEFAULT = [
+      :modules_constants,
+      :class_methods,
+      :attributes,
+      :scopes,
+      :recreate_class_method_calls,
+      :defined_methods,
+      :associations,
+    ].freeze
+
     def initialize(file:,
                    file_out:,
                    schema_scrapper:,
@@ -21,7 +29,7 @@ module ActiveMocker
       @schema_scrapper          = schema_scrapper
       @template_creator         = template_creator || template_creator_default(file_out)
       @class_introspector       = class_introspector || class_introspector_default
-      @enabled_partials         = enabled_partials || self.class.enabled_partials_default
+      @enabled_partials         = enabled_partials || ENABLED_PARTIALS_DEFAULT
       @klasses_to_be_mocked     = klasses_to_be_mocked
       @active_record_base_klass = active_record_base_klass
       @mock_append_name         = mock_append_name
@@ -32,18 +40,19 @@ module ActiveMocker
 
     def create
       verify_class
-      if errors.empty?
-        begin
-          template_creator.render
-        rescue => e
-          raise e unless error_already_collected?(e)
-        end
-        file_out.close
-        @completed = true
-      end
+      render { file_out.close } if errors.empty?
       self
     end
 
+    def render
+      template_creator.render
+    rescue => e
+      raise e unless error_already_collected?(e)
+    ensure
+      yield
+      @completed = true
+    end
+
     def completed?
       @completed
     end
@@ -60,7 +69,8 @@ module ActiveMocker
                 :enabled_partials,
                 :klasses_to_be_mocked,
                 :active_record_base_klass,
-                :mock_append_name
+                :mock_append_name,
+                :active_record_model
 
     def error_already_collected?(e)
       errors.any? { |eo| eo.original_error == e }
@@ -84,37 +94,20 @@ module ActiveMocker
       DissociatedIntrospection::Inspection.new(file: file)
     end
 
-    class << self
-      def enabled_partials_default
-        [
-          :modules_constants,
-          :class_methods,
-          :attributes,
-          :scopes,
-          :recreate_class_method_calls,
-          :defined_methods,
-          :associations,
-        ]
-      end
+    # -- END defaults -- #
 
-      public :enabled_partials_default
+    def parent_class_inspector
+      @parent_class_inspector ||= ParentClass.new(parsed_source:        class_introspector.parsed_source,
+                                                  klasses_to_be_mocked: klasses_to_be_mocked,
+                                                  mock_append_name:     mock_append_name).call
     end
 
-    # -- END defaults -- #
-
-    def parent_class_constant
-      v                      = ParentClass.new(parsed_source:        class_introspector.parsed_source,
-                                               klasses_to_be_mocked: klasses_to_be_mocked,
-                                               mock_append_name:     mock_append_name).call
-      @parent_class_constant = v.parent_class
+    def verify_parent_class
+      errors << parent_class_inspector.error if parent_class_inspector.error
     end
 
     def verify_class
-      v = ParentClass.new(parsed_source:        class_introspector.parsed_source,
-                          klasses_to_be_mocked: klasses_to_be_mocked,
-                          mock_append_name:     mock_append_name).call
-      errors << v.error if v.error
-      @parent_class = v.parent_mock_name
+      verify_parent_class
     end
 
     public
@@ -123,7 +116,7 @@ module ActiveMocker
       OpenStruct.new(enabled_partials.each_with_object({}) do |p, hash|
         begin
           file = File.new(File.join(File.dirname(__FILE__), "mock_template/_#{p}.erb"))
-          extend("ActiveMocker::MockCreator::#{p.to_s.camelize}".constantize)
+          extend(ActiveMocker::MockCreator.const_get(p.to_s.camelize))
           hash[p] = ERB.new(file.read, nil, "-", "_sub#{p}").result(binding)
         rescue => e
           errors << ErrorObject.new(class_name:     class_name,
@@ -150,291 +143,8 @@ module ActiveMocker
       end
     end
 
-    attr_reader :parent_class, :active_record_model
-
     def primary_key
       @primary_key ||= ActiveRecordSchemaScrapper::Attribute.new(name: "id", type: :integer)
     end
-
-    module ModulesConstants
-      require "active_mocker/mock/unrepresentable_const_value"
-
-      class Inspectable
-        attr_reader :inspect
-
-        def initialize(inspect)
-          @inspect = inspect
-        end
-      end
-
-      def constants
-        class_introspector.get_class.constants.each_with_object({}) do |v, const|
-          c = class_introspector.get_class.const_get(v)
-          next if [Module, Class].include?(c.class)
-          if /\A#</ =~ c.inspect
-            const[v] = Inspectable.new("ActiveMocker::UNREPRESENTABLE_CONST_VALUE")
-          else
-            const[v] = c
-          end
-        end
-      end
-
-      def modules
-        @modules ||= begin
-          {
-            included: get_module_by_reference(:included_modules),
-            extended: get_module_by_reference(:extended_modules),
-          }
-        end
-      end
-
-      private
-
-      def get_module_by_reference(type)
-        isolated_module_names = reject_local_const(class_introspector.public_send(type)).map(&:referenced_name)
-        real_module_names = get_real_module(type).map(&:name).compact
-        isolated_module_names.map do |isolated_name|
-          real_name = real_module_names.detect do |rmn|
-            real_parts = rmn.split("::")
-            total_parts_count = active_record_model.name.split("::").count + isolated_name.split("::").count
-            [
-              real_parts.include?(active_record_model.name),
-              real_parts.include?(isolated_name),
-              (total_parts_count == real_parts.count)
-            ].all?
-          end
-          real_name ? real_name : isolated_name
-        end
-      end
-
-      def get_real_module(type)
-        if type == :extended_modules
-          active_record_model.singleton_class.included_modules
-        else
-          active_record_model.included_modules
-        end
-      end
-
-      def reject_local_const(source)
-        source.reject do |n|
-          class_introspector.locally_defined_constants.values.include?(n)
-        end
-      end
-    end
-
-    module Attributes
-      def attributes
-        @attributes ||= begin
-          a = schema_scrapper.attributes.to_a
-          a << primary_key unless a.any? { |aa| aa.name == "id" }
-          a.map(&method(:process_attr))
-          a
-        end
-      end
-
-      def process_attr(attr)
-        enums                 = enums(attr.name)
-        attr.default          = Virtus::Attribute.build(attr.type).coerce(attr.default)
-        attr.attribute_writer = "write_attribute(:#{attr.name}, val)"
-        attr.attribute_reader = "read_attribute(:#{attr.name})"
-
-        unless enums.empty?
-          enum_type = ActiveMocker::AttributeTypes::Enum.build(
-            enums:         enums,
-            table_name:    table_name,
-            attribute:     attr.name,
-            db_value_type: attr.type,
-          )
-          if ActiveRecord::VERSION::MAJOR == 5
-            enum_type.ignore_value = true
-            attr.type              = enum_type
-            if attr.default
-              attr.default = Virtus::Attribute.build(enum_type).get_key(attr.default)
-            end
-          elsif ActiveRecord::VERSION::MAJOR == 4
-            attr.attribute_writer = "@#{attr.name}_enum_type ||= Virtus::Attribute.build(#{enum_type})\nwrite_attribute(:#{attr.name}, @#{attr.name}_enum_type.coerce(val))"
-            attr.attribute_reader = "@#{attr.name}_enum_type ||= Virtus::Attribute.build(#{enum_type})\n@#{attr.name}_enum_type.get_key(read_attribute(:#{attr.name}))"
-            if attr.default
-              attr.default = Virtus::Attribute.build(attr.type).coerce(attr.default)
-            end
-          end
-          attr
-        end
-      end
-
-      def enums(attribute)
-        @enums ||= begin
-          raw_enums = class_introspector
-                        .class_macros
-                        .select { |hash| hash.key?(:enum) }
-          if raw_enums
-            raw_enums
-              .map { |hash| hash[:enum].flatten.first }
-              .each_with_object({}) { |v, h| h.merge!(v) }
-          else
-            {}
-          end
-        end
-
-        @enums.fetch(attribute.to_sym, {})
-      end
-    end
-
-    module ClassMethods
-      include Attributes
-
-      def attributes_with_defaults
-        types_hash
-        attributes.each_with_object({}) do |attr, hash|
-          hash[attr.name] = attr.default
-        end
-      end
-
-      def types_hash
-        @types_hash ||= attributes.each_with_object(HashNewStyle.new) do |attr, types|
-          types[attr.name] = attr.type.to_s
-        end.inspect
-      end
-
-      def associations
-        @associations ||= schema_scrapper.associations.to_a.each_with_object({}) do |a, h|
-          h[a.name] = nil
-        end
-      end
-
-      def associations_by_class
-        schema_scrapper.associations.to_a.each_with_object({}) do |r, hash|
-          hash[r.class_name.to_s]         ||= {}
-          hash[r.class_name.to_s][r.type] ||= []
-          hash[r.class_name.to_s][r.type] << r.name
-        end
-      end
-
-      def attribute_names
-        attributes.map(&:name)
-      end
-
-      def abstract_class
-        schema_scrapper.abstract_class?
-      end
-
-      def table_name
-        schema_scrapper.table_name
-      end
-
-      def mocked_class
-        [nested_modules, class_name].compact.reject(&:empty?).join("::")
-      end
-    end
-
-    Method = Struct.new(:name, :arguments, :body)
-
-    module Scopes
-      def scope_methods
-        class_introspector.class_macros.select { |h| h.keys.first == :scope }.map do |h|
-          a = h.values.first.first
-          Method.new(a[0], ReverseParameters.new(a[1], blocks_as_values: true), nil)
-        end
-      end
-    end
-
-    AliasAttributeMethod = Struct.new(:new_name, :old_name)
-    module RecreateClassMethodCalls
-      def class_method_calls
-        @class_method_calls ||= class_introspector
-                                  .class_macros
-                                  .select { |h| h.keys.first == :alias_attribute }
-                                  .map do |h|
-          a = h.values.first.first
-          AliasAttributeMethod.new(a[0].to_s, a[1].to_s)
-        end
-      end
-
-      def attribute_aliases
-        class_method_calls.each_with_object({}) do |alias_attr, hash|
-          hash[alias_attr.new_name] = alias_attr.old_name
-        end
-      end
-    end
-
-    module DefinedMethods
-      def instance_methods
-        meths = class_introspector.get_class.public_instance_methods(false).sort
-        if safe_methods.include?(:initialize)
-          meths << :initialize
-        end
-        meths.map { |m| create_method(m, :instance_method) }
-      end
-
-      def class_methods
-        class_introspector
-          .get_class
-          .methods(false)
-          .sort
-          .map { |m| create_method(m, :method) }
-      end
-
-      private
-
-      def safe_methods
-        @safe_methods ||= class_introspector.parsed_source.comments.flat_map do |comment|
-          if comment.text.include?("ActiveMocker.safe_methods")
-            ActiveMocker.module_eval(comment.text.delete("#"))
-          end
-        end
-      end
-
-      module ActiveMocker
-        def self.safe_methods(*methods)
-          methods
-        end
-      end
-
-      def create_method(m, type)
-        if safe_methods.include?(m)
-          def_method = class_introspector.parsed_source.defs.detect { |meth| meth.name == m }
-          Method.new(
-            m,
-            def_method.arguments,
-            def_method.body
-          )
-        else
-          Method.new(
-            m,
-            ReverseParameters.new(
-              class_introspector.get_class.send(type, m).parameters,
-              blocks_as_values: true
-            ).parameters,
-            "call_mock_method(method: __method__, caller: Kernel.caller, arguments: [])"
-          )
-        end
-      end
-    end
-
-    module Associations
-      def has_many
-        relation_find(:type, __method__)
-      end
-
-      def has_one
-        relation_find(:type, __method__)
-      end
-
-      def belongs_to
-        relation_find(:type, __method__)
-      end
-
-      def has_and_belongs_to_many
-        relation_find(:type, __method__)
-      end
-
-      def relation_find(key, value)
-        association_collection.select { |r| r.send(key).to_sym == value }
-      end
-
-      def association_collection
-        @association_collection ||= schema_scrapper.associations.to_a
-      end
-    end
   end
 end

data/lib/active_mocker/mock_creator/associations.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module Associations
+      def has_many
+        relation_find(:type, __method__)
+      end
+
+      def has_one
+        relation_find(:type, __method__)
+      end
+
+      def belongs_to
+        relation_find(:type, __method__)
+      end
+
+      def has_and_belongs_to_many
+        relation_find(:type, __method__)
+      end
+
+      def relation_find(key, value)
+        association_collection.select { |r| r.send(key).to_sym == value }
+      end
+
+      def association_collection
+        @association_collection ||= schema_scrapper.associations.to_a
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/attributes.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module Attributes
+      def attributes
+        @attributes ||= begin
+          a = schema_scrapper.attributes.to_a
+          a << primary_key unless a.any? { |aa| aa.name == "id" }
+          a.map(&method(:process_attr))
+          a
+        end
+      end
+
+      def process_attr(attr)
+        enums                 = enums(attr.name)
+        attr.default          = Virtus::Attribute.build(attr.type).coerce(attr.default)
+        attr.attribute_writer = "write_attribute(:#{attr.name}, val)"
+        attr.attribute_reader = "read_attribute(:#{attr.name})"
+
+        unless enums.empty?
+          enum_type = ActiveMocker::AttributeTypes::Enum.build(
+            enums:         enums,
+            table_name:    table_name,
+            attribute:     attr.name,
+            db_value_type: attr.type,
+          )
+          if ActiveRecord::VERSION::MAJOR == 5
+            enum_type.ignore_value = true
+            attr.type              = enum_type
+            if attr.default
+              attr.default = Virtus::Attribute.build(enum_type).get_key(attr.default)
+            end
+          elsif ActiveRecord::VERSION::MAJOR == 4
+            attr.attribute_writer = "@#{attr.name}_enum_type ||= Virtus::Attribute.build(#{enum_type})\nwrite_attribute(:#{attr.name}, @#{attr.name}_enum_type.coerce(val))"
+            attr.attribute_reader = "@#{attr.name}_enum_type ||= Virtus::Attribute.build(#{enum_type})\n@#{attr.name}_enum_type.get_key(read_attribute(:#{attr.name}))"
+            if attr.default
+              attr.default = Virtus::Attribute.build(attr.type).coerce(attr.default)
+            end
+          end
+          attr
+        end
+      end
+
+      def enums(attribute)
+        @enums ||= begin
+          raw_enums = class_introspector
+                        .class_macros
+                        .select { |hash| hash.key?(:enum) }
+          if raw_enums
+            raw_enums
+              .map { |hash| hash[:enum].flatten.first }
+              .each_with_object({}) { |v, h| h.merge!(v) }
+          else
+            {}
+          end
+        end
+
+        @enums.fetch(attribute.to_sym, {})
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/class_methods.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require_relative "attributes"
+
+module ActiveMocker
+  class MockCreator
+    module ClassMethods
+      include Attributes
+
+      def attributes_with_defaults
+        types_hash
+        attributes.each_with_object({}) do |attr, hash|
+          hash[attr.name] = attr.default
+        end
+      end
+
+      def types_hash
+        @types_hash ||= attributes.each_with_object(HashNewStyle.new) do |attr, types|
+          types[attr.name] = attr.type.to_s
+        end.inspect
+      end
+
+      def associations
+        @associations ||= schema_scrapper.associations.to_a.each_with_object({}) do |a, h|
+          h[a.name] = nil
+        end
+      end
+
+      def associations_by_class
+        schema_scrapper.associations.to_a.each_with_object({}) do |r, hash|
+          hash[r.class_name.to_s]         ||= {}
+          hash[r.class_name.to_s][r.type] ||= []
+          hash[r.class_name.to_s][r.type] << r.name
+        end
+      end
+
+      def attribute_names
+        attributes.map(&:name)
+      end
+
+      def abstract_class
+        schema_scrapper.abstract_class?
+      end
+
+      def table_name
+        schema_scrapper.table_name
+      end
+
+      def mocked_class
+        [nested_modules, class_name].compact.reject(&:empty?).join("::")
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/defined_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module DefinedMethods
+      Method = Struct.new(:name, :arguments, :body)
+
+      def instance_methods
+        meths = class_introspector.get_class.public_instance_methods(false).sort
+        if safe_methods.include?(:initialize)
+          meths << :initialize
+        end
+        meths.map { |m| create_method(m, :instance_method) }
+      end
+
+      def class_methods
+        class_introspector
+          .get_class
+          .methods(false)
+          .sort
+          .map { |m| create_method(m, :method) }
+      end
+
+      private
+
+      def safe_methods
+        @safe_methods ||= class_introspector.parsed_source.comments.flat_map do |comment|
+          if comment.text.include?("ActiveMocker.safe_methods")
+            ActiveMocker.module_eval(comment.text.delete("#"))
+          end
+        end
+      end
+
+      module ActiveMocker
+        def self.safe_methods(*methods)
+          methods
+        end
+      end
+
+      def create_method(m, type)
+        if safe_methods.include?(m)
+          def_method = class_introspector.parsed_source.defs.detect { |meth| meth.name == m }
+          Method.new(
+            m,
+            def_method.arguments,
+            def_method.body
+          )
+        else
+          Method.new(
+            m,
+            ReverseParameters.new(
+              class_introspector.get_class.send(type, m).parameters,
+              blocks_as_values: true
+            ).parameters,
+            "call_mock_method(method: __method__, caller: Kernel.caller, arguments: [])"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/modules_constants.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module ModulesConstants
+      class Inspectable
+        attr_reader :inspect
+
+        def initialize(inspect)
+          @inspect = inspect
+        end
+      end
+
+      def modules
+        @modules ||= begin
+          {
+            included: get_module_by_reference(:included_modules),
+            extended: get_module_by_reference(:extended_modules),
+          }
+        end
+      end
+
+      def constants
+        class_introspector.get_class.constants.each_with_object({}) do |v, const|
+          c = class_introspector.get_class.const_get(v)
+          next if [Module, Class].include?(c.class)
+          if /\A#</ =~ c.inspect
+            const[v] = Inspectable.new("ActiveMocker::UNREPRESENTABLE_CONST_VALUE")
+          else
+            const[v] = c
+          end
+        end
+      end
+
+      private
+      def reject_local_const(source)
+        source.reject do |n|
+          class_introspector.locally_defined_constants.values.include?(n)
+        end
+      end
+
+      def get_real_module(type)
+        if type == :extended_modules
+          active_record_model.singleton_class.included_modules
+        else
+          active_record_model.included_modules
+        end
+      end
+
+      def get_module_by_reference(type)
+        isolated_module_names = reject_local_const(class_introspector.public_send(type)).map(&:referenced_name)
+        real_module_names     = get_real_module(type).map(&:name).compact
+        isolated_module_names.map do |isolated_name|
+          real_name = real_module_names.detect do |rmn|
+            real_parts        = rmn.split("::")
+            total_parts_count = active_record_model.name.split("::").count + isolated_name.split("::").count
+            [
+              real_parts.include?(active_record_model.name),
+              real_parts.include?(isolated_name),
+              (total_parts_count == real_parts.count)
+            ].all?
+          end
+          real_name ? real_name : isolated_name
+        end
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/recreate_class_method_calls.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module RecreateClassMethodCalls
+      AliasAttributeMethod = Struct.new(:new_name, :old_name)
+
+      def class_method_calls
+        @class_method_calls ||= class_introspector
+                                  .class_macros
+                                  .select { |h| h.keys.first == :alias_attribute }
+                                  .map do |h|
+          a = h.values.first.first
+          AliasAttributeMethod.new(a[0].to_s, a[1].to_s)
+        end
+      end
+
+      def attribute_aliases
+        class_method_calls.each_with_object({}) do |alias_attr, hash|
+          hash[alias_attr.new_name] = alias_attr.old_name
+        end
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_creator/scopes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module ActiveMocker
+  class MockCreator
+    module Scopes
+      Method = Struct.new(:name, :arguments, :body)
+
+      def scope_methods
+        class_introspector.class_macros.select { |h| h.keys.first == :scope }.map do |h|
+          a = h.values.first.first
+          Method.new(a[0], ReverseParameters.new(a[1], blocks_as_values: true), nil)
+        end
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_template.erb

@@ -1,6 +1,6 @@
 require 'active_mocker/mock'
 
-class <%= class_name + mock_append_name %> < <%= parent_class %>
+class <%= class_name + mock_append_name %> < <%= parent_class_inspector.parent_mock_name %>
 
   created_with('<%= ActiveMocker::VERSION %>')
 

data/lib/active_mocker/mock_template/_class_methods.erb

@@ -1,5 +1,7 @@
 #_class_methods.erb
   class << self
+private
+
     def attributes
       @attributes ||= HashWithIndifferentAccess.new(<%= attributes_with_defaults.map {|key,value| %Q[#{key}: #{value.inspect}]}.join(", ") %>).merge(super)
     end
@@ -20,7 +22,7 @@
       <%= mocked_class.inspect %>
     end
 
-    private :mocked_class
+public
 
     def attribute_names
       @attribute_names ||= attributes.stringify_keys.keys

data/lib/active_mocker/mock_template/_scopes.erb

@@ -1,6 +1,6 @@
 # _scopes.erb
   module Scopes
-    include <%= parent_class %>::Scopes
+include <%= parent_class_inspector.parent_mock_name %>::Scopes
 
   <% scope_methods.each do |method| -%>
   def <%= method.name %><%= "(#{method.arguments.parameters})" unless method.arguments.parameters.to_a.empty? %>

data/lib/active_mocker/rspec_helper.rb

@@ -9,7 +9,9 @@ RSpec.configure do |config|
     unless ENV["RUN_WITH_RAILS"] && self.class.metadata[:rails_compatible]
       active_mocker.mocks.each { |class_name, mock| stub_const(class_name, mock) }
     end
-    stub_const("ActiveRecord::RecordNotFound", ActiveMocker::RecordNotFound)
+    if (mapping = active_mocker.features[:stub_active_record_exceptions])
+      mapping.each { |class_name, mock| stub_const(class_name, mock) }
+    end
   end
 
   config.after(:all, active_mocker: true) do

data/lib/active_mocker/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ActiveMocker
-  VERSION = "2.4.0.pre5"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_mocker
 version: !ruby/object:Gem::Version
-  version: 2.4.0.pre5
+  version: 2.4.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2016-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -227,6 +227,13 @@ files:
 - lib/active_mocker/mock/template_methods.rb
 - lib/active_mocker/mock/unrepresentable_const_value.rb
 - lib/active_mocker/mock_creator.rb
+- lib/active_mocker/mock_creator/associations.rb
+- lib/active_mocker/mock_creator/attributes.rb
+- lib/active_mocker/mock_creator/class_methods.rb
+- lib/active_mocker/mock_creator/defined_methods.rb
+- lib/active_mocker/mock_creator/modules_constants.rb
+- lib/active_mocker/mock_creator/recreate_class_method_calls.rb
+- lib/active_mocker/mock_creator/scopes.rb
 - lib/active_mocker/mock_template.erb
 - lib/active_mocker/mock_template/_associations.erb
 - lib/active_mocker/mock_template/_attributes.erb
@@ -260,9 +267,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1