active_mocker 2.1.3 → 2.2.0

data/lib/active_mocker/mock/has_one.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
 module ActiveMocker
   class HasOne < SingleRelation
     attr_reader :item
 
     def initialize(item, child_self:, foreign_key:)
-      item.send(:write_attribute, foreign_key, item.try(:id)) if !item.try(:id).nil?
+      item.send(:write_attribute, foreign_key, item.try(:id)) unless item.try(:id).nil?
       super
     end
-
   end
 end

data/lib/active_mocker/mock/hash_process.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module ActiveMocker
   # @api private
   class HashProcess
-
     attr_accessor :hash, :processor
 
     def initialize(hash, processor)
@@ -19,4 +19,4 @@ module ActiveMocker
       self
     end
   end
-end
+end

data/lib/active_mocker/mock/mock_relation.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveMocker
   class MockRelation
     # @param [ActiveMocker::Base] mock, a generated mock class

data/lib/active_mocker/mock/object_inspect.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 module ActiveMocker
   class ObjectInspect
-
     def initialize(class_name, attributes)
       @class_name = class_name
       @attributes = attributes
@@ -37,4 +37,4 @@ module ActiveMocker
       end
     end
   end
-end
+end

data/lib/active_mocker/mock/queries.rb

@@ -1,13 +1,12 @@
+# frozen_string_literal: true
 module ActiveMocker
   module Queries
-
     class Find
-
       def initialize(record)
         @record = record
       end
 
-      def is_of(conditions={})
+      def is_of(conditions = {})
         conditions.all? do |col, match|
           if match.is_a? Enumerable
             any_match(col, match)
@@ -26,17 +25,15 @@ module ActiveMocker
       def compare(col, match)
         @record.send(col) == match
       end
-
     end
 
     class WhereNotChain
-
       def initialize(collection, parent_class)
         @collection   = collection
         @parent_class = parent_class
       end
 
-      def not(conditions={})
+      def not(conditions = {})
         @parent_class.call(@collection.reject do |record|
           Find.new(record).is_of(conditions)
         end)
@@ -60,16 +57,16 @@ module ActiveMocker
     #
     #   Post.limit(100).delete_all
     #   # => ActiveMocker::Error: delete_all doesn't support limit scope
-    def delete_all(conditions=nil)
+    def delete_all(conditions = nil)
       raise ActiveMocker::Error.new("delete_all doesn't support limit scope") if from_limit?
       if conditions.nil?
         to_a.map(&:delete)
         return to_a.clear
       end
-      where(conditions).map { |r| r.delete }.count
+      where(conditions).map(&:delete).count
     end
 
-    alias_method :destroy_all, :delete_all
+    alias destroy_all delete_all
 
     # Returns a new relation, which is the result of filtering the current relation
     # according to the conditions in the arguments.
@@ -113,7 +110,7 @@ module ActiveMocker
     #    User.where.not(name: "Jon")
     #
     # See WhereChain for more details on #not.
-    def where(conditions=nil)
+    def where(conditions = nil)
       return WhereNotChain.new(all, method(:__new_relation__)) if conditions.nil?
       __new_relation__(to_a.select do |record|
         Find.new(record).is_of(conditions)
@@ -131,7 +128,7 @@ module ActiveMocker
     #
     # <tt>ActiveMocker::RecordNotFound</tt> will be raised if one or more ids are not found.
     def find(ids)
-      raise RecordNotFound.new("Couldn't find #{self.name} without an ID") if ids.nil?
+      raise RecordNotFound.new("Couldn't find #{name} without an ID") if ids.nil?
       results = [*ids].map do |id|
         find_by!(id: id.to_i)
       end
@@ -200,10 +197,10 @@ module ActiveMocker
 
     # Like <tt>find_by</tt>, except that if no record is found, raises
     # an <tt>ActiveMocker::RecordNotFound</tt> error.
-    def find_by!(conditions={})
+    def find_by!(conditions = {})
       result = find_by(conditions)
       if result.nil?
-        raise RecordNotFound.new("Couldn't find #{self.name} with '#{conditions.keys.first}'=#{conditions.values.first}")
+        raise RecordNotFound.new("Couldn't find #{name} with '#{conditions.keys.first}'=#{conditions.values.first}")
       end
       result
     end
@@ -234,7 +231,7 @@ module ActiveMocker
       find_by(attributes) || create(attributes, &block)
     end
 
-    alias_method :find_or_create_by!, :find_or_create_by
+    alias find_or_create_by! find_or_create_by
 
     # Like <tt>find_or_create_by</tt>, but calls <tt>new</tt> instead of <tt>create</tt>.
     def find_or_initialize_by(attributes, &block)
@@ -354,10 +351,9 @@ module ActiveMocker
     end
 
     def __new_relation__(collection)
-      duped            = self.dup
+      duped            = dup
       duped.collection = collection
       duped
     end
-
   end
 end

data/lib/active_mocker/mock/records.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 module ActiveMocker
   class Records
-
     extend Forwardable
     def_delegators :records, :<<, :count, :length, :to_a
 
@@ -16,7 +16,7 @@ module ActiveMocker
     end
 
     def delete(record)
-      raise RecordNotFound, 'Record has not been created.' unless records.delete(record)
+      raise RecordNotFound, "Record has not been created." unless records.delete(record)
     end
 
     def exists?(record)
@@ -61,4 +61,4 @@ module ActiveMocker
       record
     end
   end
-end
+end

data/lib/active_mocker/mock/relation.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
 module ActiveMocker
   class Relation < Collection
     include Queries
 
-    def initialize(collection=[])
+    def initialize(collection = [])
       super
       @from_limit = false
     end
 
     def inspect
       entries     = to_a.take(11).map!(&:inspect)
-      entries[10] = '...' if entries.size == 11
-      "#<#{self.class.name} [#{entries.join(', ')}]>"
+      entries[10] = "..." if entries.size == 11
+      "#<#{self.class.name} [#{entries.join(", ")}]>"
     end
 
     def from_limit?
@@ -22,6 +23,5 @@ module ActiveMocker
     def set_from_limit
       @from_limit = true
     end
-
   end
-end
+end

data/lib/active_mocker/mock/single_relation.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 module ActiveMocker
   class SingleRelation
-
     attr_reader :item
 
     def initialize(item, child_self:, foreign_key:)
@@ -9,7 +9,7 @@ module ActiveMocker
     end
 
     def assign_associations(child_self, item)
-      [*item.class._find_associations_by_class(child_self.class.send('mocked_class'))].each do |type, relations|
+      [*item.class._find_associations_by_class(child_self.class.send("mocked_class"))].each do |_type, relations|
         relations.each do |relation|
           if item.send(relation).class <= Collection
             item.send(relation) << child_self
@@ -19,7 +19,5 @@ module ActiveMocker
         end
       end
     end
-
   end
 end
-

data/lib/active_mocker/mock/template_methods.rb

@@ -1,12 +1,11 @@
+# frozen_string_literal: true
 module ActiveMocker
   module TemplateMethods
-
     def self.included(base)
       base.extend(ClassMethods)
     end
 
     module ClassMethods
-
       def attributes
         HashWithIndifferentAccess.new({})
       end
@@ -24,7 +23,7 @@ module ActiveMocker
       end
 
       def mocked_class
-        ''
+        ""
       end
 
       def attribute_names
@@ -32,9 +31,8 @@ module ActiveMocker
       end
 
       def primary_key
-        ''
+        ""
       end
-
     end
   end
 end

data/lib/active_mocker/mock_creator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveMocker
   class MockCreator
     def initialize(file:,
@@ -8,6 +9,7 @@ module ActiveMocker
                    enabled_partials: nil,
                    klasses_to_be_mocked:,
                    mock_append_name:,
+                   active_record_model:,
                    active_record_base_klass: ActiveRecord::Base)
       @file                     = file
       @file_out                 = file_out
@@ -18,6 +20,7 @@ module ActiveMocker
       @klasses_to_be_mocked     = klasses_to_be_mocked
       @active_record_base_klass = active_record_base_klass
       @mock_append_name         = mock_append_name
+      @active_record_model      = active_record_model
       @errors                   = []
       @completed                = false
     end
@@ -61,14 +64,15 @@ module ActiveMocker
     # -- Defaults -- #
     def template_creator_default(file_out)
       TemplateCreator.new(file_out:     file_out,
-                          erb_template: File.new(File.join(File.dirname(__FILE__), "mock_template.erb"), 'r'),
+                          erb_template: File.new(File.join(File.dirname(__FILE__), "mock_template.erb"), "r"),
                           binding:      binding,
-                          post_process: -> (str) {
-                            ruby_code = DissociatedIntrospection::RubyCode.build_from_source(str, parse_with_comments: true)
+                          post_process: lambda do |str|
+                            ruby_code = DissociatedIntrospection::RubyCode.build_from_source(str,
+                                                                                             parse_with_comments: true)
                             DissociatedIntrospection::WrapInModules.new(ruby_code: ruby_code)
                               .call(modules: nested_modules)
                               .source_from_ast.gsub(/end\n/, "end\n\n")
-                          })
+                          end)
     end
 
     def class_introspector_default
@@ -77,7 +81,15 @@ module ActiveMocker
 
     class << self
       def enabled_partials_default
-        [:modules_constants, :class_methods, :attributes, :scopes, :defined_methods, :associations]
+        [
+          :modules_constants,
+          :class_methods,
+          :attributes,
+          :scopes,
+          :recreate_class_method_calls,
+          :defined_methods,
+          :associations,
+        ]
       end
 
       public :enabled_partials_default
@@ -99,11 +111,18 @@ 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"))
-          self.extend("ActiveMocker::MockCreator::#{p.to_s.camelize}".constantize)
-          hash[p] = ERB.new(file.read, nil, '-', "_sub#{p}").result(binding)
+          extend("ActiveMocker::MockCreator::#{p.to_s.camelize}".constantize)
+          hash[p] = ERB.new(file.read, nil, "-", "_sub#{p}").result(binding)
         rescue => e
-          errors << ErrorObject.new(class_name: class_name, original_error: e, type: :generation, level: :error, message: e.message)
-          errors << ErrorObject.new(class_name: class_name, original_error: e, type: :erb, level: :debug, message: "Erb template: #{p} failed.\n#{file.path}")
+          errors << ErrorObject.new(class_name:     class_name,
+                                    original_error: e, type: :generation,
+                                    level:          :error,
+                                    message:        e.message)
+          errors << ErrorObject.new(class_name:     class_name,
+                                    original_error: e,
+                                    type:           :erb,
+                                    level:          :debug,
+                                    message:        "Erb template: #{p} failed.\n#{file.path}")
           raise e
         end
       end)
@@ -119,12 +138,10 @@ module ActiveMocker
       end
     end
 
-    def parent_class
-      @parent_class
-    end
+    attr_reader :parent_class, :active_record_model
 
     def primary_key
-      @primary_key ||= ActiveRecordSchemaScrapper::Attribute.new(name: 'id', type: :integer)
+      @primary_key ||= ActiveRecordSchemaScrapper::Attribute.new(name: "id", type: :integer)
     end
 
     module ModulesConstants
@@ -139,7 +156,7 @@ module ActiveMocker
         @modules ||= begin
           {
             included: get_module_by_reference(:included_modules),
-            extended: get_module_by_reference(:extended_modules)
+            extended: get_module_by_reference(:extended_modules),
           }
         end
       end
@@ -147,7 +164,28 @@ module ActiveMocker
       private
 
       def get_module_by_reference(type)
-        reject_local_const(class_introspector.public_send(type)).map(&:referenced_name)
+        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)
@@ -161,9 +199,7 @@ module ActiveMocker
       def attributes
         @attribute ||= begin
           a = schema_scrapper.attributes.to_a
-          unless a.any? { |aa| aa.name == "id" }
-            a << primary_key
-          end
+          a << primary_key unless a.any? { |aa| aa.name == "id" }
           a
         end
       end
@@ -180,7 +216,7 @@ module ActiveMocker
 
       def types_hash
         attributes.each_with_object(HashNewStyle.new) do |attr, types|
-          types[attr.name] = "#{attr.type}"
+          types[attr.name] = attr.type.to_s
         end.inspect
       end
 
@@ -199,7 +235,7 @@ module ActiveMocker
       end
 
       def attribute_names
-        attributes.map { |a| a.name }
+        attributes.map(&:name)
       end
 
       def abstract_class
@@ -226,8 +262,26 @@ module ActiveMocker
       end
     end
 
-    module DefinedMethods
+    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
         class_introspector
           .get_class
@@ -247,7 +301,9 @@ module ActiveMocker
       private
 
       def create_method(m, type)
-        Method.new(m, ReverseParameters.new(class_introspector.get_class.send(type, m).parameters, blocks_as_values: true))
+        Method.new(m,
+                   ReverseParameters.new(class_introspector.get_class.send(type, m).parameters,
+                                         blocks_as_values: true))
       end
     end