impersonator 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44894f5dac3e7080abf3ffebf05ea83a876394629f60f9e486319f8e4e5304e2
-  data.tar.gz: 994a96556cef09050e108cfd55539af2f61507afae6298a994da811f187076bb
+  metadata.gz: 88bdf9e7b7619dc442feaf3630312ef3ae0a30cedbd4c1593e4b896d93fac5a2
+  data.tar.gz: 073f80859044bd9852a62ab292cf029f52056bcf49446b03a94981cf8c9cde1b
 SHA512:
-  metadata.gz: 83d2e1d38817599af079e1160c519a9529a820485ee851e7d9934a897f3f81ba97f3dc6add6c4e3f59f73d88095442971f9f4231666337cc75d9dd1cc7468b5b
-  data.tar.gz: 7c8b47fb88e82aca2d80ffc27f09c1ae37842d0ca2a0356fdaed50bc9d5cb9bb659c6687759ea21c95949af215c16a8572b09dfc975e54c839461a17d71757a7
+  metadata.gz: c832394967e28325e1d021957dd14721595b77439c809fdfd15d6491c1ad447486f061f573b7371d3db8bc9e7812b57780181f3f0812cfda8d8de9806a9cd7bc
+  data.tar.gz: e2e0408e9c6f7ce5e35d51b9ccc214af75dcfbd30cf0003f6c8ce17725367ed1cec00eaf852f0d0d4249e711ca16c88929dcd58b9b4864b5457feb9ed0d1b0e9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    impersonator (0.1.2)
+    impersonator (0.1.3)
       zeitwerk (~> 2.1.6)
 
 GEM

data/README.md

@@ -32,7 +32,7 @@ And then execute:
 Use `Impersonator.impersonate` passing in a list of methods to impersonate and a block that will instantiate the object at record time:
 
 ```ruby
-Impersonator.impersonate(:add, :divide) { Calculator.new }
+calculator = Impersonator.impersonate(:add, :divide) { Calculator.new }
 ```
 
 * At record time, `Calculator` will be instantiated and their methods normally invoked, recording the returned values (and yielded values if any).
@@ -47,15 +47,15 @@ end
 
 # The first time it records...
 Impersonator.recording('calculator add') do
-  impersonated_calculator = Impersonator.impersonate(:add) { Calculator.new }
-  puts impersonated_calculator.add(2, 3) # 5
+  calculator = Impersonator.impersonate(:add) { Calculator.new }
+  puts calculator.add(2, 3) # 5
 end
 
 # The next time it replays
 Object.send :remove_const, :Calculator # Calculator does not even have to exist now
 Impersonator.recording('calculator add') do
-  impersonated_calculator = Impersonator.impersonate(:add) { Calculator.new }
-  puts impersonated_calculator.add(2, 3) # 5
+  calculator = Impersonator.impersonate(:add) { Calculator.new }
+  puts calculator.add(2, 3) # 5
 end
 ```
 
@@ -189,6 +189,7 @@ end
 
 ## Links
 
+- [API documentation at rubydoc.info](https://www.rubydoc.info/github/jorgemanrubia/impersonator)
 - [Blog post](https://www.jorgemanrubia.com/2019/06/16/impersonator-a-ruby-library-to-record-and-replay-object-interactions/)
 
 ## Contributing

data/lib/impersonator/proxy.rb

@@ -67,14 +67,7 @@ module Impersonator
       matching_configuration = method_matching_configurations_by_method[method_name.to_sym]
       method = Method.new(name: method_name, arguments: args, block: block,
                           matching_configuration: matching_configuration)
-      if recording.replay_mode?
-        recording.replay(method)
-      else
-        spiable_block = method&.block_spy&.block
-        @impersonated_object.send(method_name, *args, &spiable_block).tap do |return_value|
-          recording.record(method, return_value)
-        end
-      end
+      recording.invoke(@impersonated_object, method, args)
     end
   end
 end

data/lib/impersonator/record_mode.rb

@@ -0,0 +1,56 @@
+module Impersonator
+  # The state of a {Recording recording} in record mode
+  class RecordMode
+    include HasLogger
+
+    # recording file path
+    attr_reader :recording_path
+
+    # @param [String] recording_path the file path to the recording file
+    def initialize(recording_path)
+      @recording_path = recording_path
+    end
+
+    # Start a recording session
+    def start
+      logger.debug 'Recording mode'
+      make_sure_recordings_dir_exists
+      @method_invocations = []
+    end
+
+    # Records the method invocation
+    #
+    # @param [Object, Double] impersonated_object
+    # @param [MethodInvocation] method
+    # @param [Array<Object>] args
+    def invoke(impersonated_object, method, args)
+      spiable_block = method&.block_spy&.block
+      impersonated_object.send(method.name, *args, &spiable_block).tap do |return_value|
+        record(method, return_value)
+      end
+    end
+
+    # Finishes the record session
+    def finish
+      File.open(recording_path, 'w') do |file|
+        YAML.dump(@method_invocations, file)
+      end
+    end
+
+    private
+
+    # Record a {MethodInvocation method invocation} with a given return value
+    # @param [Method] method
+    # @param [Object] return_value
+    def record(method, return_value)
+      method_invocation = MethodInvocation.new(method_instance: method, return_value: return_value)
+
+      @method_invocations << method_invocation
+    end
+
+    def make_sure_recordings_dir_exists
+      dirname = File.dirname(recording_path)
+      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    end
+  end
+end

data/lib/impersonator/recording.rb

@@ -3,6 +3,21 @@
 module Impersonator
   # A recording is responsible for saving interactions at record time, and replaying them at
   # replay time.
+  #
+  # A recording is always in one of two states.
+  #
+  # * {RecordMode Record mode}
+  # * {ReplayMode Replay mode}
+  #
+  # The state objects are responsible of dealing with the recording logic, which happens in 3
+  # moments:
+  #
+  # * {#start}
+  # * {#invoke}
+  # * {#finish}
+  #
+  # @see RecordMode
+  # @see ReplayMode
   class Recording
     include HasLogger
 
@@ -15,57 +30,39 @@ module Impersonator
       @label = label
       @recordings_path = recordings_path
       @disabled = disabled
+
+      initialize_current_mode
     end
 
     # Start a recording/replay session
     def start
       logger.debug "Starting recording #{label}..."
-      if can_replay?
-        start_in_replay_mode
-      else
-        start_in_record_mode
-      end
+      current_mode.start
     end
 
-    # Record a {MethodInvocation method invocation} with a given return value
-    # @param [Method] method
-    # @param [Object] return_value
-    def record(method, return_value)
-      method_invocation = MethodInvocation.new(method_instance: method, return_value: return_value)
-
-      @method_invocations << method_invocation
-    end
-
-    # Replay a method invocation
-    # @param [Method] method
-    def replay(method)
-      method_invocation = @method_invocations.shift
-      unless method_invocation
-        raise Impersonator::Errors::MethodInvocationError, 'Unexpected method invocation received:'\
-              "#{method}"
-      end
-
-      validate_method_signature!(method, method_invocation.method_instance)
-      replay_block(method_invocation, method)
-
-      method_invocation.return_value
+    # Handles the invocation of a given method on the impersonated object
+    #
+    # It will either record the interaction or replay it dependening on if there
+    # is a recording available or not
+    #
+    # @param [Object, Double] impersonated_object
+    # @param [MethodInvocation] method
+    # @param [Array<Object>] args
+    def invoke(impersonated_object, method, args)
+      current_mode.invoke(impersonated_object, method, args)
     end
 
     # Finish a record/replay session.
     def finish
       logger.debug "Recording #{label} finished"
-      if record_mode?
-        finish_in_record_mode
-      else
-        finish_in_replay_mode
-      end
+      current_mode.finish
     end
 
     # Return whether it is currently at replay mode
     #
     # @return [Boolean]
     def replay_mode?
-      @replay_mode
+      @current_mode == replay_mode
     end
 
     # Return whether it is currently at record mode
@@ -77,66 +74,34 @@ module Impersonator
 
     private
 
-    def can_replay?
-      !@disabled && File.exist?(file_path)
-    end
-
-    def replay_block(recorded_method_invocation, method_to_replay)
-      block_spy = recorded_method_invocation.method_instance.block_spy
-      block_spy&.block_invocations&.each do |block_invocation|
-        method_to_replay.block.call(*block_invocation.arguments)
-      end
-    end
+    attr_reader :current_mode
 
-    def start_in_replay_mode
-      logger.debug 'Replay mode'
-      @replay_mode = true
-      @method_invocations = YAML.load_file(file_path)
+    def initialize_current_mode
+      @current_mode = if can_replay?
+                        replay_mode
+                      else
+                        record_mode
+                      end
     end
 
-    def start_in_record_mode
-      logger.debug 'Recording mode'
-      @replay_mode = false
-      make_sure_recordings_dir_exists
-      @method_invocations = []
+    def can_replay?
+      !@disabled && File.exist?(recording_path)
     end
 
-    def finish_in_record_mode
-      File.open(file_path, 'w') do |file|
-        YAML.dump(@method_invocations, file)
-      end
+    def record_mode
+      @record_mode ||= RecordMode.new(recording_path)
     end
 
-    def finish_in_replay_mode
-      unless @method_invocations.empty?
-        raise Impersonator::Errors::MethodInvocationError,
-              "Expecting #{@method_invocations.length} method invocations"\
-              " that didn't happen: #{@method_invocations.inspect}"
-      end
+    def replay_mode
+      @replay_mode ||= ReplayMode.new(recording_path)
     end
 
-    def file_path
+    def recording_path
       File.join(@recordings_path, "#{label_as_file_name}.yml")
     end
 
     def label_as_file_name
       label.downcase.gsub(/[\(\)\s \#:]/, '-').gsub(/[\-]+/, '-').gsub(/(^-)|(-$)/, '')
     end
-
-    def make_sure_recordings_dir_exists
-      dirname = File.dirname(file_path)
-      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
-    end
-
-    def validate_method_signature!(expected_method, actual_method)
-      unless actual_method == expected_method
-        raise Impersonator::Errors::MethodInvocationError, <<~ERROR
-          Expecting:
-            #{expected_method}
-          But received:
-            #{actual_method}
-        ERROR
-      end
-    end
   end
 end

data/lib/impersonator/replay_mode.rb

@@ -0,0 +1,68 @@
+module Impersonator
+  # The state of a {Recording recording} in replay mode
+  class ReplayMode
+    include HasLogger
+
+    # recording file path
+    attr_reader :recording_path
+
+    # @param [String] recording_path the file path to the recording file
+    def initialize(recording_path)
+      @recording_path = recording_path
+    end
+
+    # Start a replay session
+    def start
+      logger.debug 'Replay mode'
+      @replay_mode = true
+      @method_invocations = YAML.load_file(recording_path)
+    end
+
+    # Replays the method invocation
+    #
+    # @param [Object, Double] impersonated_object not used in replay mode
+    # @param [MethodInvocation] method
+    # @param [Array<Object>] args not used in replay mode
+    def invoke(_impersonated_object, method, _args)
+      method_invocation = @method_invocations.shift
+      unless method_invocation
+        raise Impersonator::Errors::MethodInvocationError, 'Unexpected method invocation received:'\
+              "#{method}"
+      end
+
+      validate_method_signature!(method, method_invocation.method_instance)
+      replay_block(method_invocation, method)
+
+      method_invocation.return_value
+    end
+
+    # Finishes the record session
+    def finish
+      unless @method_invocations.empty?
+        raise Impersonator::Errors::MethodInvocationError,
+              "Expecting #{@method_invocations.length} method invocations"\
+              " that didn't happen: #{@method_invocations.inspect}"
+      end
+    end
+
+    private
+
+    def replay_block(recorded_method_invocation, method_to_replay)
+      block_spy = recorded_method_invocation.method_instance.block_spy
+      block_spy&.block_invocations&.each do |block_invocation|
+        method_to_replay.block.call(*block_invocation.arguments)
+      end
+    end
+
+    def validate_method_signature!(expected_method, actual_method)
+      unless actual_method == expected_method
+        raise Impersonator::Errors::MethodInvocationError, <<~ERROR
+          Expecting:
+            #{expected_method}
+          But received:
+            #{actual_method}
+        ERROR
+      end
+    end
+  end
+end

data/lib/impersonator/version.rb

@@ -1,3 +1,3 @@
 module Impersonator
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: impersonator
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jorge Manrubia
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-29 00:00:00.000000000 Z
+date: 2019-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -117,7 +117,9 @@ files:
 - lib/impersonator/method_invocation.rb
 - lib/impersonator/method_matching_configuration.rb
 - lib/impersonator/proxy.rb
+- lib/impersonator/record_mode.rb
 - lib/impersonator/recording.rb
+- lib/impersonator/replay_mode.rb
 - lib/impersonator/version.rb
 homepage: https://github.com/jorgemanrubia/impersonator
 licenses: