speq 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca948589baaf3fd6d4385aec6da046cb0b96595ea1cc78af59787bf76112abe0
-  data.tar.gz: 5879601e06032198afc0675b44130900b3fdbb895f207cab7c2cfc94b70638fb
+  metadata.gz: 2d4e8796522782ab6e954f384d21d6b6d1d5e6728c773c68e587873f4183173e
+  data.tar.gz: f0e4a46ce5889abf250761d4f990a43a61792c6bade4e30e88fd7e9c45869699
 SHA512:
-  metadata.gz: 8f999677ac2de3f9e9760cfebe7180d1cb91215060a6f424f0c856f981ba9818715105b13dc1353d1b43d1fb9382b6c2189a0f31f64d50b21999b8ecb4bd4e23
-  data.tar.gz: 1f674c4b2593df191a9d036b0f458cf1aee46f342066667f5df33504bd70e5cfb30858f3fdc208229f0a87741d36fd9b7785e5a05234bb2a0e4f85556c8ffb18
+  metadata.gz: 9a08b7857d12e9b57af750fb35db681884a7af03a6224424abf659ad2eb4fde5353c8dbb3b873ab6c9f0ed6ac90ae4732338150748def36ddda786ad1921845f
+  data.tar.gz: e4ac157417ac3cda5a872b1b13a39ece575d437b10ea8fbca320d71ab383b255ca66be76085ce07bc3f20054d796dacfe17ad9a855632b10b44e21fe67c26681

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    speq (0.2.1)
+    speq (0.3.0)
       colorize (~> 0.8.1)
 
 GEM

data/README.md

@@ -1,10 +1,27 @@
 # Speq
 
-## A tiny library to build specs with fewer words
+## Build specs with fewer words
 
-Speq is TDD library for rapid prototyping in Ruby. It aims to work well anytime testing is desired but writing specs with existing tools may feel excessive.
+Speq is a testing library for rapid prototyping in Ruby.
 
-Speq favors simplicity and minimalism, which may not always be compatible with rigorous testing. The existing TDD tools for Ruby are exceptional, and Speq is not a replacement.
+Speq favors simplicity and minimalism.
+
+```ruby
+is(Array.new).empty?
+# Passed (1/1)
+#   [] is empty.
+```
+
+But also values flexibility.
+
+```ruby
+speq(Array(nil), 'an array created by calling Array(nil)').eq?([nil])
+
+# Failed (1/1)
+#   An array created by calling Array(nil) is NOT equal to [nil]. ( [] != [nil] )
+```
+
+Speq is ideal whenever it would feel excessive to use one of the existing frameworks, but it's not enough to just print & inspect outputs.
 
 ## Installation
 
@@ -22,45 +39,320 @@ Or install it yourself as:
 
     gem install speq
 
-## Design
+## Design & Syntax
+
+Speq is loosely based on the given-when-then or arrange-act-assert testing pattern. Speq's design choices are guided by the competing motivations of having tests be as short and simple as possible while maintaining the flexibility to be as descriptive as needed.
+
+In contrast to similar tools, speqs are typically framed as _questions_ about a program's behavior rather than assertions about the desired behavior. The most basic test involves passing a string to the method `speq` followed by `pass?` and a block that evaluates strictly to true or false.
+
+```ruby
+speq("Does Ruby properly calculate Euler's identity?").pass? do
+  e = Math::E
+  π = Math::PI
+  i = (1i)
+
+  e**(i*π) + 1 == 0
+end
+
+# Passed (1/1)
+#   Testing 'does Ruby properly calculate Euler's identity?' passes.
+```
+
+The above works, but it's not much shorter than existing solutions. More importantly, it's missing vital information about what action was taken, what the outcome was, and what assertion led to the success.
+
+Shown below is the basic two-part pattern for most speqs and the resulting report combining explicit and implicit descriptions:
+
+```ruby
+speq(Math::E**((1i) * Math::PI ) + 1, 'e^iπ + 1').eq?(0)
+# Passed (1/1)
+#     e^iπ + 1 is equal to 0. ( (0.0+0.0i) == 0 )
+```
+
+### Actions
+
+Descriptions for simple unit tests are often closely tied to the source code, and as such, Speq tries to eliminate them wherever possible. To automatically generate descriptions, the action or subject of interest is supplied to be evaluated dynamically.
 
-Speq's design choices are influenced by the competing motivations of having tests be as short and simple as possible while maintaining the flexibility to be as descriptive as needed.
+More specifically, we begin by setting up the program state and then explicitly supply the action being tested using the methods below. By breaking down the expression's method/message, arguments, and receiver, Speq can use the additional information to help generate an often sufficiently detailed description of the test. Actions are evaluated when they reach a [matcher](#matchers).
 
-Speq is loosely based on the given-when-then or arrange-act-assert testing pattern. Whereas one would typically need to make each step explicit, Speq tests focus on making it easy to simply assert the expected behavior with an implicit arrangement and action.
+- message: `does(*:symbol` or `is(*:symbol)`, default: `:itself`
+- arguments: `with(...)` or `of(...)`, default: `*[]`
+- receiver: `on(object, description(optional))`, default: `Object`
 
-## Syntax
+```ruby
+is(:prime?).of(2).true?
+
+on((1..4).to_a.reverse).does(:sort).eq?([1, 2, 3, 4])
+
+# .with() accepts arguments with the exact same format as any other method
+does(:map).with { |idx| idx * idx }.on(0..3).eq?([0, 1, 4, 9])
+
+# Passed (3/3)
+#   prime? of 2 is true.
+#   sort on [4, 3, 2, 1] equals [1, 2, 3, 4].
+#   map with a block on 1..4 equals [0, 1, 4, 9].
+```
 
-Speq's syntax is still in flux and likely to change dramatically until an effective setup is established.
+Chaining methods can be accomplished by providing multiple symbols. If an intermediate value needs to be tested or a method needs to be given arguments, this can be accomplished by using `.then(:next_method).with`. An example of this is shown below. An alternative, unconventional syntax for accomplishing the same can be found in the section on [syntactic sugar](#Sugar)
 
 ```ruby
-test_unit :sort, on: [3, 2, 1], eq: [1, 2, 3]
+on(1..4)
+  .does(:to_a, :shuffle, :sort)
+  .eq?([1, 2, 3, 4])
+  .then(:sort).with { | a, b | b <=> a }
+  .eq?([4, 3, 2, 1])
+
+# Passed (1/1)
+#   to_a on 1..4 then reverse (on [1, 2, 3, 4]) then sort (on [4, 3, 2, 1]) equals [1, 2, 3, 4].
+```
+
+### Matchers
+
+All speq methods that end with a question mark are matchers.
+
+The matcher `pass?` is the most general and simply expects to be given a code block that evaluates to true or false. The output from the action is passed along as the first piped variable.
+
+```ruby
+does(:strip)
+  .on(' speq ')
+  .pass? { |str|  str == 'speq' && !str.include?(' ') }
+
+does(:rand)
+  .pass? { |val| val.is_a?(Float) }
+
+does(:prime?)
+  .with(-1)
+  .raise?('Prime is not defined for negative numbers')
+
+on(User)
+  .does(:new)
+  .with(id: 1, name: 'user name')
+  .have?(:id)
+```
+
+#### Prefixes and Compound Matchers
+
+Multiple matchers can follow an action. By default, all matchers must pass for the test to be considered successful. To run multiple tests on the same action, see the section on [test subjects](#subjects)
+
+The logical inverse of any matcher can be achieved by prefixing the matcher with `not_`.
+
+```ruby
+# Equivalent to the previous speq
+does(:strip).on(' speq ').not_include?(' ').eq?('speq')
+```
+
+For simple combinations, it's sufficient to prefix the second matcher with one of the following: `or_, nand_, nor_, xor_, xnor_`
+
+```ruby
+arr = Array.new(10, rand.round)
+speq(arr, '10 element array filled with zeros or ones').has?(length: 100).all?(0).or_all?(1)
+
+# arr.length == 100 && (arr.all?(0) || arr.all?(1))
+```
+
+Although it's best to avoid complex combinations of matchers, logical operators can be combined unambiguously if absolutely needed by chaining operators with prefix notation.
+
+```ruby
+default = rand.round(1) <=> 0.5
+length = default.zero? ? 0 : 100
+
+arr = Array.new(length, default)
+speq(arr, 'Either empty, all 1, or all -1').or?.empty?.xor?.include?(-1).include?(1)
+```
+
+#### Generated & built-in matchers
+
+If the object being tested responds to the method ending with `?`, then an appropriate matcher is automatically generated. As a result, existing methods such as `instance_of?`, `nil?`, or `empty?` can be used despite the fact that they are not in the list below.
+
+```ruby
+pass?(*description, &block)
+has?(*:message, **(message: val)) # alias: have?
+
+eq?(obj)   # result == obj
+case?(obj) # obj === result
+
+true?
+false?
+truthy?
+falsy?
+
+raise?('The following error message')
+raise?(ErrorClass)
+
+# Compound matchers
+either?(*matcher)  # matcher1 || matcher2 || ...
+neither?(*matcher) # !matcher1 || !matcher2 ||  ...
+
+```
+
+#### Matcher name precedence
+
+Parsing the name of a matcher gives highest precedence to the object being tested. For example, consider the following test:
+
+```ruby
+class Display
+  attr_reader :type
+
+  def initialize(type = :case)
+    @type = type.to_sym
+  end
+
+  def case?
+    @type == :case
+  end
+end
+
+window_display = Display.new('window')
+
+speq(window_display).not_case? # Will use Display#case
+on(window_display).is(:type).case?(Symbol) # Will use Speq#case?
+```
+
+To resolve `not_case?`, speq will do the following:
+
+1. Checks for the prefix `speq_`, reserved in case of name conflicts.
+2. Generates a matcher if the object responds to `not_case?`.
+3. Generates a matcher if the object responds to `case?` and applies prefixes.
+4. Uses the built-in `case?` and applies prefixes.
+
+### Additional Functionality
+
+#### Object Descriptions
+
+It may be advantageous to describe an object in advance such that, from there on, the report will automatically include the object description anytime that object is encountered.
+
+```ruby
+MyClass = Class.new
+
+call(MyClass, 'my class, an instance of the class Class')
+speq(MyClass).instance_of?(Class)
+
+# call tracks both object identity and object equality
+my_arr = []
+call(my_arr, 'a specific empty array')
+call([], 'an empty array')
+
+speq(my_arr).eq?([])
+
+# Passed (2/2)
+#  'my class, an instance of the class Class' is an instance of the class Class.
+#  'my specific empty array' equals 'an empty array'
+```
+
+#### Fakes
+
+Fakes are Speq's simple implementation of a test double. Most closely resembling a stub, fakes provide canned or computed responses, allowing for additional test isolation for objects that rely on objects not within the scope of testing.
+
+```ruby
+fake_bank = fake(
+  balance: 5000,
+  print_balance: '$50.00',
+  withdraw: proc {|amount| [50, amount].min }
+)
+```
+
+#### Subjects
+
+Speq has the distinct advantage of making it particularly easy to run many similar tests on the same subject.
+Opening a block on an action that has not been clo
+
+```ruby
+not_prime = [0, 1, 4, 6, 8, 9]
+prime = [2, 3, 5, 7]
+
+#
+does(:prime?) do
+  with[not_prime].false?
+  with[prime].true?
+end
+
+does(:my_sort) do
+  small_array = [3, 2, 1]
+  large_array = Array.new(10**6) {rand}
+
+  on(small_array).eq?(small_array.sort)
+  on(large_array).eq?(large_array.sort)
+end
+```
+
+#### Sugar
+
+```ruby
+# Action-Question Chains
+on('3 2 1')
+  << :split
+  << has?(length: 3)
+  << :map << with(&:to_i)
+  << :reduce << with(&:+)
+  << eq?(6)
+
+# Can start with the usual syntax and switch when convenient
+on(1..4).does(:to_a, :shuffle, :sort).eq?([1, 2, 3, 4])
+  << :sort << with { | a, b | b <=> a } << eq?([4, 3, 2, 1])
+
+# Broadcasting
+def add(a, b)
+  a + b
+end
+
+a = [1, 2, 3]
+b = [4, 5, 6]
+
+does(:add).with[a, b].eq?([5, 7, 9])
 ```
 
 ## Usage
 
-### Wherever you want
+### CLI: Speq Files
+
+Speq offers a simple CLI that lets you run tests written in dedicated spec files. This is the preferred way to run speq consistent with the examples shown above.
+
+Executing `speq` (or `bundle exec speq` if using bundle) will recursively search the working directory and run all files that end with `_speq.rb`.
+
+To run individual files, specify a list of speq file prefixes. For example, to run tests that are within the files `example_speq.rb` and `sample_speq.rb`, simply execute:
+
+    speq example sample
+
+Speq files only `require 'speq'` by default, so any external code being tested will still need to be required.
+
+### Anywhere: Speq.test
+
+Speq can be used anywhere as long as it is required and all tests are written within a block passed to Speq.test.
 
 ```ruby
 require 'speq'
 
-Speq.test do
-  # Tests here can access local variables.
-  # Test results are printed to $stdout.
-  # The method returns true if all tests pass, false otherwise.
+Speq.test(self) do | context |
+  # You can pass the surrounding context if needed.
+  # Calling 'report' prints the tests seen so far to $stdout.
+
+  # By default, Speq.test Returns the instance of Speq::Test created here.
+  # Using the return keyword, you can choose to return the following instead:
+  # 'return score': returns the proportion of tests passed as a Rational number
+  # 'return pass?': returns true or false for whether all the tests passed
 end
 ```
 
-### With dedicated spec files
+Speq can also be included to be used in a more direct manner. Here is an example of using Speq within another class for added functionality.
 
-Speq also offers a simple CLI that lets you run tests written in dedicated spec files.
+```ruby
+require 'speq'
 
-Executing `bundle exec speq` will recursively search the working directory and run all files that end with `_speq.rb`.
+class Exam
+  include Speq
 
-To run individual files, specify a list of speq file prefixes. For example, to run tests that are within the files `example_speq.rb` and `sample_speq.rb`, simply execute:
+  def initialize(questions)
+    @questions = questions
+  end
 
-    bundle exec speq example sample
+  def grade
+    @questions.each do | question |
+      speq(question.response, question.to_s).eq?(question.answer)
+    end
 
-Speq files are not expected to require `speq`, but they should require other files that may be needed to run the specs.
+    score
+  end
+end
+```
 
 ## Contributing
 

data/bin/console

@@ -4,5 +4,6 @@ require 'bundler/setup'
 require 'pry'
 
 require 'speq'
+include Speq
 
 Pry.start

data/exe/speq

@@ -1,4 +1,3 @@
 #!/usr/bin/env ruby
-
-require 'speq'
-Speq::CLI.new(ARGV).run
+require 'speq/cli'
+Speq::CLI.new(ARGV)

data/lib/speq.rb

@@ -4,26 +4,41 @@ require 'speq/matcher'
 require 'speq/report'
 require 'speq/unit'
 require 'speq/fake'
+require 'speq/action'
 require 'speq/cli'
 
 module Speq
+  @tests = [Test.new]
+  @descriptions = { Object => nil }
+
+  def self.test(&block)
+    self << Test.new
+    module_exec(&block)
+  end
+
+  def self.<<(test)
+    @tests << test
+  end
+
+  def self.descriptions
+    @descriptions
+  end
+
   module_function
 
-  def method_missing(method, *args)
-    if Matcher.respond_to?(method)
-      Matcher.send(method, *args)
+  def method_missing(method_name, *args, &block)
+    if Action.instance_methods.include?(method_name)
+      Action.new(@tests.last).send(method_name, *args, &block)
     else
       super
     end
   end
 
-  def unit_test(message, **kwargs)
-    matcher_method = kwargs.keys.find { |key| Matcher.respond_to?(key) }
-    matcher = send(matcher_method, kwargs[matcher_method])
-
-    unit = Unit.new(message, kwargs[:on], kwargs[:with], matcher)
-    Report.new([unit]).print_report
+  def report
+    Report.new(@tests).print_report
+  end
 
-    unit.passed?
+  def fake(**mapping)
+    Fake.new(mapping)
   end
 end

data/lib/speq/action.rb

@@ -0,0 +1,97 @@
+require 'speq'
+
+module Speq
+  class Action
+    attr_accessor :test_group, :message_queue, :receiver, :arguments_queue
+
+    def initialize(
+      test_group,
+      receiver = Object,
+      messages = [:itself],
+      arguments = [{ args: [], block: nil }]
+    )
+      @test_group = test_group
+
+      @message_queue = messages
+      @arguments_queue = arguments
+      @receiver = receiver
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s.end_with?('?')
+        matcher = Matcher.send(method, *args, &block)
+        @test_group << Unit.new(clone, matcher)
+      else
+        super
+      end
+    end
+
+    def clone
+      self.class.new(
+        test_group,
+        receiver,
+        message_queue.clone,
+        arguments_queue.clone
+      )
+    end
+
+    def result
+      until @message_queue.empty?
+        args = arguments_queue.shift
+        message = message_queue.shift
+
+        @receiver = receiver.send(message, *args[:args], &args[:block])
+      end
+
+      @receiver
+    end
+
+    def on(receiver, description = nil)
+      @receiver = receiver
+      Speq.descriptions[receiver] = description || receiver
+      self
+    end
+
+    def does(*messages)
+      messages.each do |message|
+        message_queue.push(message)
+        arguments_queue.push(args: [], block: nil)
+      end
+
+      self
+    end
+
+    def with(*args, &block)
+      arguments_queue.last[:args] = args
+      arguments_queue.last[:block] = block
+
+      self
+    end
+
+    def format_arguments
+      arguments = arguments_queue.last
+      argument_description = ''
+
+      unless arguments[:args].empty?
+        argument_description << "with '#{arguments[:args].join(', ')}'"
+      end
+
+      argument_description << ' and a block' if arguments[:block]
+
+      argument_description
+    end
+
+    def format_receiver
+      Speq.descriptions[receiver] ? "on '#{Speq.descriptions[receiver]}'" : ''
+    end
+
+    def to_s
+      [message_queue.last, format_arguments, format_receiver]
+        .reject(&:empty?)
+        .join(' ')
+    end
+
+    alias is does
+    alias of with
+  end
+end

data/lib/speq/cli.rb

@@ -1,14 +1,13 @@
+require 'speq'
 require 'find'
 require 'colorize'
 
 # Provides a CLI for running Speq
 module Speq
   class CLI
-    attr_accessor :tests
-
     def initialize(cli_args)
       @files = find_files(cli_args)
-      @tests = []
+      run
     end
 
     def find_files(file_prefixes)
@@ -19,8 +18,7 @@ module Speq
 
     def run
       @files.each { |file| Speq.module_eval(File.read(file), file) }
-      @tests.each(&:report)
-      @tests.all?(&:passed?)
+      Speq.report
     end
   end
 end

data/lib/speq/fake.rb

@@ -1,4 +1,4 @@
-# The Fake class inludes a variety of doubles, mocks, stubs, etc.
+# The Fake class is a lightweight, general-purpose test double
 module Speq
   class Fake
     def initialize(mapping)
@@ -14,5 +14,9 @@ module Speq
         -> { return_value }
       end
     end
+
+    def to_s
+      description = send(:class) == self.class ? 'a fake' : "a fake#{send(:class)}"
+    end
   end
 end

data/lib/speq/matcher.rb

@@ -2,31 +2,74 @@
 # respond to match, returning true for an expected return value of a unit test
 module Speq
   class Matcher
-    def initialize(expected)
-      @expected = expected
+    def initialize(expectation, phrase)
+      @expectation = expectation
+      @phrase = phrase
     end
 
-    def match(actual)
-      @expected[actual]
+    def match?(actual)
+      @actual = actual
+      @expectation[actual]
     end
 
-    def self.truthy
+    def to_s
+      @phrase[@actual]
+    end
+
+    def self.method_missing(method_name, *args, &block)
+      if method_name.to_s.end_with?('?')
+        dynamic_matcher(method_name, *args, &block)
+
+      else
+        super
+      end
+    end
+
+    def self.dynamic_matcher(method_name, *args, &block)
+      Matcher.new(
+        ->(object) { object.send(method_name, *args, &block) },
+        proc { "passes: #{method_name}" }
+      )
+    end
+
+    def self.pass?(&prc)
+      Matcher.new(prc)
+    end
+
+    def self.true?
+      Matcher.eq?(true)
+    end
+
+    def self.truthy?
       Matcher.new(->(actual_value) { actual_value ? true : false })
     end
 
-    def self.falsey
+    def self.falsy?
       Matcher.new(->(actual_value) { actual_value ? false : true })
     end
 
-    def self.eq(expected_value)
-      Matcher.new(->(actual_value) { expected_value.eql?(actual_value) })
+    def self.eq?(expected_value)
+      Matcher.new(
+        ->(actual_value) { expected_value.eql?(actual_value) },
+        ->(actual_value) { "equals #{actual_value}" }
+      )
     end
 
-    def self.is(expected_object)
-      Matcher.new(->(actual_object) { expected_object.equal?(actual_object) })
+    def self.have?(*symbols, **key_value_pairs)
+      new(
+        lambda do |object|
+          symbols.each { |symbol| return false unless object.respond_to?(symbol) }
+          key_value_pairs.each { |key, value| return false unless object.send(key) == value }
+        end,
+        proc do
+          properties = symbols.empty? ? '' : symbols.join(' ') + ', '
+          values = key_value_pairs.map { |key, value| "#{key}: #{value}" }.join(' ')
+          "has #{properties}#{values}"
+        end
+      )
     end
 
-    def self.raises(expected_except)
+    def self.raise?(expected_except)
       case expected_except
       when Class
         raise_class(expected_except)

data/lib/speq/report.rb

@@ -1,31 +1,24 @@
 # The Report class produces and prints a report per test group
 module Speq
   class Report
-    def initialize(units)
-      @units = units
+    def initialize(tests)
+      @units = tests.flat_map(&:units)
+      @passed = []
+      @failed = []
     end
 
     def print_report
-      report_string = ''
-
       @units.each do |unit|
         if unit.passed?
-          outcome = 'PASSED: '
-          color = :green
+          @passed << unit.to_s.colorize(:green)
         else
-          outcome = 'FAILED: '
-          color = :red
+          @failed << unit.to_s.colorize(:red)
         end
-
-        method = "calling '#{unit.message}' "
-        arguments = unit.arguments ? "with arguments: '#{unit.arguments}'" : ''
-        receiver = unit.receiver == Object ? '' : "on: #{unit.receiver} "
-
-        report_string <<
-          [outcome, method, arguments, receiver, "\n"].join.colorize(color)
       end
 
-      puts report_string
+      puts "Passed (#{@passed.length}/#{@units.length})" unless @passed.empty?
+      puts @passed
+      puts "Failed (#{@failed.length}/#{@units.length})" unless @failed.empty?
     end
   end
 end

data/lib/speq/test.rb

@@ -1,6 +1,10 @@
-# The Test class is a simple implementation of unit test block
+require 'speq/action'
+
+# A
 module Speq
   class Test
+    attr_reader :units
+
     def initialize
       @units = []
     end
@@ -8,5 +12,10 @@ module Speq
     def passed?
       @units.all?(&:passed?)
     end
+
+    def <<(unit)
+      @units << unit
+      self
+    end
   end
 end

data/lib/speq/unit.rb

@@ -1,20 +1,24 @@
+require 'speq/action'
+
 # The Unit class is responsible for running a test and storing the result
 module Speq
   class Unit
-    attr_reader :message, :receiver, :arguments
+    attr_reader :result, :action, :matcher
 
-    def initialize(message, receiver = Object, arguments = [], matcher)
-      @result = matcher.match(receiver.send(message, *arguments))
+    def initialize(action, matcher)
+      @action = action
+      @matcher = matcher
+      @result = matcher.match?(action.clone.result)
     rescue StandardError => exception
-      @result = matcher.match(exception)
-    ensure
-      @message = message
-      @receiver = receiver
-      @arguments = arguments
+      @result = matcher.match?(exception)
     end
 
     def passed?
       @result
     end
+
+    def to_s
+      "#{action} #{matcher}"
+    end
   end
 end

data/lib/speq/version.rb

@@ -1,3 +1,3 @@
 module Speq
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speq
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - zaniar moradian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-31 00:00:00.000000000 Z
+date: 2018-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,6 +84,7 @@ files:
 - bin/setup
 - exe/speq
 - lib/speq.rb
+- lib/speq/action.rb
 - lib/speq/cli.rb
 - lib/speq/fake.rb
 - lib/speq/matcher.rb