active_mocker 2.5.4 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee07a0c316a8e30d793536c32edcb6ffc1ff0d3a
-  data.tar.gz: 2c7938f5ea726a3ddb388e6b65547df17bc5ce2f
+  metadata.gz: 9486fcafe8737ffaf943ef442d155de53152ac51
+  data.tar.gz: 1b70a0a54a57e9b093b9a010580403baa015ff0f
 SHA512:
-  metadata.gz: 2909eac242da2763b902c05af8e462e49ee256640cc791716a76bde87d56dc7c2d3e2fb750996d77de865ec4bc0eb2d20d34bdd1c2e0cf343ebdb1f6d9231d71
-  data.tar.gz: 59177e2d5513705962e95ba9c0784c5436299b38736cb3a660bd58d8e265a03d77a5d84e792d78a285d44d229cebdb3c91ad5f052bf755fbae58989450ba6f16
+  metadata.gz: b5fee7877de2d5f3c1fa342430a0607ea27d7fcb7936b74d2db2a5e9b6f6958f99c901477648968c3cebfc372cf4370fb6c266b68e8f748e790da114676ce745
+  data.tar.gz: 4dd3a0f9b59357d078e603457c34a3379f8b9548edb98e22b2dda6644742b848129e2bcb0a447f82223df4d54d13ea416979ab6cb250edba8a5382d144941112

data/CHANGELOG.md

@@ -1,6 +1,41 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 2.6.0 - 2017-12-01
+### Feature
+- Relation#order now accepts all non-SQL arguments
+
+Example usage:
+```ruby
+  User.order('name')
+
+  User.order(:name)
+
+  User.order(email: :desc)
+
+  User.order(:name, email: :desc)
+  
+  User.order(name: :desc, email: :asc)
+```
+
+### Enhancement
+- Improved output for `rake active_mocker:build`. When all mocks built successfully the messaging could be misleading. 
+- Error message for calling stubbed methods better formats RSpec syntax for variable names.
+- Now whitelist all locally defined methods as safe to copy/run within mock 
+```ruby
+# ActiveMocker.all_methods_safe
+class User < ActiveRecord::Base
+end
+```
+
+OR blacklist methods from being safe.
+
+```ruby
+# ActiveMocker.all_methods_safe except: { instance_methods: [], class_methods: [], scopes: [] }
+class User < ActiveRecord::Base
+end
+```
+
 ## 2.5.4 - 2017-11-17
 ### Fix
 - has_and_belongs_to_many association did not contain scoped methods.

data/lib/active_mocker/display_errors.rb

@@ -44,19 +44,22 @@ module ActiveMocker
     end
 
     def error_summary
-      display "Error Summary"
       display "errors: #{error_count}, warn: #{warn}, info: #{info}"
       display "Failed models: #{failed_models.join(", ")}" if failed_models.count > 0
     end
 
-    def failure_count_message
+    def number_models_mocked
       if success_count < model_count || any_errors?
-        display "#{model_count - success_count} mock(s) out of #{model_count} failed."
+        display "Mocked #{success_count} ActiveRecord #{plural("Model", success_count)} out of #{model_count} #{plural("file", model_count)}."
       end
     end
 
     private
 
+    def plural(string, count, plural="s")
+      count > 1 || count.zero? ? "#{string}#{plural}" : string
+    end
+
     def display(msg)
       out.puts(msg)
     end
@@ -95,10 +98,10 @@ module ActiveMocker
 
       error_summary if any_errors?
 
-      failure_count_message
+      number_models_mocked
 
       return unless any_errors?
-      display "To see more/less detail set error_verbosity = 0, 1, 2, 3"
+      display "To see more/less detail set ERROR_VERBOSITY = 0, 1, 2, 3"
     end
 
     def error_count

data/lib/active_mocker/mock/mockable_method.rb

@@ -10,7 +10,7 @@ module ActiveMocker
                                             ["#{klass}_relation", klass.camelize, :scopes]
                                           elsif type == "#"
                                             klass = self.class.name
-                                            ["#{klass.underscore}_record", klass, :instance_methods]
+                                            ["#{klass.underscore.split("/").first}_record", klass, :instance_methods]
                                           else
                                             [name, name, :class_methods]
                                           end

data/lib/active_mocker/mock/queries.rb

@@ -311,8 +311,50 @@ module ActiveMocker
     #   User.order('name')
     #
     #   User.order(:name)
-    def order(key)
-      __new_relation__(all.sort_by { |item| item.send(key) })
+    #
+    #   User.order(email: :desc)
+    #
+    #   User.order(:name, email: :desc)
+    def order(*args)
+      options = args.extract_options!
+      if options.empty? && args.count == 1
+        __new_relation__(all.sort_by { |item| item.send(args.first) })
+      else
+        __new_relation__(Sort.order_mixed_args(all, args, options))
+      end
+    end
+
+    module Sort
+      class DESC
+        attr_reader :r
+
+        def initialize(r)
+          @r = r
+        end
+
+        def <=>(other)
+          -(r <=> other.r) # Flip negative/positive result
+        end
+      end
+
+      class << self
+        def desc(r)
+          DESC.new(r)
+        end
+
+        def asc(r)
+          r
+        end
+
+        def order_mixed_args(all, args, options)
+          options.merge!(args.each_with_object({}) { |a, h| h[a] = :asc }) # Add non specified direction keys
+          all.sort { |a, b| build_order(a, options) <=> build_order(b, options) }
+        end
+
+        def build_order(a, options)
+          options.map { |k, v| send(v, a.send(k)) }
+        end
+      end
     end
 
     # Reverse the existing order clause on the relation.

data/lib/active_mocker/mock_creator/defined_methods.rb

@@ -24,7 +24,7 @@ module ActiveMocker
 
       def create_method(m, type)
         plural_type = (type.to_s + "s").to_sym
-        if safe_methods[plural_type].include?(m)
+        if safe_method?(type, m)
           def_type   = type == :method ? :class_defs : :defs
           def_method = class_introspector.parsed_source.public_send(def_type).detect { |meth| meth.name == m }
           raise "ActiveMocker.safe_methods is unable to find #{plural_type}: #{m}" unless def_method

data/lib/active_mocker/mock_creator/safe_methods.rb

@@ -2,11 +2,23 @@
 module ActiveMocker
   class MockCreator
     module SafeMethods
-      BASE = { instance_methods: [], scopes: [], methods: [] }.freeze
+      BASE = { instance_methods: [], scopes: [], methods: [], all_methods_safe: false }.freeze
+
+      def safe_method?(type, name)
+        plural_type      = (type.to_s + "s").to_sym
+        all_methods_safe = all_methods_safe?(type, name)
+        return true if all_methods_safe
+        return true if safe_methods[plural_type].include?(name)
+        false
+      end
+
+      private
 
       def safe_methods
         @safe_methods ||= class_introspector.parsed_source.comments.each_with_object(BASE.dup) do |comment, hash|
-          if comment.text.include?("ActiveMocker.safe_methods")
+          if comment.text.include?("ActiveMocker.all_methods_safe")
+            hash[:all_methods_safe] = ActiveMocker.module_eval(comment.text.delete("#"))
+          elsif comment.text.include?("ActiveMocker.safe_methods")
             hash.merge!(ActiveMocker.module_eval(comment.text.delete("#")))
           else
             hash
@@ -14,9 +26,38 @@ module ActiveMocker
         end
       end
 
+      def all_methods_safe?(type, name)
+        plural_type      = (type.to_s + "s").to_sym
+        all_methods_safe = safe_methods.fetch(:all_methods_safe)
+        if all_methods_safe.is_a?(Hash)
+          !all_methods_safe.fetch(plural_type).include?(name)
+        else
+          all_methods_safe
+        end
+      end
+
       module ActiveMocker
-        def self.safe_methods(*arg_methods, scopes: [], instance_methods: [], class_methods: [])
-          { instance_methods: arg_methods.concat(instance_methods), scopes: scopes, methods: class_methods }
+        class << self
+          def safe_methods(*arg_methods, scopes: [], instance_methods: [], class_methods: [], all_methods_safe: false)
+            {
+              instance_methods: arg_methods.concat(instance_methods),
+              scopes:           scopes,
+              methods:          class_methods,
+              all_methods_safe: all_methods_safe,
+            }
+          end
+
+          def all_methods_safe(except: {})
+            other_keys = except.except(:instance_methods, :scopes, :class_methods)
+            unless other_keys.empty?
+              raise ArgumentError, "ActiveMocker.all_methods_safe arguments must only be `except: { instance_methods: [], scopes: [], class_methods: [] }`"
+            end
+            {
+              instance_methods: except.fetch(:instance_methods, []),
+              scopes:           except.fetch(:scopes, []),
+              methods:          except.fetch(:class_methods, []),
+            }
+          end
         end
       end
     end

data/lib/active_mocker/mock_creator/scopes.rb

@@ -15,8 +15,8 @@ module ActiveMocker
         end
       end
 
-      def scope_body(arguments, name)
-        if safe_methods[:scopes].include?(name)
+      def scope_body(_arguments, name)
+        if safe_method?(:scope, name)
           find_scope_body_from_ast(name)
         else
           <<-METHOD

data/lib/active_mocker/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module ActiveMocker
-  VERSION = "2.5.4"
+  VERSION = "2.6.0"
   module Mock
     VERSION = "2" # This increments when breaking changes happen in the generated mocks
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_mocker
 version: !ruby/object:Gem::Version
-  version: 2.5.4
+  version: 2.6.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-17 00:00:00.000000000 Z
+date: 2017-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport