active_mocker 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b140042c4be2000d8ff69f0c61498876a2d2b4e5
-  data.tar.gz: 70ea49b50c9ccdb1faf340b2392a3c3a65ecff75
+  metadata.gz: 05720b7a53a8a8d14dacf57d5ba1d92be772ff13
+  data.tar.gz: 9a2db70acca737f482b0b0d73ab13cf2c7e49595
 SHA512:
-  metadata.gz: 3eac64b9a66fa2a107221e59a7ba2285e273f29bd90b5df6d358669e514ea0ed2b0631d4402dc575c8ced6098b0f70f8abdc390b3c708b97f3beb50b37f4aa77
-  data.tar.gz: 6bda4b0492259a07978df406f431e1f39017d6440c12da700a513263eadc1c31428df3f8a8b63c4892cc06c207ccc1b7299e03484ea0db7b3baaecaa893040d6
+  metadata.gz: 0296c4a1536fd52d860b604877191ba75102221095546685dfdef441860f361a6b71352b7f74eb21a5dd487d33913575363986e8f9b8caa469a78a80f43f6126
+  data.tar.gz: 478ec70d8c0fa0cb8d439ab86ab9f6920f0b098b40a1887435cbf96bb1082b04a5d76f2654fa3b10ae336523f46dc75ce1720811d65c8f9b65c3123c9eb2cd8d

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 2.2.0 - 2016-05-03
+### Feature 
+- Add `ActiveMocker::Mock#slice`
+- Import alias_attribute usage to mock  - With supporting methods `attribute_alias?(name)` and `attribute_alias(name)`
+
+### Fix
+- When an include/extended module is not locally defined, but defined in the same namespace as the mock it was not correctly namespaced
+- Fix issue NoMethodError in Rails 5.beta when introspection activerecord model.
+
+## Enhancement
+-  Ignore all non ActiveRecord::Base subclasses
+- Make rake dependency less strict `>= 10.0`
+
 ## 2.1.3 - 2016-03-21
 ### Fix
 - Issue where namespaced mocks would not be auto stubbed. 

data/README.md

@@ -288,6 +288,8 @@ See [Documentation](http://rdoc.info/github/zeisler/active_mocker/master/ActiveM
   * column_names/attribute_names
   * delete_all/destroy_all
   * table_name
+  * slice
+  * alias_attributes
   
 **Query Methods** - [docs](http://rdoc.info/github/zeisler/active_mocker/master/ActiveMocker/Mock/Queries)
 
@@ -340,6 +342,9 @@ See [Documentation](http://rdoc.info/github/zeisler/active_mocker/master/ActiveM
   * attribute_names
   * attribute_present?
   * has_attribute?
+  * slice
+  * attribute_alias?
+  * alias_attributes
 
 **has_one/belongs_to/has_many**
 

data/lib/active_mocker.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #                   _   _           __  __            _
 #         /\       | | (_)         |  \/  |          | |
 #        /  \   ___| |_ ___   _____| \  / | ___   ___| | _____ _ __
@@ -8,12 +9,12 @@
 #     By Dustin Zeisler
 
 require "rubygems"
-require 'active_mocker/version'
-require 'active_mocker/railtie' if defined?(Rails)
-require 'forwardable'
-require 'active_support/all'
-require 'active_mocker/public_methods'
-require 'active_mocker/config'
+require "active_mocker/version"
+require "active_mocker/railtie" if defined?(Rails)
+require "forwardable"
+require "active_support/all"
+require "active_mocker/public_methods"
+require "active_mocker/config"
 require "reverse_parameters"
 require "active_record_schema_scrapper"
 require "dissociated_introspection"

data/lib/active_mocker/config.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module ActiveMocker
   class Config
     class << self
-
       attr_accessor :model_dir,
                     :mock_dir,
                     :single_model_path,
@@ -10,9 +10,7 @@ module ActiveMocker
                     :disable_modules_and_constants,
                     :mock_append_name
 
-      def model_base_classes=(val)
-        @model_base_classes = val
-      end
+      attr_writer :model_base_classes
 
       # @see ActiveMocker#configure
       def set
@@ -27,7 +25,7 @@ module ActiveMocker
         @model_dir                     = nil unless @model_dir
         @mock_dir                      = nil unless @mock_dir
         @mock_append_name              = "Mock"
-        rails_defaults if Object.const_defined?('Rails')
+        rails_defaults if Object.const_defined?("Rails")
       end
 
       def reset_all
@@ -37,13 +35,13 @@ module ActiveMocker
          :single_model_path,
          :progress_bar,
          :error_verbosity,
-         :mock_append_name
+         :mock_append_name,
         ].each { |ivar| instance_variable_set("@#{ivar}", nil) }
       end
 
       def rails_defaults
-        @model_dir = File.join(Rails.root, 'app/models') unless @model_dir
-        @mock_dir  = File.join(Rails.root, 'spec/mocks') unless @mock_dir
+        @model_dir = File.join(Rails.root, "app/models") unless @model_dir
+        @mock_dir  = File.join(Rails.root, "spec/mocks") unless @mock_dir
       end
 
       def progress_class

data/lib/active_mocker/deprecated_components/mock_abilities.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
 module ActiveMocker
   # @deprecated to keep using until removal, require this file.
   module MockAbilities
     module InstanceAndClassMethods
-
-      def mock_instance_method(method, exe_bind=false, &block)
+      def mock_instance_method(method, exe_bind = false, &block)
         mockable_instance_methods[method.to_sym] = MockMethod.new(block, exe_bind)
       end
 
-      alias_method :stub_instance_method, :mock_instance_method
+      alias stub_instance_method mock_instance_method
 
       def clear_mocked_methods
         mockable_instance_methods.clear
@@ -39,7 +39,6 @@ module ActiveMocker
         return instance_exec(method.arguments, &method.block) if method.exe_bind
         method.block.call(*method.arguments)
       end
-
     end
 
     def self.included(base)
@@ -53,28 +52,26 @@ module ActiveMocker
     end
 
     module ClassMethods
-
       include InstanceAndClassMethods
 
       def mockable_class_methods
         @mockable_class_methods ||= {}
       end
 
-      def mock_class_method(method, exe_bind=false, &block)
+      def mock_class_method(method, exe_bind = false, &block)
         mockable_class_methods[method.to_sym] = MockMethod.new(block, exe_bind)
       end
 
-      alias_method :stub_class_method, :mock_class_method
+      alias stub_class_method mock_class_method
 
       def call_mock_method(method:, caller:, arguments: [])
         mock_method = mockable_class_methods[method.to_sym]
-        is_implemented(mock_method, method, '::', caller)
+        is_implemented(mock_method, method, "::", caller)
         mock_method.arguments = arguments
         execute_block(mock_method)
       end
 
       private :call_mock_method
-
     end
 
     include InstanceAndClassMethods
@@ -94,7 +91,6 @@ module ActiveMocker
     end
 
     class MockMethod
-
       attr_accessor :block, :arguments, :exe_bind
 
       def initialize(block, exe_bind)

data/lib/active_mocker/deprecated_components/rspec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "active_mocker/rspec"
 
 module ActiveMocker
@@ -9,4 +10,4 @@ module ActiveMocker
       active_mocker.mocks.find(*args)
     end
   end
-end
+end

data/lib/active_mocker/display_errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveMocker
   class DisplayErrors
     attr_reader :errors, :model_count, :out
@@ -29,7 +30,7 @@ module ActiveMocker
 
     def display_errors
       uniq_errors.each do |e|
-        next if e.level == :debug unless ENV["DEBUG"]
+        next unless ENV["DEBUG"] || !(e.level == :debug)
         if ActiveMocker::Config.error_verbosity == 3
           out.puts "#{e.class_name} has the following errors:"
           out.puts e.message.colorize(e.level_color)
@@ -62,7 +63,7 @@ module ActiveMocker
 
     def failure_count_message
       if ActiveMocker::Config.error_verbosity > 0 && (success_count < model_count || uniq_errors.count > 0)
-        out.puts "#{ model_count - success_count } mock(s) out of #{model_count} failed."
+        out.puts "#{model_count - success_count} mock(s) out of #{model_count} failed."
       end
     end
   end

data/lib/active_mocker/error_object.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 module ActiveMocker
   class ErrorObject
-
     attr_reader :message, :level, :original_error, :type, :class_name
 
     def initialize(level: :warn, message:, class_name:, type:, original_error: nil)
@@ -13,17 +13,17 @@ module ActiveMocker
 
     def self.build_from(object: nil, exception: nil, class_name: nil, type: nil)
       if object
-        args              = [:message, :original_error, :level, :type, :class_name].each_with_object({}) do |meth, hash|
+        args = [:message, :original_error, :level, :type, :class_name].each_with_object({}) do |meth, hash|
           hash[meth] = object.public_send(meth) if object.respond_to? meth
         end
         args[:type]       = type unless type.nil?
         args[:class_name] = class_name unless class_name.nil?
-        return self.new(args)
+        return new(args)
       elsif exception && class_name
-        return self.new(message:        exception.message,
-                        class_name:     class_name,
-                        original_error: exception,
-                        type:           type ? type : :standard_error)
+        return new(message:        exception.message,
+                   class_name:     class_name,
+                   original_error: exception,
+                   type:           type ? type : :standard_error)
       end
       raise ArgumentError
     end
@@ -34,12 +34,12 @@ module ActiveMocker
 
     def level_color
       case level
-        when :standard_error, :fatal, :error
-          :red
-        when :warn
-          :yellow
-        when :info
-          :default
+      when :standard_error, :fatal, :error
+        :red
+      when :warn
+        :yellow
+      when :info
+        :default
       end
     end
   end

data/lib/active_mocker/file_path_to_ruby_class.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 module ActiveMocker
   class FilePathToRubyClass
-
     attr_reader :class_path, :base_path
 
     def initialize(base_path:, class_path:)
@@ -9,8 +9,7 @@ module ActiveMocker
     end
 
     def to_s
-      File.basename((class_path.gsub(base_path + "/", "")).split("/").map(&:camelize).join("::"), '.rb')
+      File.basename(class_path.gsub(base_path + "/", "").split("/").map(&:camelize).join("::"), ".rb")
     end
-
   end
 end

data/lib/active_mocker/file_writer.rb

@@ -0,0 +1,125 @@
+module ActiveMocker
+  class FileWriter
+    include Virtus.model
+    delegate :name, to: :model, prefix: true
+
+    attribute :model, Object
+    attribute :file, String
+    attribute :display_errors
+    attribute :config
+    attribute :model_names, Array
+
+    def write!
+      assure_dir_path_exists!
+
+      safe_write { |f| process!(f) }
+    end
+
+    private
+
+    def process!(file_out)
+      result = create_mock(file_out, model)
+      status = collect_errors(result.errors)
+
+      ok = result.completed? && status.successful?
+      return unless ok
+
+      display_errors.success_count += 1
+    end
+
+    def safe_write
+      File.open(mock_file_path, "w") do |file_out|
+        begin
+          yield file_out
+        rescue StandardError => e
+          rescue_clean_up(e, file_out)
+        end
+      end
+    end
+
+    def rescue_clean_up(e, file_out)
+      display_errors.failed_models << model_name
+      file_out.close unless file_out.closed?
+      File.delete(file_out.path) if File.exist?(file_out.path)
+      display_errors.wrap_an_exception(e, model_name)
+    end
+
+    def scrapper
+      @scrapper ||= ActiveRecordSchemaScrapper.new(model: model)
+    end
+
+    def mock_file_path
+      File.join(Config.mock_dir, mock_file_name)
+    end
+
+    def mock_file_name
+      "#{model_name.underscore}_#{config.mock_append_name.underscore}.rb"
+    end
+
+    def assure_dir_path_exists!
+      unless File.exist?(File.dirname(mock_file_path))
+        FileUtils.mkdir_p(File.dirname(mock_file_path))
+      end
+    end
+
+    def create_mock(file_out, model)
+      MockCreator.new(file:                 File.open(file),
+                      file_out:             file_out,
+                      schema_scrapper:      scrapper,
+                      klasses_to_be_mocked: model_names,
+                      enabled_partials:     enabled_partials,
+                      mock_append_name:     config.mock_append_name,
+                      active_record_model:  model).create
+    end
+
+    OtherErrors = Struct.new(:successful?)
+
+    def collect_errors(create_mock_errors)
+      add_errors!
+
+      if create_mock_errors.present? || schema.attribute_errors?
+        display_errors.failed_models << model_name
+        File.delete(mock_file_path) if File.exist?(mock_file_path)
+        display_errors.add(create_mock_errors)
+        OtherErrors.new(false)
+      else
+        OtherErrors.new(true)
+      end
+    end
+
+    def add_errors!
+      add_error(schema.association_errors, :associations)
+      add_error(schema.attribute_errors, :attributes)
+    end
+
+    def add_error(error, type)
+      display_errors.wrap_errors(error, model_name, type: type)
+    end
+
+    def enabled_partials
+      if config.disable_modules_and_constants
+        MockCreator.enabled_partials_default - [*:modules_constants]
+      else
+        MockCreator.enabled_partials_default
+      end
+    end
+
+    def schema
+      @schema ||= Schema.new(ActiveRecordSchemaScrapper.new(model: model))
+    end
+
+    class Schema < SimpleDelegator
+      def attribute_errors?
+        attribute_errors.any? { |e| e.level == :error }
+      end
+
+      def association_errors
+        associations.errors
+      end
+
+      def attribute_errors
+        attributes.errors
+      end
+    end
+  end
+end

data/lib/active_mocker/generate.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+require_relative "file_writer"
+
 module ActiveMocker
   class Generate
-
     def initialize
-      raise ArgumentError, "mock_dir is missing a valued value!" if config.mock_dir.nil? || config.mock_dir.empty?
+      check_directory!(:mock_dir)
       create_mock_dir
-      raise ArgumentError, "model_dir is missing a valued value!" if config.model_dir.nil? || config.model_dir.empty? || !Dir.exists?(config.model_dir)
+      check_directory!(:model_dir)
+      raise_missing_arg(:model_dir) unless Dir.exist?(config.model_dir)
+
       @display_errors = DisplayErrors.new(models_paths.count)
     end
 
@@ -12,92 +16,81 @@ module ActiveMocker
     def call
       clean_up
       progress_init
-      models_paths.each do |file|
-        model_name      = model_name(file)
-        model           = get_model_const(model_name)
-        mock_file_name  = "#{model_name.underscore}_#{config.mock_append_name.underscore}.rb"
-        mock_file_path  = File.join(Config.mock_dir, mock_file_name)
-        assure_dir_path_exists(mock_file_path)
-        schema_scrapper = ActiveRecordSchemaScrapper.new(model: model)
-        File.open(mock_file_path, 'w') do |file_out|
-          begin
-            result                       = create_mock(file, file_out, schema_scrapper)
-            status                       = collect_errors(mock_file_path, result.errors, schema_scrapper, model_name)
-            display_errors.success_count += 1 if result.completed? && status.successful?
-          rescue => e
-            rescue_clean_up(e, file_out, model_name)
-          end
-        end
+
+      active_record_models_with_files.each do |model, file|
+        write_file(model, file)
+
         progress.increment
       end
+
       display_errors.display_errors
       self
     end
 
-    def get_model_const(model_name)
-      model_name.constantize
-    rescue StandardError, LoadError => e
-      display_errors.wrap_an_exception(e, model_name)
+    def active_record_models
+      @active_record_models ||= active_record_models_with_files.map(&:first)
     end
 
     private
 
-    attr_reader :display_errors
-
-    def create_mock(file, file_out, schema_scrapper)
-      MockCreator.new(file:                 File.open(file),
-                      file_out:             file_out,
-                      schema_scrapper:      schema_scrapper,
-                      klasses_to_be_mocked: model_names,
-                      enabled_partials:     enabled_partials,
-                      mock_append_name:     config.mock_append_name).create
-    end
-
-    OtherErrors = Struct.new(:successful?)
-    def collect_errors(mock_file_path, create_mock_errors, schema_scrapper, model_name)
-      display_errors.wrap_errors(schema_scrapper.associations.errors, model_name, type: :associations)
-      display_errors.wrap_errors(schema_scrapper.attributes.errors, model_name, type: :attributes)
-      if create_mock_errors.present? || schema_scrapper.attributes.errors.any? { |e| e.level == :error }
-        display_errors.failed_models << model_name
-        File.delete(mock_file_path) if File.exists?(mock_file_path)
-        display_errors.add(create_mock_errors)
-        OtherErrors.new(false)
-      else
-        OtherErrors.new(true)
+    attr_reader :display_errors, :progress
+
+    def check_directory!(type)
+      value = config.send(type)
+
+      if value.nil? || value.empty?
+        raise_missing_arg(type)
       end
     end
 
-    def rescue_clean_up(e, file_out, model_name)
-      display_errors.failed_models << model_name
-      file_out.close unless file_out.closed?
-      File.delete(file_out.path) if File.exists?(file_out.path)
-      display_errors.wrap_an_exception(e, model_name)
+    def raise_missing_arg(type)
+      raise ArgumentError, "#{type} is missing a valued value!"
     end
 
-    def model_name(file)
-      FilePathToRubyClass.new(base_path: config.model_dir, class_path: file).to_s
+    def write_file(model, file)
+      writer = FileWriter.new(
+        model: model,
+        file: file,
+        display_errors: display_errors,
+        config: config,
+        model_names: model_names)
+
+      writer.write!
     end
 
-    def model_names
-      @model_names ||= models_paths.map { |p| model_name(p) }
+    def progress_init
+      @progress = config.progress_class.create(active_record_models.count)
     end
 
-    def progress
-      @progress
+    def model_names
+      @model_names ||= active_record_models.map(&:name)
     end
 
-    def progress_init
-      @progress = config.progress_class.create(models_paths.count)
+    def active_record_models_with_files
+      @active_record_models_with_files ||= models_paths.map do |file|
+        model = constant_from(model_name_from(file))
+        [model, file] if model
+      end.compact
     end
 
     def models_paths
       @models_paths ||= Dir.glob(config.single_model_path || File.join(config.model_dir, "**/*.rb"))
     end
 
-    def assure_dir_path_exists(file)
-      unless File.exists?(File.dirname(file))
-        FileUtils::mkdir_p(File.dirname(file))
-      end
+    def constant_from(model_name)
+      constant = model_name.constantize
+      return unless constant.ancestors.include?(ActiveRecord::Base)
+      constant
+    rescue NameError, LoadError => e
+      display_errors.wrap_an_exception(e, model_name)
+      nil
+    end
+
+    def model_name_from(file)
+      FilePathToRubyClass.new(
+        base_path: config.model_dir,
+        class_path: file
+      ).to_s
     end
 
     def config
@@ -105,15 +98,7 @@ module ActiveMocker
     end
 
     def create_mock_dir
-      FileUtils::mkdir_p(config.mock_dir) unless Dir.exists?(config.mock_dir)
-    end
-
-    def enabled_partials
-      if config.disable_modules_and_constants
-        MockCreator.enabled_partials_default - [*:modules_constants]
-      else
-        MockCreator.enabled_partials_default
-      end
+      FileUtils.mkdir_p(config.mock_dir) unless Dir.exist?(config.mock_dir)
     end
 
     def clean_up