active_mocker 2.0.0.pre1 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8936b1f4fe07483ea78ff2ec8268d9ffb583b6c7
-  data.tar.gz: 18b528c86620ba5988e94acb77a666e1cd4ad601
+  metadata.gz: be84f88aee5f849ac41ade637327ab87376e48ef
+  data.tar.gz: 3bbf50a5b83647f3f84aea50b623d5a18e7b071d
 SHA512:
-  metadata.gz: 494897b8098ec22bf7e35871b0b5dd993823203c66d2fa373d61025000010a47041c79e2240e03b939561c03f7c337bf3a8ae2577d52dba9640dc690523a1982
-  data.tar.gz: 9ea5b695ac94d7c02d5b791992c7ffaea6d0e8bbfd06f053d11befa2f8dc704d97e42e4d0220480a4e442a3dabc9d493d1861be0a021530e73100d1d2e1f3bb0
+  metadata.gz: 2cf704f658296af715b9ff4a7f94d76639a2cb87476a4fea8eb55f33a34380919c84bd00823b5f553ab1701d3420c4853eedfce73c755296d210bbb3e452b466
+  data.tar.gz: d526baf349a850d6a0914a51b88ef7026a4f6ded6c7247c4fbdf661aa6d37da1cd7532362feee937a086bfc6fe6847246b69b7edc1a3234ea723c7fc2b8bcf3f

data/CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to this project will be documented in this file.
 ## 2.0.0.pre1 - 2015-12-13
 ### Enhancement
 - The mock append name is now changeable using `ActiveMocker::Config.mock_append_name=`. The default still being `Mock`.
-- `ActiveMocker::Mock::MockRelation(mock, collection)` to create separate independent mock collections.
+- `ActiveMocker::MockRelation(mock, collection)` to create separate independent mock collections.
 - Change `ActiveMocker::Mock::Base` to `ActiveMocker::Base`
 - Provide more control over error when running `rake active_mocker:build`, error_verbosity now has setting for 0 to 3.
 

data/README.md

@@ -357,6 +357,7 @@ See [Documentation](http://rdoc.info/github/zeisler/active_mocker/master/ActiveM
 * Sql queries, joins, etc will never be supported.
 * A record that has been created and then is modified will persist changes without calling `#save`, beware of this difference.
 * This is not a full replacement for ActiveRecord. It's simplified, with only the most essential parts. There are many tests to verify that is works the same as ActiveRecord, but's yours responsibility to know how ActiveRecord works.
+* Primary key will always default to `id`. If this is an causes a problem open an issue. 
 
 ## Inspiration
 Thanks to Jeff Olfert for being my original inspiration for this project.

data/lib/active_mocker.rb

@@ -1,5 +1,13 @@
-require "rubygems"
+#                   _   _           __  __            _
+#         /\       | | (_)         |  \/  |          | |
+#        /  \   ___| |_ ___   _____| \  / | ___   ___| | _____ _ __
+#       / /\ \ / __| __| \ \ / / _ \ |\/| |/ _ \ / __| |/ / _ \ '__|
+#      / ____ \ (__| |_| |\ V /  __/ |  | | (_) | (__|   <  __/ |
+#     /_/    \_\___|\__|_| \_/ \___|_|  |_|\___/ \___|_|\_\___|_|
+#
+#     By Dustin Zeisler
 
+require "rubygems"
 require 'active_mocker/version'
 require 'active_mocker/railtie' if defined?(Rails)
 require 'ruby-progressbar'
@@ -11,6 +19,7 @@ require "reverse_parameters"
 require "active_record_schema_scrapper"
 require "dissociated_introspection"
 require "colorize"
+require "active_mocker/hash_new_style"
 require "active_mocker/null_progress"
 require "active_mocker/progress"
 require "active_mocker/parent_class"

data/lib/active_mocker/display_errors.rb

@@ -1,12 +1,14 @@
 module ActiveMocker
   class DisplayErrors
-    attr_reader :errors, :model_count
-    attr_accessor :success_count
+    attr_reader :errors, :model_count, :out
+    attr_accessor :success_count, :failed_models
 
-    def initialize(model_count)
+    def initialize(model_count, out: STDERR)
       @errors        = []
       @success_count = 0
       @model_count   = model_count
+      @failed_models = []
+      @out           = out
     end
 
     def add(errors)
@@ -27,24 +29,26 @@ module ActiveMocker
 
     def display_errors
       uniq_errors.each do |e|
+        next if e.level == :debug unless ENV["DEBUG"]
         if ActiveMocker::Config.error_verbosity == 3
-          STDERR.puts "#{e.class_name} has the following errors:"
-          STDERR.puts e.message.colorize(e.level_color)
-          STDERR.puts e.level
-          STDERR.puts e.original_error.message.colorize(e.level_color) if e.original_error?
-          STDERR.puts e.original_error.backtrace if e.original_error?
-          STDERR.puts e.original_error.class.name.colorize(e.level_color) if e.original_error?
+          out.puts "#{e.class_name} has the following errors:"
+          out.puts e.message.colorize(e.level_color)
+          out.puts e.level
+          out.puts e.original_error.message.colorize(e.level_color) if e.original_error?
+          out.puts e.original_error.backtrace if e.original_error?
+          out.puts e.original_error.class.name.colorize(e.level_color) if e.original_error?
         elsif ActiveMocker::Config.error_verbosity == 2
-          STDERR.puts e.message.colorize(e.level_color)
+          out.puts "#{e.class_name} has the following errors:"
+          out.puts e.message.colorize(e.level_color)
         end
       end
       if ActiveMocker::Config.error_verbosity > 0 && uniq_errors.count > 0
-        STDERR.puts "Error Summary"
+        out.puts "Error Summary"
         error_summary
       end
       failure_count_message
       if ActiveMocker::Config.error_verbosity > 0 && uniq_errors.count > 0
-        STDERR.puts "To see more/less detail set error_verbosity = 0, 1, 2, 3"
+        out.puts "To see more/less detail set error_verbosity = 0, 1, 2, 3"
       end
     end
 
@@ -52,13 +56,14 @@ module ActiveMocker
       error_count = uniq_errors.count { |e| [:red].include?(e.level_color) }
       warn        = uniq_errors.count { |e| [:yellow].include?(e.level_color) }
       info        = uniq_errors.count { |e| [:default].include?(e.level_color) }
-      STDERR.puts "errors: #{error_count}, warn: #{warn}, info: #{info}"
+      out.puts "errors: #{error_count}, warn: #{warn}, info: #{info}"
+      out.puts "Failed models: #{failed_models.join(", ")}" if failed_models.count > 0
     end
 
     def failure_count_message
       if ActiveMocker::Config.error_verbosity > 0 && (success_count < model_count || uniq_errors.count > 0)
-        STDERR.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
-end
+end

data/lib/active_mocker/error_object.rb

@@ -29,7 +29,7 @@ module ActiveMocker
     end
 
     def original_error?
-      original_error.present?
+      !original_error.nil?
     end
 
     def level_color
@@ -43,4 +43,4 @@ module ActiveMocker
       end
     end
   end
-end
+end

data/lib/active_mocker/generate.rb

@@ -19,9 +19,9 @@ module ActiveMocker
         schema_scrapper = ActiveRecordSchemaScrapper.new(model: model)
         File.open(mock_file_path, 'w') do |file_out|
           begin
-            result = create_mock(file, file_out, schema_scrapper)
-            collect_errors(mock_file_path, result.errors, schema_scrapper, model_name)
-            display_errors.success_count += 1 if result.completed?
+            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
@@ -51,16 +51,22 @@ module ActiveMocker
                       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)
-      unless create_mock_errors.empty?
+      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)
       end
-      display_errors.wrap_errors(schema_scrapper.associations.errors, model_name, type: :associations)
-      display_errors.wrap_errors(schema_scrapper.attributes.errors, model_name, type: :attributes)
     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)

data/lib/active_mocker/hash_new_style.rb

@@ -0,0 +1,7 @@
+module ActiveMocker
+  class HashNewStyle < Hash
+    def inspect
+      '{ ' + self.map { |name, type| "#{name}: #{type}" }.join(', ') + ' }'
+    end
+  end
+end

data/lib/active_mocker/mock_creator.rb

@@ -25,7 +25,11 @@ module ActiveMocker
     def create
       verify_class
       if errors.empty?
-        template_creator.render
+        begin
+          template_creator.render
+        rescue => e
+          raise e unless error_already_collected?(e)
+        end
         file_out.close
         @completed = true
       end
@@ -50,8 +54,11 @@ module ActiveMocker
                 :active_record_base_klass,
                 :mock_append_name
 
+    def error_already_collected?(e)
+      errors.any? { |eo| eo.original_error == e }
+    end
+
     # -- Defaults -- #
-    private
     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'),
@@ -89,7 +96,8 @@ module ActiveMocker
           self.extend("ActiveMocker::MockCreator::#{p.to_s.camelize}".constantize)
           hash[p] = ERB.new(file.read, nil, '-', "_sub#{p}").result(binding)
         rescue => e
-          print "#{file.inspect}"
+          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)
@@ -109,27 +117,27 @@ module ActiveMocker
 
     module ModulesConstants
       def constants
-        const = {}
-        class_introspector.get_class.constants.each { |c| const[c] = class_introspector.get_class.const_get(c) }
-        const = const.reject do |c, v|
-          v.class == Module || v.class == Class
+        class_introspector.get_class.constants.each_with_object({}) do |v, const|
+          c        = class_introspector.get_class.const_get(v)
+          const[v] = c unless c.class == Module || c.class == Class
         end
-        const
       end
 
       def modules
         @modules ||= begin
           {
-            included: reject_local_const(class_introspector.included_modules)
-                        .map(&:referenced_name),
-            extended: reject_local_const(class_introspector.extended_modules)
-                        .map(&:referenced_name)
+            included: get_module_by_reference(:included_modules),
+            extended: get_module_by_reference(:extended_modules)
           }
         end
       end
 
       private
 
+      def get_module_by_reference(type)
+        reject_local_const(class_introspector.public_send(type)).map(&:referenced_name)
+      end
+
       def reject_local_const(source)
         source.reject do |n|
           class_introspector.locally_defined_constants.values.include?(n)
@@ -153,23 +161,15 @@ module ActiveMocker
       include Attributes
 
       def attributes_with_defaults
-        hash = {}
-        attributes.each do |attr|
+        attributes.each_with_object({}) do |attr, hash|
           hash[attr.name] = Virtus::Attribute.build(attr.type).coerce(attr.default)
         end
-        hash
       end
 
       def types_hash
-        types = {}
-        attributes.each do |attr|
+        attributes.each_with_object(HashNewStyle.new) do |attr, types|
           types[attr.name] = "#{attr.type}"
-        end
-
-        type_array = types.map do |name, type|
-          "#{name}: #{type}"
-        end
-        '{ ' + type_array.join(', ') + ' }'
+        end.inspect
       end
 
       def associations
@@ -199,54 +199,55 @@ module ActiveMocker
       end
     end
 
+    Method = Struct.new(:name, :arguments)
+
     module Scopes
       def scope_methods
         class_introspector.class_macros.select { |h| h.keys.first == :scope }.map do |h|
           a = h.values.first.first
-          OpenStruct.new(name: a[0], arguments: ReverseParameters.new(a[1]))
+          Method.new(a[0], ReverseParameters.new(a[1]))
         end
       end
     end
 
     module DefinedMethods
-      def get_instance_methods
-        methods = class_introspector.get_class.public_instance_methods(false)
-        methods << class_introspector.get_class.superclass.public_instance_methods(false) if class_introspector.get_class.superclass != ActiveRecord::Base
-        methods.flatten
-      end
 
       def instance_methods
-        get_instance_methods.map do |m|
-          OpenStruct.new(name: m, arguments: ReverseParameters.new(class_introspector.get_class.instance_method(m).parameters))
-        end
+        class_introspector
+          .get_class
+          .public_instance_methods(false)
+          .map { |m| create_method(m, :instance_method) }
       end
 
-      def get_class_methods
-        class_introspector.get_class.methods(false)
+      def class_methods
+        class_introspector
+          .get_class
+          .methods(false)
+          .map { |m| create_method(m, :method) }
       end
 
-      def class_methods
-        get_class_methods.map do |m|
-          OpenStruct.new(name: m, arguments: ReverseParameters.new(class_introspector.get_class.method(m).parameters))
-        end
+      private
+
+      def create_method(m, type)
+        Method.new(m, ReverseParameters.new(class_introspector.get_class.send(type, m).parameters))
       end
     end
 
     module Associations
       def has_many
-        association_collection.select { |a| a.type == :has_many }
+        relation_find(:type, __method__)
       end
 
       def has_one
-        association_collection.select { |a| a.type == :has_one }
+        relation_find(:type, __method__)
       end
 
       def belongs_to
-        association_collection.select { |a| a.type == :belongs_to }
+        relation_find(:type, __method__)
       end
 
       def has_and_belongs_to_many
-        association_collection.select { |a| a.type == :has_and_belongs_to_many }
+        relation_find(:type, __method__)
       end
 
       def relation_find(key, value)
@@ -258,4 +259,4 @@ module ActiveMocker
       end
     end
   end
-end
+end

data/lib/active_mocker/version.rb

@@ -1,3 +1,3 @@
 module ActiveMocker
-  VERSION = "2.0.0.pre1"
+  VERSION = "2.0.0.rc1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_mocker
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre1
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-14 00:00:00.000000000 Z
+date: 2015-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -176,6 +176,7 @@ files:
 - lib/active_mocker/display_errors.rb
 - lib/active_mocker/error_object.rb
 - lib/active_mocker/generate.rb
+- lib/active_mocker/hash_new_style.rb
 - lib/active_mocker/loaded_mocks.rb
 - lib/active_mocker/mock.rb
 - lib/active_mocker/mock/association.rb