prolog_minitest_matchers 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3432250c36aada7c4efaf78622e1c6f538ce804d
-  data.tar.gz: d312f4b46721223e8796c7b8a08b714335719fd3
+  metadata.gz: 81ac10d6ba50c569650a8228fcc14cec39504ee0
+  data.tar.gz: 397e377a53f73bcae18ae287c89b13b3e7728bd4
 SHA512:
-  metadata.gz: 9c5dcf648b266d338d43023504adcf61004828cca72b101deef1a373570cf010f7ebcf8a640c59fa7e3068713a06f5cdc9f86329648a23950df792bc7ff0e2b6
-  data.tar.gz: 09a985e617ed970d21f272838491612672ab8f6c59e7b2f700d8f4866ddd1ddb48b02deb54e5ce0bcce34522084ca4981b91d68d9f9e24cb98edb058fd3118e3
+  metadata.gz: '081234b6d44e0f0ce04f06da3fa88e6b70209d064062c2b693c21ed58ff49060597be8fe0f9fb85d78dacc35c67ad5282d3fdd9f8fcb2bd2be2a84e43037dca0'
+  data.tar.gz: de4ac96c56ca29e0b34be02bde9ea1a4a290916d1ee0dcafb0b1d45f145b5c191e758c6c8e17099fc80fa77f577526f1e459f3622f93e657638dae43ffa80576

data/README.md

@@ -2,7 +2,101 @@
 
 This is an evolving collection of MiniTest and MiniTest::Spec custom matchers which we have found useful in our work. As we have built up our applications, we've seen the disparity between *tests* and *assertions* grow; often to a differential of 30% or even more. While some standard MiniTest::Spec expectations involve multiple assertions, we can police our own.
 
-For example, we often have class API tests that look something like
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'prolog_minitest_matchers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install prolog_minitest_matchers
+## Usage
+
+As of Gem Release 0.3.0, this Gem defines three MiniTest::Spec expectations (and thus three MiniTest asserters) that can be used in your MiniTest code:
+
+1. `must_require_dry_struct_attribute` (`assert_requires_dry_struct_attribute`);
+2. `must_require_initialize_parameter` (`assert_requires_initialize_parameter`); and
+3. `must_require_static_call_param` (`assert_requires_static_call_param`).
+
+In each case, the expectation (through the implementing asserter) will verify that the parameter expected to cause a failure when omitted **must** exist in the supplied set of full parameters.
+
+### `must_require_dry_struct_attribute`
+
+Implemented by asserter `MiniTest::Assertions::AssertRequiresDryStructAttribute`.
+
+Suppose that you have code such as
+
+```ruby
+# in foo.rb
+class Foo < Dry::Types::Struct
+  attribute :foo, Types::Strict::String
+  attribute :bar, Types::Coercible.Int
+  # ...
+end
+```
+
+and test code such as
+
+```ruby
+# in foo_test.rb
+
+describe 'Foo' do
+  describe 'initialisation' do
+    describe 'requires parameters for' do
+      let(:params) { { foo: 'some foo', bar: 42 } }
+
+      it 'foo' do
+        params.delete :foo
+        error = expect { Foo.new params }.must_raise KeyError
+        expect(error.message).must_equal "No key :foo in #{params.inspect}!"
+      end
+
+      it 'bar' do
+        # ...
+      end
+    end # describe 'requires parameters for'
+  end # describe 'initialisation'
+
+  # ... other tests
+end
+```
+
+That parameter test has two expectations: first, that a `KeyError` will be raised; and second, that that error's message will be as expected. Instead, how about this:
+
+```ruby
+# in foo_test.rb
+
+describe 'Foo' do
+  describe 'initialisation requires parameters for' do
+    let(:params) { { foo: 'some foo', bar: 42 } }
+
+    it ':foo' do
+      expect(Foo).must_require_dry_struct_attribute params, :foo
+    end
+    
+    it ':bar' do
+      expect(Foo).must_require_dry_struct_attribute params, :bar
+    end
+  end # describe 'initialisation requires parameters for'
+
+  # ... other tests
+end
+```
+
+Somewhat shorter, yes; more importantly, two much more intention-revealing expectations that are counted as one assertion each. If you ascribe to the widely-used recommendation that each test (`it` block in MiniTest::Spec usage) should test one thing, this will have you wondering "how come my tests and assertions don't match up very well" just that little bit less.
+
+### `must_require_initialize_parameter`
+
+Implemented by asserter `MiniTest::Assertions::AssertRequiresInitializeParameter`.
+
+Again, suppose that you have code such as
 
 ```ruby
 # in foo.rb
@@ -13,7 +107,11 @@ class Foo
 
   # ...
 end
+```
+
+and test code such as
 
+```ruby
 # in foo_test.rb
 
 describe 'Foo' do
@@ -37,13 +135,11 @@ describe 'Foo' do
 
   # ... other tests
 end
-
 ```
 
-That parameter test has two expectations: first, that an `ArgumentError` will be raised; and second, that that error's message will be as expected. Instead, how about this:
+As before, that parameter test has two expectations: first, that an `ArgumentError` will be raised; and second, that that error's message will be as expected. Instead, we can now use this:
 
 ```ruby
-
 # in foo_test.rb
 
 describe 'Foo' do
@@ -65,45 +161,153 @@ describe 'Foo' do
 
   # ... other tests
 end
+```
+
+Again, two much more intention-revealing expectations that are counted as one assertion each.
+
+### `must_require_static_call_param`
 
+Implemented by asserter `MiniTest::Assertions::AssertRequiresInitializeParameter`.
+
+This is useful, not for initialisation in the traditional sense, but for service objects implementing a *class-level* `.call` interface that takes one or more named parameters. You might have code that looks like:
+
+```ruby
+# in foo.rb
+class Foo
+  def self.call(foo:, bar:)
+    Foo.new(foo, bar).call
+  end
+  
+  def call
+    # ...
+  end
+  
+  protected
+  
+  def initialize(foo, bar)
+    @foo = massage_initial_foo_with foo
+    @bar = massage_initial_bar_with bar
+    self
+  end
+  
+  private
+  
+  attr_reader :bar, :foo
+  # ...
+end
 ```
 
-Two expectations; two assertions; two much more *intention-revealing* expectations.
+and test code such as
 
-## Installation
+```ruby
+# in foo_test.rb
 
-Add this line to your application's Gemfile:
+describe 'Foo' do
+  describe 'initialisation' do
+    describe 'requires parameters for' do
+      let(:params) { { foo: 'some foo', bar: 'some bar' } }
+
+      it 'foo' do
+        params.delete :foo
+        error = expect { Foo.new params }.must_raise KeyError
+        expect(error.message).must_equal "No key :foo in #{params.inspect}!"
+      end
+
+      it 'bar' do
+        # ...
+      end
+    end
+
+    # ... other initialisation tests
+  end
+
+  # ... other tests
+end
+```
+
+As before, that parameter test has two expectations: first, that a `KeyError` will be raised; and second, that that error's message will be as expected. We can use this instead:
 
 ```ruby
-gem 'prolog_minitest_matchers'
+# in foo_test.rb
+
+describe 'Foo' do
+  describe 'initialisation' do
+    describe 'requires parameters for' do
+      let(:params) { { foo: 'some foo', bar: 'some bar' } }
+
+      it 'foo' do
+        expect(Foo).must_require_static_call_param params, :foo
+      end
+
+      it 'bar' do
+        expect(Foo).must_require_static_call_param params, :bar
+      end
+    end
+
+    # ... other initialisation tests
+  end
+
+  # ... other tests
+end
 ```
 
-And then execute:
+Once again, two much more intention-revealing expectations that are counted as one assertion each.
 
-    $ bundle
+### Notes on Implementation
 
-Or install it yourself as:
+Attentive readers may note the strong similarity between these three expectations. They would be right; although the use cases differ in important ways, the implementation details that set each apart from the others have been reduced to a minimum, as inspecting the code itself will reveal. See some room for improvement? Great! Open an issue and let's talk about it!
 
-    $ gem install prolog_minitest_matchers
 
-## Usage
+## Errata
+
+### Reversing MiniTest::Spec expectations does not work (Issue [#1](https://github.com/TheProlog/prolog_minitest_matchers/issues/1))
 
-See the discussion at the top of this page for a description of how to use the `must_require_initialize_parameter` expectation, which is a MiniTest::Spec wrapper around the `assert_requires_initialize_parameter` MiniTest assertion.
+Ordinarily, MiniTest::Spec matchers provide reversible expectations; that is, expectations can be positive (`must_`) *or* negative (`won't_`). For a trivial example,
+
+```ruby
+expect(2 + 2).must_equal 4
+expect(2 + 2).wont_equal 5
+```
 
-Note that this assertion will verify that the parameter expected to fail when removed must exist in the full set of parameters specified.
+The same "asserter" code is being exercised, and fails if the asserted condition is false (for `must_equal`) or true (for `wont_equal`).
 
-As other assertions/expectations are added to this Gem over the next few weeks, *including* formal test coverage of the asserters and expectations themselves, this usage information will be broken out into a separate document. Stay tuned &ndash; or open a pull request!
+None of the matchers included as part of Gem Release 0.3.0 (`must_require_dry_struct_attribute`, `must_require_initialize_parameter`, and `must_require_static_call_param`) are reversible in this way. Given the expected use cases of these matchers, this has been judged to be acceptable; the issue has been left open but labelled `wontfix`. (PRs welcome).
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies (which as of now must already be installed on your local system). Then, run `bin/rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies (which as of now must already be installed on your local system). Then, run `bin/rake test` to run the tests, or `bin/rake` to run tests and, if tests are successful, further static-analysis tools ([RuboCop](https://github.com/bbatsov/rubocop), [Flay](https://github.com/seattlerb/flay), [Flog](https://github.com/seattlerb/flog), and [Reek](https://github.com/troessner/reek)).
 
-To install this gem onto your local machine, run `bin/rake install`. Maintainers should be familiar with the standard procedure for releasing an updated Gem version to RubyGems.
+To install *your build* of this Gem onto your local machine, run `bin/rake install`. We recommend that you uninstall any previously-installed "official" Gem to increase your confidence that your tests are running against your build.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/prolog_minitest_matchers. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/TheProlog/prolog_minitest_matchers. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+### Process
+
+If you wish to submit a new feature, such as a new matcher, to the Gem, please [open an issue](https://github.com/TheProlog/prolog_minitest_matchers/issues/new) to discuss your idea with the maintainer and other interested community members. Issue threads are a great place to thrash out the details of what you're trying to accomplish and how your work would affect other code and/or community members. If you need help with something, or aren't sure how to choose between different ideas to accomplish some detail of what you're setting out to do, this is the place to discuss that. There is *no such thing as a stupid question that you don't know the answer to* (once you've researched in your search engine of choice, of course; please do respect people's time and attention).
+
+The processes for proposing a new feature or a fix to an open bug-report issue are very similar:
+
+1. Make sure that you have forked this Gem's [repository on GitHub](https://github.com/TheProlog/prolog_minitest_matchers) to your own GitHub account. (If you don't yet have a GitHub account, [join](https://github.com/join?source=header-home); it's free.)
+2. If you're proposing a new feature, [open an issue](https://github.com/TheProlog/prolog_minitest_matchers/issues/new) as suggested above. If you're addressing an existing issue, *thanks;* you don't need to open a new one.
+3. Clone *your* copy of the repo to your local development system.
+4. Create a new Git branch for your work. It's best to give it a reasonably short name that's suggestive of what you're specifically trying to accomplish.
+   1. If you're adding a new feature, such as a new matcher, consider that `dry-struct-attribute` was a more useful branch name for the `must_require_static_call_param` matcher than, say, `my-new-matcher` for (hopefully) obvious reasons.
+   2. If you're adding a fix for an existing issue, say Issue #4172, then a branch name of `issue-4172` is probably perfect.
+   3. **Do not** work on your copy of the `master` branch! Any pull request (see below) that you later submit for changes you've made on `master` will be rejected, and you will be asked to submit your proposed changes on a branch that branches from a commit on the upstream `master` branch.
+5. Now write great (tests and) code!
+6. As soon as you have something to show, *even if it's not complete yet* (but it passes what tests you have), [push your branch](https://help.github.com/articles/pushing-to-a-remote/) to *your forked repo* on GitHub and open a [new pull request](https://github.com/TheProlog/prolog_minitest_matchers/compare) ("PR") for *your branch* compared to `master` on the [upstream](https://github.com/TheProlog/prolog_minitest_matchers/) repository. That lets the maintainer and other community members review your code and tests, comment, help out, and so on.
+7. Continuing with your pull requests, it's usually better if you make small, incremental changes in each commit in a sequence. We (endeavour to) practice [behaviour-driven development](https://en.wikipedia.org/wiki/Behavior-driven_development): write tests for the simplest thing that could possibly work; see the tests fail; then make them pass, commit, and go on to the next simplest thing. Don't get hung up on lots of refactoring until you have code that does everything you want it to do; once you have a legitimately complete green bar, *that's* the time to apply SOLID principles and patterns to DRY things up. Better to have (temporary) duplication than choose the wrong abstraction.
+
+### Notes on Contributing
+
+Don't be discouraged if it takes several commits to complete your work and then several more to get everybody agreeing that it's complete and well done. ("Useful" and "worth adding" should have been settled at the issue stage, before you started working on your PR.) That's because…
+
+When pull requests are *merged* into the `master` branch, they are *squashed* so that all changes are applied to `master` in a single commit. This means that, even if you have a dozen or more commits in your PR where you've been *very* incremental, and even changed direction once or twice, what matters is the final result; not what it took to get there.
+
+Once your PR has been merged, it's a good idea to pull the upstream `master` branch to your development system (`git pull upstream master`) and then push it to your fork (`git push origin master`). (What? You don't *have* an `upstream` remote as shown by `git remote -v`? Run the command `git remote add upstream https://github.com/TheProlog/prolog_minitest_matchers.git` from your local development directory, and now you do.)
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The Gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/config.reek

@@ -2,7 +2,7 @@
 LongParameterList:
   max_params: 4  # If it's good enough for Sandi, it's good enough for us.
 
-# NestedIterators:
-#   max_allowed_nesting: 2
-#   ignore_iterators:
-#     - lambda
+NestedIterators:
+  max_allowed_nesting: 2
+  ignore_iterators:
+    - lambda

data/lib/prolog_minitest_matchers/matchers/asserters/assert_requires_dry_struct_attribute.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+require_relative './base_assert_required_parameter'
+
+module MiniTest
+  # Adding custom assertions to make specs easier to read
+  module Assertions
+    # Actual test logic for `#assert_requires_struct_attribute`.
+    class AssertRequiresDryStructAttribute < BaseAssertRequiredParameter
+      private
+
+      def default_message_for(param_key)
+        "] :#{param_key} is missing in Hash input"
+      end
+
+      def error_class
+        Dry::Types::StructError
+      end
+
+      def error_inducer
+        -> { klass.new params }
+      end
+    end # class MiniTest::Assertions::AssertRequiresDryStructAttribute
+  end
+end

data/lib/prolog_minitest_matchers/matchers/asserters/assert_requires_initialize_parameter.rb

@@ -1,68 +1,24 @@
 # frozen_string_literal: true
 
+require_relative './base_assert_required_parameter'
+
 module MiniTest
   # Adding custom assertions to make specs easier to read
   module Assertions
     # Actual test logic for `#assert_requires_initialize_parameter`.
-    class AssertRequiresInitializeParameter
-      def initialize(klass, full_params, param_key, message)
-        @klass = klass
-        @full_params = full_params
-        @param_key = param_key
-        @message = initial_message_from(message, param_key)
-        self
-      end
-
-      def call(assert)
-        assert.call(errors_as_expected(save_and_try_to_init), message)
-      end
-
+    class AssertRequiresInitializeParameter < BaseAssertRequiredParameter
       private
 
-      attr_reader :full_params, :klass, :message, :param_key
-
-      def errors_as_expected(errors)
-        errors[:expected]&.message == message
-      end
-
-      def filtered_params
-        full_params.dup.reject { |source_key, _| source_key == param_key }
-      end
-
-      # Running Reek will complain about a :reek:ControlParameter. Protocol is.
-      def initial_message_from(message, param_key)
-        message || "missing keyword: #{param_key}"
-      end
-
-      def save_and_try_to_init
-        verify_param_in_list
-        save_and_delete_param_before { |params| try_to_init params }
-      end
-
-      def save_and_delete_param_before
-        yield filtered_params
-      end
-
-      def try_to_init(params)
-        expected_error = nil
-        begin
-          klass.new params
-        rescue ArgumentError => error
-          expected_error = error
-        end
-        { expected: expected_error }
-      end
-
-      def verify_param_in_list
-        raise KeyError, no_param_message unless param_in_full_list?
+      def default_message_for(param_key)
+        "missing keyword: #{param_key}"
       end
 
-      def no_param_message
-        "No key :#{param_key} in #{full_params}!"
+      def error_class
+        ArgumentError
       end
 
-      def param_in_full_list?
-        full_params.key? param_key
+      def error_inducer
+        -> { klass.new params }
       end
     end # class MiniTest::Assertions::AssertRequiresInitializeParameter
   end

data/lib/prolog_minitest_matchers/matchers/asserters/assert_requires_static_call_param.rb

@@ -1,73 +1,24 @@
 # frozen_string_literal: true
 
+require_relative './base_assert_required_parameter'
+
 module MiniTest
   # Adding custom assertions to make specs easier to read
   module Assertions
     # Actual test logic for `#assert_requires_static_call_paramr`.
-    class AssertRequiresStaticCallParam
-      def initialize(klass, full_params, param_key, message)
-        @klass = klass
-        @full_params = full_params
-        @param_key = param_key
-        @message = initial_message_from(message, param_key)
-        self
-      end
-
-      def call(assert)
-        verify_param_in_list(assert)
-        assert.call(errors_as_expected(save_and_try_to_call), message)
-      end
-
+    class AssertRequiresStaticCallParam < BaseAssertRequiredParameter
       private
 
-      attr_reader :full_params, :klass, :message, :param_key
-
-      def errors_as_expected(errors)
-        errors[:expected]&.message == message
-      end
-
-      def filtered_params
-        full_params.dup.reject { |source_key, _| source_key == param_key }
-      end
-
-      # Running Reek will complain about a :reek:ControlParameter. Protocol is.
-      def initial_message_from(message, param_key)
-        message || "missing keyword: #{param_key}"
-      end
-
-      def key_not_found_message
-        "Key :#{param_key} not found in #{full_params}!"
-      end
-
-      def save_and_try_to_call
-        save_and_delete_param_before { |params| try_to_call params }
-        # saved_item = full_params[param_key]
-        # full_params.delete param_key
-        # errors = try_to_call
-        # full_params[param_key] = saved_item
-        # errors
-      end
-
-      def try_to_call(params)
-        expected_error = nil
-        begin
-          klass.call params
-        rescue ArgumentError => error
-          expected_error = error
-        end
-        { expected: expected_error }
-      end
-
-      def save_and_delete_param_before
-        yield filtered_params
+      def default_message_for(param_key)
+        "missing keyword: #{param_key}"
       end
 
-      def verify_param_in_list(assert)
-        assert.call(param_in_list?, key_not_found_message)
+      def error_class
+        ArgumentError
       end
 
-      def param_in_list?
-        full_params.key?(param_key)
+      def error_inducer
+        -> { klass.call params }
       end
     end # class MiniTest::Assertions::AssertRequiresStaticCallParam
   end

data/lib/prolog_minitest_matchers/matchers/asserters/base_assert_required_parameter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative './induce_error'
+require_relative './verify_key_in_hash'
+
+module MiniTest
+  # Adding custom assertions to make specs easier to read
+  module Assertions
+    # Base assertion class to verify error raised when parameter omitted.
+    class BaseAssertRequiredParameter
+      def initialize(klass, params, param_key, message)
+        message ||= default_message_for(param_key)
+        @params = Internals.hash_without_key(params, param_key)
+        @klass = klass
+        @param_key = param_key
+        @message = message
+        self
+      end
+
+      def call(assert)
+        assert.call(correct_error_message?, message)
+      end
+
+      private
+
+      attr_reader :params, :klass, :message, :param_key
+
+      def actual_error_message
+        errors[:expected]&.message
+      end
+
+      def correct_error_message?
+        actual_error_message.match message
+      end
+
+      def errors
+        InduceError.call error_class: error_class, inducer: error_inducer
+      end
+
+      # Methods that neither affect nor are affected by instance state.
+      module Internals
+        def self.hash_without_key(hash, key)
+          VerifyKeyInHash.call hash, key
+          hash.dup.reject { |source_key, _| source_key == key }
+        end
+      end
+      private_constant :Internals
+    end # class MiniTest::Assertions::BaseAssertRequiredParameter
+  end
+end

data/lib/prolog_minitest_matchers/matchers/asserters/induce_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Attempt to induce a specified failure, and report if successful or not.
+class InduceError
+  def self.call(error_class:, inducer:)
+    InduceError.new(error_class, inducer).call
+  end
+
+  def call
+    expected_error = nil
+    begin
+      inducer.call
+    rescue error_class => error
+      expected_error = error
+    end
+    { expected: expected_error }
+  end
+
+  protected
+
+  def initialize(error_class, inducer)
+    @error_class = error_class
+    @inducer = inducer
+    self
+  end
+
+  private
+
+  attr_reader :error_class, :inducer
+end # class InduceError

data/lib/prolog_minitest_matchers/matchers/asserters/verify_key_in_hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Used to validate incoming parameter hash.
+class VerifyKeyInHash
+  def self.call(hash, key)
+    VerifyKeyInHash.new(hash, key).call
+  end
+
+  def call
+    raise KeyError, no_key_message unless key_in_hash?
+  end
+
+  protected
+
+  def initialize(hash, key)
+    @hash = hash
+    @key = key
+    self
+  end
+
+  private
+
+  attr_reader :hash, :key
+
+  def key_in_hash?
+    hash.key? key
+  end
+
+  def no_key_message
+    "No key :#{key} in #{hash}!"
+  end
+end # class VerifyKeyInHash

data/lib/prolog_minitest_matchers/matchers/requires_dry_struct_attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'minitest/spec'
+
+require_relative './asserters/assert_requires_dry_struct_attribute'
+
+module MiniTest
+  # Adding custom assertions to make specs easier to read
+  module Assertions
+    def assert_requires_dry_struct_attribute(klass, full_params, param_key,
+                                             message = nil)
+      AssertRequiresDryStructAttribute.new(klass, full_params, param_key,
+                                           message).call(method(:assert))
+    end
+  end
+
+  # Make it available to MiniTest::Spec
+  module Expectations
+    infect_an_assertion :assert_requires_dry_struct_attribute,
+                        :must_require_dry_struct_attribute, :reverse
+  end
+end

data/lib/prolog_minitest_matchers/version.rb

@@ -2,5 +2,5 @@
 
 # Module to satisfy Gem requirements; nothing inside but version-spec constant.
 module PrologMinitestMatchers
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/prolog_minitest_matchers.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'prolog_minitest_matchers/version'
+require 'prolog_minitest_matchers/matchers/requires_dry_struct_attribute'
 require 'prolog_minitest_matchers/matchers/requires_initialize_parameter'
+require 'prolog_minitest_matchers/matchers/requires_static_call_param'
 
 # Module to satisfy Gem requirements; nothing inside but version-spec constant.
 module PrologMinitestMatchers

data/prolog_minitest_matchers.gemspec

@@ -27,6 +27,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "dry-types", "~> 0.7", ">= 0.7.2"
+
   spec.add_development_dependency "bundler", "~> 1.12", ">= 1.12.5"
   spec.add_development_dependency "rake", "~> 11.2", ">= 11.2.2"
   spec.add_development_dependency "minitest", "~> 5.9", ">= 5.9.0"

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: prolog_minitest_matchers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeff Dickey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-26 00:00:00.000000000 Z
+date: 2016-07-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -187,8 +207,13 @@ files:
 - Rakefile
 - config.reek
 - lib/prolog_minitest_matchers.rb
+- lib/prolog_minitest_matchers/matchers/asserters/assert_requires_dry_struct_attribute.rb
 - lib/prolog_minitest_matchers/matchers/asserters/assert_requires_initialize_parameter.rb
 - lib/prolog_minitest_matchers/matchers/asserters/assert_requires_static_call_param.rb
+- lib/prolog_minitest_matchers/matchers/asserters/base_assert_required_parameter.rb
+- lib/prolog_minitest_matchers/matchers/asserters/induce_error.rb
+- lib/prolog_minitest_matchers/matchers/asserters/verify_key_in_hash.rb
+- lib/prolog_minitest_matchers/matchers/requires_dry_struct_attribute.rb
 - lib/prolog_minitest_matchers/matchers/requires_initialize_parameter.rb
 - lib/prolog_minitest_matchers/matchers/requires_static_call_param.rb
 - lib/prolog_minitest_matchers/version.rb
@@ -219,3 +244,4 @@ signing_key:
 specification_version: 4
 summary: Custom Minitest matcher(s) we've developed for our own use.
 test_files: []
+has_rdoc: