deep_double 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10da248b3fdf8a64407a89a83c6f77e6df110f55c44bf3c5be5a2ae1c1924066
-  data.tar.gz: 73bb4881d11356d2ec95f810b7446e51e6b0c516c1066258eee7b04e74a0c158
+  metadata.gz: f2d86400433bcf2186dbab75a25cc58151a8934d1c672d2d3d1692d895ddafd3
+  data.tar.gz: 8493e72d2bc1444d2eb3b4185b9068ae8ad33373738f0333e52b41e4963187e3
 SHA512:
-  metadata.gz: 95ec83eeaec878133e679e327bc16f7c18623a5822df6eaf48a99634a30df7e6f9f643c372ca006502be02002ad733191d3b8ce6fb59ab95f5a9ffceeb07d9ca
-  data.tar.gz: dc383f873d38b97b9be99c107efb7ea0331f2021c5795d3b3a89b1b17f92c745349613b6895f4f7afd5e9ec628104d5124a854f12ccb28f29b2b9f2fa164812f
+  metadata.gz: cb4a27a46a3520bf82b1efb7e120ecd0dc7d416beef4be394539a3e0ceeba0ab6360e97986f59ce5b0732ee8d45f9ad4e1c770183309447c8847b0379585140b
+  data.tar.gz: 3b4f0744335a8a49045a2f7cb8d92a019079dad84a8e73519a12b8b384474020fd0b37c12035651771b52d8a0872f1717bb4a69ba30522a3cbf6fbdf9b84218c

data/lib/deep_double.rb

@@ -4,9 +4,9 @@
 # It drastically reduces the amount of boilerplate compared with rspec.
 #
 
-require 'deep_double/function'
+require 'deep_double/fake_method'
 require 'deep_double/literal'
-require 'deep_double/recursive_function'
+require 'deep_double/recursive_fake_method'
 require "deep_double/version"
 
 module DeepDouble
@@ -45,12 +45,12 @@ module DeepDouble
     end
 
     def create_method(meth)
-      define_singleton_method(meth.to_sym, &function(meth))
+      define_singleton_method(meth.to_sym, &fake_method(meth))
     end
 
-    def function(meth)
-      raw_fn = Function.new(@definition[meth])
-      RecursiveFunction.new(raw_fn)
+    def fake_method(meth)
+      raw_fn = FakeMethod.new(@definition[meth])
+      RecursiveFakeMethod.new(raw_fn)
     end
   end
 end

data/lib/deep_double/fake_method.rb

@@ -0,0 +1,40 @@
+require 'deep_double/fake_method/validate_stubbed_values'
+
+# Takes a Hash of stubbed values to create a fake method. The stubbed values map
+# lists of arguments (represented as arrays, with the empty array representing a
+# method that takes no args) to return values.
+#
+
+module DeepDouble
+  class FakeMethod
+
+    def initialize(stubbed_values)
+      @stubbed_values = stubbed_values
+      validate_stubbed_values
+    end
+
+    def call(*args)
+      result(args)
+    end
+
+    private
+
+    def validate_stubbed_values
+      ValidateStubbedValues.new(@stubbed_values).call
+    end
+
+    def result(args)
+      validate_result_exists(args)
+      @stubbed_values.key?(args) ? @stubbed_values[args] : @stubbed_values[:default]
+    end
+
+    def validate_result_exists(args)
+      return if result_exists?(args)
+      raise ArgumentError, "FakeMethod not defined for args: #{args}"
+    end
+
+    def result_exists?(args)
+      @stubbed_values.key?(args) || @stubbed_values.key?(:default)
+    end
+  end
+end

data/lib/deep_double/fake_method/validate_stubbed_values.rb

@@ -0,0 +1,44 @@
+# Validates that the structure of a stubbed values Hash is valid:
+# - It must be a Hash
+# - It's keys must be Arrays or the special value ":default"
+#
+module DeepDouble
+  class FakeMethod
+
+    class ValidateStubbedValues
+      def initialize(stubbed_values)
+        @stubbed_values = stubbed_values
+      end
+
+      def call
+        validate_type
+        validate_keys
+      end
+
+      private
+
+      def validate_type
+        return if @stubbed_values.is_a?(Hash)
+        raise ArgumentError,
+          "The stubbed values defining a FakeMethod must be a Hash"
+      end
+
+      def validate_keys
+        @stubbed_values.keys.each { |key| validate_key(key) }
+      end
+
+      def validate_key(key)
+        return if valid_key?(key)
+        raise ArgumentError,
+          "Keys in a stubbed values Hash must by Arrays representing " +
+          "argument lists (the empty array represents 0 arguments). The " +
+          "following key was invalid: #{key.inspect}"
+      end
+
+      def valid_key?(key)
+        key.is_a?(Array) || key == :default
+      end
+    end
+
+  end
+end

data/lib/deep_double/{recursive_function.rb → recursive_fake_method.rb}

@@ -1,15 +1,15 @@
-# Makes a `DeepDouble::Function` recursive, so that `Hash` results are
+# Makes a `DeepDouble::FakeMethod` recursive, so that `Hash` results are
 # automatically converted to `DeepDouble` instances in their own right.
 #
 module DeepDouble
-  class RecursiveFunction
+  class RecursiveFakeMethod
 
-    def initialize(function)
-      @function = function
+    def initialize(fake_method)
+      @fake_method = fake_method
     end
 
     def call(*args)
-      result = @function.call(*args)
+      result = @fake_method.call(*args)
       special_case_transforms(result)
     end
 

data/lib/deep_double/version.rb

@@ -1,3 +1,3 @@
 module DeepDouble
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_double
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Jonah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-10 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,10 +73,10 @@ files:
 - bin/setup
 - deep_double.gemspec
 - lib/deep_double.rb
-- lib/deep_double/function.rb
-- lib/deep_double/function/validate_result_table.rb
+- lib/deep_double/fake_method.rb
+- lib/deep_double/fake_method/validate_stubbed_values.rb
 - lib/deep_double/literal.rb
-- lib/deep_double/recursive_function.rb
+- lib/deep_double/recursive_fake_method.rb
 - lib/deep_double/version.rb
 - spec/deep_double_spec.rb
 - spec/spec_helper.rb

data/lib/deep_double/function.rb

@@ -1,46 +0,0 @@
-require 'deep_double/function/validate_result_table'
-
-# A "function" in the mathematical sense: a mapping of input values to output
-# values.  This (argument -> value) mapping is specified by a "result_table" --
-# just an ordinary ruby hash -- passed to the constructor.
-#
-# If the return value is itself a hash, it's interpreted as the definition of
-# another double, and so another `DeepDouble` instance is returned.
-#
-module DeepDouble
-  class Function
-
-    def initialize(result_table)
-      @result_table = result_table
-      validate_result_table
-    end
-
-    def call(*args)
-      validate_result_exists(args)
-      result(args)
-    end
-
-    private
-
-    def validate_result_table
-      ValidateResultTable.new(@result_table).call
-    end
-
-    def validate_result_exists(args)
-      return if value_defined_for?(args)
-      raise ArgumentError, "Function not defined for args: #{args}"
-    end
-
-    def result(args)
-      if @result_table.key?(args)
-        @result_table[args]
-      else
-        @result_table[:default]
-      end
-    end
-
-    def value_defined_for?(args)
-      @result_table.key?(args) || @result_table.key?(:default)
-    end
-  end
-end

data/lib/deep_double/function/validate_result_table.rb

@@ -1,47 +0,0 @@
-# A "function" in the mathematical sense: a mapping of input values to output
-# values.  This (argument -> value) mapping is specified by a "result_table" --
-# just an ordinary ruby hash -- passed to the constructor.
-#
-# If the return value is itself a hash, it's interpreted as the definition of
-# another double, and so another `DeepDouble` instance is returned.
-#
-module DeepDouble
-  class Function
-
-    class ValidateResultTable
-      def initialize(result_table)
-        @result_table = result_table
-      end
-
-      def call
-        validate_result_table_type
-        validate_result_table_keys
-      end
-
-      private
-
-      def validate_result_table_type
-        return if @result_table.is_a?(Hash)
-        raise ArgumentError,
-          "The result table defining a Function must be a Hash"
-      end
-
-      def validate_result_table_keys
-        @result_table.keys.each { |key| validate_key(key) }
-      end
-
-      def validate_key(key)
-        return if valid_key?(key)
-        raise ArgumentError,
-          "Keys in a result table must by Arrays representing argument " +
-          "lists (the empty array represents 0 arguments). The following " +
-          "key was invalid: #{key.inspect}"
-      end
-
-      def valid_key?(key)
-        key.is_a?(Array) || key == :default
-      end
-    end
-
-  end
-end