active_mocker 1.8.3 → 1.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae00f4e9e6d46b5a085a6d536cf47b3947417f2b
-  data.tar.gz: 24c2eb0336c786d222f9518b3f70b6a5e40c1e7f
+  metadata.gz: ae228af179be61ae85b6dcacebff1adbad0c2de3
+  data.tar.gz: d4b1cc0d7d6209bbe2ca6210534e54348746d7ef
 SHA512:
-  metadata.gz: 47d4cdc06da8d6c3696ed5a454681367138532f1bb7101b38573849f311adbcec439b7bc046f7dd599a03cbf3e792af545ade199c2bea33467048c141e125466
-  data.tar.gz: ae43867bd1997997f98bc607046ca7a3042d97a9950b64e27f3f64a9e7bcbcdebce7ae2faa4fb66f4c7b3efa3ca90008725b99c68ae311be44648438370f1ba9
+  metadata.gz: b68c2749a6ec8ef1c1617345bca88413cc22ca5f2ff4b7feadd9120d38a2dea9839fc6fc1352b336d966d93119b67b3e330d1b7d2f5dc1092bd16cf5f5e26628
+  data.tar.gz: 01f7f45c33a3ec713045d38114653bf5a345b27836ff9ed3ced1a222528e3d50e0cbaf5289ea426097eda7209bee880d11db22c34bc87d164f7cc45b6d57335e

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 1.8.4 - 2015-10-06
+### Fix
+- Calling scoped method that has not been stubbed raises incorrect error. https://github.com/zeisler/active_mocker/issues/22
+- Not closing file stream while writing mocks. https://github.com/zeisler/active_mocker/pull/29
+
 ## 1.8.3 - 2015-03-03
 ### Fix
 - When AR model ended in 's' it would result in failing to create the mock file.

data/README.md

@@ -5,13 +5,15 @@
 [![Dependency Status](https://gemnasium.com/zeisler/active_mocker.svg)](https://gemnasium.com/zeisler/active_mocker)
 [![Gitter chat](https://badges.gitter.im/zeisler/active_mocker.png)](https://gitter.im/zeisler/active_mocker)
 
-ActiveMocker creates mocks classes from ActiveRecord models. Allowing your test suite to run very fast by not loading Rails a database. It parses the schema.rb and the defined methods on a model then generates a ruby file that can be included within a test. The mock file can be run by themselves and come with a partial implementation of ActiveRecord. Attributes and associations can be used just the same as in ActiveRecord. Methods will have the correct arguments but raise an NotImplementedError when called. Mocks are regenerated when the schema is modified so your mocks will not go stale; preventing the case where your units tests pass but production code fails.
+ActiveMocker creates mocks classes from ActiveRecord models. Allowing your test suite to run very fast by not loading Rails or a database. It parses the schema.rb and the defined methods on a model then generates a ruby file that can be included within a test. The mock file can be run by themselves and come with a partial implementation of ActiveRecord. Attributes and associations can be used just the same as in ActiveRecord. Methods will have the correct arguments but raise an NotImplementedError when called. Mocks are regenerated when the schema is modified so your mocks will not go stale; preventing the case where your units tests pass but production code fails.
 
 Examples from a real apps
 
 		Finished in 1 seconds
 		374 examples, 0 failures
 
+## Around the web
+["Mocking ActiveRecord with ActiveMocker" by Envy](http://madewithenvy.com/ecosystem/articles/2015/mocking-activerecord-with-activemocker/)
 
 ------------------------------------------
 
@@ -63,7 +65,7 @@ Or install it yourself as:
     $ gem install active_mocker
 
 ## Dependencies
-* Tested with Rails 4.0, 4.1, 4.2beta2
+* Tested with Rails 4.0, 4.1, 4.2
 * Requires Ruby MRI >= 2.1.
 
 

data/lib/active_mocker/generate.rb

@@ -93,7 +93,9 @@ class Generate
   end
 
   def save_mock_file(klass_str, model)
-    File.open(File.join(Config.mock_dir, "#{model.class_name.underscore}_mock.rb"), 'w').write(klass_str)
+    File.open(File.join(Config.mock_dir, "#{model.class_name.underscore}_mock.rb"), 'w') do |f|
+      f.write(klass_str)
+    end
   end
 
   def generate_mock_string(model)

data/lib/active_mocker/mock/mock_abilities.rb

@@ -55,7 +55,7 @@ module ActiveMocker
 
       alias_method :stub_class_method, :mock_class_method
 
-      def call_mock_method(method, caller, *arguments)
+      def call_mock_method(method:, caller:, arguments: [])
         mock_method = mockable_class_methods[method.to_sym]
         is_implemented(mock_method, method, '::', caller)
         mock_method.arguments = arguments
@@ -68,7 +68,7 @@ module ActiveMocker
 
     include InstanceAndClassMethods
 
-    def call_mock_method(method, caller, *arguments)
+    def call_mock_method(method:, caller:, arguments: [])
       mock_method = mockable_instance_methods[method.to_sym]
       mock_method = self.class.send(:mockable_instance_methods)[method.to_sym] if mock_method.nil?
       is_implemented(mock_method, method, '#', caller)

data/lib/active_mocker/mock_template.erb

@@ -152,7 +152,7 @@ class <%= class_name + @mock_append_name %> < <%= parent_class %>
 
 <% scope_methods.each do |method| -%>
     def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-      ActiveMocker::LoadedMocks.find('<%= class_name %>').send(:call_mock_method, '<%= method.name %>', <%= method.arguments.passable %>)
+      ActiveMocker::LoadedMocks.find('<%= class_name %>').send(:call_mock_method, method: '<%= method.name %>', caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
     end
 
 <% end -%>
@@ -178,12 +178,12 @@ class <%= class_name + @mock_append_name %> < <%= parent_class %>
 
 <% instance_methods.each do |method| %>
   def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-    call_mock_method :<%= method.name %>, Kernel.caller<%= ', ' unless method.arguments.empty? %><%= method.arguments.passable %>
+    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
   end
 <% end -%>
 <% class_methods.each do |method| %>
   def self.<%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-    call_mock_method :<%= method.name %>, Kernel.caller<%= ', ' unless method.arguments.empty? %><%= method.arguments.passable %>
+    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
   end
 <% end -%>
 

data/lib/active_mocker/model_schema.rb

@@ -269,11 +269,11 @@ module ActiveMocker
         end
 
         def to_s
-          Reparameterize.call(arguments)
+          Reparameterize.method_arguments(arguments)
         end
 
         def passable
-          Reparameterize.call(arguments, param_list: true)
+          Reparameterize.method_parameters(arguments)
         end
 
       end

data/lib/active_mocker/reparameterize.rb

@@ -1,40 +1,41 @@
 module ActiveMocker
 # @api private
-class Reparameterize
+  class Reparameterize
 
-  def self.call(params, param_list:nil)
-    return param_list(params) unless param_list.nil?
-    method_arguments(params)
-  end
+    def self.call(params, method_parameters: nil)
+      return method_parameters(params) unless method_parameters.nil?
+      method_arguments(params)
+    end
 
-  def self.method_arguments(params)
-    params.map do |state, param|
-      case state
-        when :req
-          param
-        when :rest
-          "*#{param}"
-        when :opt
-          "#{param}=nil"
-        when :keyreq
-          "#{param}:"
-        when :key
-          "#{param}: nil"
-      end
-    end.join(', ')
+    # Method arguments are the real values passed to (and received by) the function.
+    def self.method_arguments(params)
+      params.map do |state, param|
+        case state
+          when :req
+            param
+          when :rest
+            "*#{param}"
+          when :opt
+            "#{param}=nil"
+          when :keyreq
+            "#{param}:"
+          when :key
+            "#{param}: nil"
+        end
+      end.join(', ')
+    end
 
-  end
+    # Method parameters are the names listed in the function definition.
+    def self.method_parameters(params)
+      params.map do |state, param|
+        case state
+          when :key, :keyreq
+            "#{param}: #{param}"
+          else
+            param
+        end
+      end.join(', ')
+    end
 
-  def self.param_list(params)
-    params.map do |state, param|
-      case state
-        when :key, :keyreq
-          "#{param}: #{param}"
-        else
-          param
-      end
-    end.join(', ')
   end
-
-end
 end

data/lib/active_mocker/version.rb

@@ -1,3 +1,3 @@
 module ActiveMocker
-  VERSION = "1.8.3"
+  VERSION = "1.8.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_mocker
 version: !ruby/object:Gem::Version
-  version: 1.8.3
+  version: 1.8.4
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -276,7 +276,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Creates mocks from Active Record models. Allows your test suite to run very