less_interactions 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f66dc3d8874f056ca707580b54ba75439df9547
-  data.tar.gz: 218adf942ea75603a46a59af10738475adcc6c51
+  metadata.gz: 4d6950164589b4d646f7ef8f183b9642c13dde61
+  data.tar.gz: 51cdc8d312de5087272ada094908634c0cace295
 SHA512:
-  metadata.gz: 10d99fdaaee88851a7630740dee9e1c369ef8fcb25afa12a3ad0d1318167791ffecc9fcf2c2d18805c04bf4684f123b1121273d2afbb186b3c2ebabaf47f627a
-  data.tar.gz: 2c1ef12cdf3604fc9e6282d88d46741805741345a1f136fa9186a9f1d20dcd3a1d1df74e600a352a6e5d045535f71a6d151f193b1978e9744e9e547183789a50
+  metadata.gz: 6630b11347f16225b5a8242b55bf5fbaa265f55a53c2e236a0db9172e2b238673aa19dd63ff8444694e8d7dc1bd9de831251072d73440932a21e3a8b43fdfc35
+  data.tar.gz: 5c50e9a6a8f9201b74eaf8535e3bff276e5d221e25b1cfda418edf1be19f3c2e4c605b7d17d2c48b505d1987a9c96dc1141a97d899e7731b730fb0d68f723f7d

data/README.rdoc

@@ -82,7 +82,14 @@ After:
     #only one of these is required
     expects_any :need_this, :or, :this
 
-    # method chain in use case is easy to see.
+    # A way to document what you are expecting to be returned 
+    # Also creates setter and getter methods for each
+    returns :user
+    returns :was_this_successful
+
+    # Method chain in use case is easy to see.
+    # To have access to the getter and setter methods created with returns 
+    # you need the run method to return self
     def run
       do_somthing_with some_other_thing_the_interaction_needs
       build_or_find_an_expense
@@ -93,8 +100,9 @@ After:
       update_budgets
       update_bank_accounts
       @expense
+      self
     end
-
+ 
     private
 
     # implementation of other methods

data/lib/less_interactions.rb

@@ -1,4 +1,7 @@
 
 require 'bundler/setup'
 require 'less_interactions/interaction'
-require 'less_interactions/response'
+require 'less_interactions/response'
+require 'less_interactions/expectation'
+require 'less_interactions/multiple_choice_expectation'
+require 'less_interactions/expectation_array'

data/lib/less_interactions/expectation.rb

@@ -0,0 +1,33 @@
+# Verifies that some conditions are met for a member of a parameters hash
+module Less
+  class Expectation
+    attr_reader :parameter
+    def initialize parameter, options = {}
+      @parameter = parameter
+      @allow_nil = options[:allow_nil]
+    end
+
+    def verify(params)
+      unless verifies_expectations?(params)
+        raise MissingParameterError, "Parameter empty  :#{@parameter}"
+      end
+    end
+
+    def allows_nil?
+      @allow_nil
+    end    
+
+    private
+
+    def verifies_expectations?(params)
+      if @allow_nil == nil || @allow_nil == false
+        params.has_key?(@parameter) && params[@parameter] != nil
+      else
+        true
+      end
+    end
+  end
+  class MissingParameterError < StandardError; end
+end
+
+

data/lib/less_interactions/expectation_array.rb

@@ -0,0 +1,11 @@
+module Less
+  class ExpectationArray < Array
+    
+    def verify!(all_params)
+      self.each do |expectation|
+        expectation.verify(all_params)
+      end
+    end
+
+  end
+end

data/lib/less_interactions/interaction.rb

@@ -1,4 +1,3 @@
-
 module Less
   class Interaction
     # Initialize the objects for an interaction.
@@ -12,18 +11,11 @@ module Less
         options[:context] = context # add context to the options so will get the ivar and getter
       end
 
-      ex = self.class.expectations.dup
-      n = ex.keep_if {|name, allow_nil| allow_nil.has_key?(:allow_nil) && allow_nil[:allow_nil]}
-      nils = {}
-      n.each do |name, val|
-        nils[name] = nil
-      end
-      self.class.any_expectations.flatten.each {|e| nils[e] = nil}
-
-      nils.merge(options).each do |name, value|
-        instance_variable_set "@#{name}", value
-        if respond_to?( "#{name}=" ) && !value.nil?
-          send "#{name}=", value
+      self.all_params = options
+      set_instance_variables
+      options.each do |name, value|
+        if respond_to?( "#{name}=" ) 
+          send "#{name}=", value   
         end
       end
     end
@@ -42,11 +34,11 @@ module Less
 
     # Run your interaction.
     # @param [Object] context
-    # @param [Hash] options
+    # @param [Hash] params
     #
-    # This will initialize your interaction with the options you pass to it and then call its {#run} method.
-    def self.run(context = {}, options = {})
-      me = new(context, options)
+    # This will initialize your interaction with the params you pass to it and then call its {#run} method.
+    def self.run(context = {}, params = {})
+      me = new(context, params)
       me.send :expectations_met?
       me.init
       me.run
@@ -66,69 +58,83 @@ module Less
       else
         options = {}
       end
-      __setup_expecations parameters do |parameter|
+
+      parameters.each do |parameter|
+        add_reader(parameter)
         add_expectation(parameter, options)
       end
     end
 
     def self.expects_any *parameters
-      __setup_expecations parameters do |parameter|
+      parameters.each do |parameter|
+        add_reader(parameter)
       end
       add_any_expectation(parameters)
     end
 
-
+    # Make an attr_accessor alias for what you are expecting to be returned
+    # Need to return self in the run method for to use this
+    def self.returns(*args)
+      attr_accessor(*args)
+    end
 
     private
 
-    def self.__setup_expecations parameters
-      parameters.each do |param|
-        methods = (self.instance_methods + self.private_instance_methods)
-        self.send(:attr_reader, param.to_sym) unless methods.member?(param.to_sym)
-        yield param if block_given?
-      end
+    def all_params
+      @__all_params
     end
 
-    def self.add_expectation(parameter, options)
-      expectations[parameter] = options
+    def all_params=(p)
+      @__all_params = p
     end
 
-    def self.add_any_expectation(parameters)
-      any_expectations << parameters
+    def set_instance_variables
+      all_params.each do |name, value|
+        instance_variable_set "@#{name}", value
+      end
+
+      self.class.expectations.each do |expectation|
+        name = expectation.parameter
+        if all_params.has_key?(name)
+          instance_variable_set "@#{name}", all_params[name]
+        elsif expectation.allows_nil?
+          instance_variable_set "@#{name}", nil
+        end
+      end
     end
 
-    def expectations_met?
-      __expects_mets? && __expects_any_mets?
+    def self.add_reader param
+      methods = (self.instance_methods + self.private_instance_methods)
+      self.send(:attr_reader, param.to_sym) unless methods.member?(param.to_sym)
     end
 
-    def __expects_any_mets?
-      self.class.any_expectations.each do |any_set|
-        if any_set.all? {|e| instance_variable_get("@#{e}").nil?}
-          raise MissingParameterError, "Parameters empty   :#{any_set.to_s} (At least one of these must not be nil)"
-        end
+    def self.add_expectation(parameter, options)
+      ex = Expectation.new(parameter, options)
+      if expectations.none? { |e| e.parameter == parameter }
+        expectations << ex
       end
-      true
     end
 
-    def __expects_mets?
-      self.class.expectations.each do |param, param_options|
-        unless param_options[:allow_nil]
-          raise MissingParameterError, "Parameter empty   :#{param.to_s}" if instance_variable_get("@#{param}").nil?
-        end
+    def self.add_any_expectation(parameters)
+      new_ex = MultipleChoiceExpectation.new(parameters)
+      if any_expectations.none? {|ex| ex.parameters == new_ex.parameters }
+        any_expectations << new_ex
       end
-      true
+    end
+
+    def expectations_met?
+      self.class.any_expectations.verify!(all_params) && self.class.expectations.verify!(all_params)
     end
 
     def self.any_expectations
-      @any_expectations ||= []
+      @any_expectations ||= ExpectationArray.new()
     end
 
     def self.expectations
-      @expectations ||= {}
+      @expectations ||= ExpectationArray.new()
     end
   end
 
 
   class InvalidInteractionError < StandardError; end
-  class MissingParameterError < StandardError; end
 end

data/lib/less_interactions/multiple_choice_expectation.rb

@@ -0,0 +1,32 @@
+#Accepts multiple parameters and validates them to ensure at least one is present and not nil.
+#Raise MissingParameterError if the correct parameters are not present. 
+module  Less
+  class MultipleChoiceExpectation 
+    attr_reader :parameters
+    
+    def initialize parameters 
+      @parameters = parameters
+    end
+
+    def verify(hash_to_verify)
+      unless verifies_expectations?(hash_to_verify)
+        raise MissingParameterError, "Parameters empty #{@parameters.map(&:to_sym)} (At least one of these must not be nil)"
+      end
+    end
+
+    def verifies_expectations?(hash_to_verify)
+      valid = @parameters.any? do |parameter|
+        hash_to_verify.has_key?(parameter) && !hash_to_verify[parameter].nil?
+      end
+      return valid
+    end
+
+    def all_params_are_not_nil?(hash_to_verify)
+      hash_to_verify.any? do |k,v|
+        v.nil?
+      end
+    end
+  end
+
+  class MissingParameterError < StandardError; end
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module Less
   class Interaction
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/test/expectation_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+class ExpectationTest < Minitest::Test
+  include Less
+
+  should "parameters hash can meet an expectation" do
+    ex = Expectation.new(:name)
+    params = {name: "Mike", age: 27}
+    assert_nothing_raised do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash fails when not meeting an expectation" do
+    ex = Expectation.new(:name)
+    params = {name: nil, age: 27}
+    assert_raises(MissingParameterError) do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash fails if expectation is absent" do
+    ex = Expectation.new(:name)
+    params = {age: 27}
+    assert_raises(MissingParameterError) do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters should not fail if allow nil is true parameters value is nil" do
+    ex = Expectation.new(:name, allow_nil: true)
+    params = {name: nil}
+    assert_nothing_raised do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters should not fail if allow nil is true and no parameters are passed" do
+    ex = Expectation.new(:name, allow_nil: true)
+    params = {}
+    assert_nothing_raised do
+      ex.verify(params)
+    end
+  end
+end

data/test/interaction_test.rb

@@ -33,16 +33,6 @@ class InteractionTest < Minitest::Test
     assert_equal 1, i.instance_variable_get(:@a)
   end
 
-  should "call the writer if there is one" do
-    class InteractionWithWriter < Interaction
-      expects :a, allow_nil: true
-      def run; self; end
-      def a= val; @a += 1; end
-    end
-    i = InteractionWithWriter.run a: 1
-    assert_equal 2, i.instance_variable_get(:@a)
-  end
-
   should "call the writer if there is one and value is not null" do
     class GobbledyGook; def gobble; "gook"; end; end
     class InteractionWithWriter < Interaction
@@ -80,39 +70,39 @@ class InteractionTest < Minitest::Test
   end
 
   should "run if an expected parameter is found" do
-    class InteractionWithParameter < Less::Interaction
+    class InteractionWithParameterA < Less::Interaction
       expects :title
 
       def run; end
     end
-    assert_nothing_raised { InteractionWithParameter.run(:title => "Hello, test") }
+    assert_nothing_raised { InteractionWithParameterA.run(:title => "Hello, test") }
   end
 
   should "run if an expected parameter is found, even if it is false" do
-    class InteractionWithParameter < Less::Interaction
+    class InteractionWithParameterB < Less::Interaction
       expects :title
 
       def run; end
     end
-    assert_nothing_raised { InteractionWithParameter.run(:title => false) }
+    assert_nothing_raised { InteractionWithParameterB.run(:title => false) }
   end
 
   should "run if an expected parameter is found, even if it is nil, if the option is specified" do
-    class InteractionWithParameter < Less::Interaction
+    class InteractionWithParameterC < Less::Interaction
       expects :title, :allow_nil => true
 
       def run;end
     end
-    assert_nothing_raised { InteractionWithParameter.run(:title => nil) }
+    assert_nothing_raised { InteractionWithParameterC.run(:title => nil) }
   end
 
   should "run if an expected parameter is found, even if it is nil, if the option is not specified, but is allow_nil and is called" do
-    class InteractionWithParameter < Less::Interaction
+    class InteractionWithParameterD < Less::Interaction
       expects :title, :allow_nil => true
 
       def run; title;end
     end
-    assert_nothing_raised { InteractionWithParameter.run() }
+    assert_nothing_raised { InteractionWithParameterD.run() }
   end
 
   should "set ivars from options on initialize" do
@@ -121,7 +111,6 @@ class InteractionTest < Minitest::Test
     assert_equal 2, i.instance_variable_get(:@b)
   end
 
-
   should "Convert first param to context on initialize" do
     i = Less::Interaction.new 1, b:2
     assert_equal 1, i.instance_variable_get(:@context)
@@ -143,7 +132,6 @@ class InteractionTest < Minitest::Test
   end
 
   should "be able to override an expects" do
-
     class OverrideExpects < Less::Interaction
       expects :object, allow_nil: true
 
@@ -183,7 +171,6 @@ class InteractionTest < Minitest::Test
      assert_equal "1", x.send(:int)
    end
 
-
    should "fail if all expects_any parameters are nil" do
      class AnyInteractionWithAllNilParameters < Less::Interaction
        expects_any :title, :a, :b
@@ -210,4 +197,52 @@ class InteractionTest < Minitest::Test
      assert_raises(MissingParameterError) { ExpectationsMetBeforeInit.run() }
    end
 
+   should "call the writer if there is one" do   
+     class InteractionWithWriter < Interaction    
+       expects :a, allow_nil: true    
+       def run; self; end   
+       def a= val; @a += 1; end   
+     end    
+     i = InteractionWithWriter.run a: 1   
+     assert_equal 2, i.instance_variable_get(:@a)   
+   end    
+ 
+  should "call the writer even if the value of the param is nil" do 
+    class InteractionWithWriterb < Interaction
+      expects :a, allow_nil: true
+      def run; self; end
+      def a= val; @a = 1; end
+    end
+    i = InteractionWithWriterb.run a: nil 
+    assert_equal 1, i.instance_variable_get(:@a)
+  end
+
+  should "not call the writer if the param is not passed in" do 
+    class InteractionWithWriterc < Interaction
+      expects :a, allow_nil: true
+      def run; self; end 
+      def a= val; @a = 1; end 
+    end
+    i = InteractionWithWriterc.run 
+    assert_equal nil, i.instance_variable_get(:@a)
+  end
+
+  should "set a getter when returns is called" do 
+    class InteractionWithReturns < Interaction
+      returns :a
+      def run; self; end
+    end
+    i = InteractionWithReturns.run(a: 1)
+    assert_equal 1, i.a
+  end
+
+  should "not set a getter if returns is not called" do 
+    class InteractionWithReturns2 < Interaction
+      def run; self; end
+    end
+    i = InteractionWithReturns2.run(a: 1)
+    assert_raises NoMethodError do 
+      i.a
+    end
+  end
 end

data/test/multiple_choice_expectation_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+class MultipleChoiceExpectation < Minitest::Test
+  include Less
+
+  should "parameters hash can meet an expectation" do
+    ex = MultipleChoiceExpectation.new([:name, :user, :id])
+    params = {name: "Mike"}
+    assert_nothing_raised do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash fails if all parameters are nil" do
+    ex = MultipleChoiceExpectation.new([:name, :user, :id])
+    params = {name: nil, age: nil}
+    assert_raises (MissingParameterError) do
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash should pass when one parameter is not nil" do 
+    ex = MultipleChoiceExpectation.new([:name, :age, :id])
+    params = {name: nil, age: 55}
+    assert_nothing_raised do 
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash should pass when the second parameter is not nil" do 
+    ex = MultipleChoiceExpectation.new([:name, :age, :id])
+    params = {age: 12}
+    assert_nothing_raised do 
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash should pass even if some parameters are missing" do 
+    ex = MultipleChoiceExpectation.new([:name, :age, :id])
+    params = {name: "Michael"}
+    assert_nothing_raised do 
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash should fail if no parameters are passed in" do 
+    ex = MultipleChoiceExpectation.new([:name, :age, :id])
+    params = {}
+    assert_raises (MissingParameterError) do 
+      ex.verify(params)
+    end
+  end
+
+  should "parameters hash should fail if parameter is present and nil" do
+    ex = MultipleChoiceExpectation.new([:name, :age, :id])
+    params = {age: nil}
+    assert_raises (MissingParameterError) do 
+      ex.verify(params)
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: less_interactions
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Eugen Minciu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-23 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,10 +62,15 @@ files:
 - lib/generators/less/templates/interaction.rb
 - lib/generators/less/templates/test.rb
 - lib/less_interactions.rb
+- lib/less_interactions/expectation.rb
+- lib/less_interactions/expectation_array.rb
 - lib/less_interactions/interaction.rb
+- lib/less_interactions/multiple_choice_expectation.rb
 - lib/less_interactions/response.rb
 - lib/version.rb
+- test/expectation_test.rb
 - test/interaction_test.rb
+- test/multiple_choice_expectation_test.rb
 - test/response_test.rb
 - test/test_helper.rb
 homepage: ''
@@ -93,7 +98,9 @@ signing_key:
 specification_version: 4
 summary: A better way to think about Rails application
 test_files:
+- test/expectation_test.rb
 - test/interaction_test.rb
+- test/multiple_choice_expectation_test.rb
 - test/response_test.rb
 - test/test_helper.rb
 has_rdoc: