dry-matcher 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b7b475f9c2a102c0da7f6cf3422b8553e0f5d2f
+  data.tar.gz: 5c618057052448e4986233291fcadbe794c4b687
+SHA512:
+  metadata.gz: 93a241b0c7fd705e703f6f3b021cbcf19b3ef1f88eeb45605dfcb815daf670ab547e9f306178c8fa8859c0d190de3c13c99d4d6a9a319ee09f84328d744630b5
+  data.tar.gz: 0e3cc0b1df1587600fe864336d84fcbecf94432c363a279c0f0382c96dbd0542ddf0b1d9c5ba63d321e1bc450e44724e13db5dcb561f9ec227dbd154e33f1dda

data/CHANGELOG.md

@@ -0,0 +1,92 @@
+# 0.5.0 / 2016-06-30
+
+## Added
+
+- Added support for building custom matchers, with an any number of match cases, each offering their own matching and resolving logic. This is now the primary API for dry-matcher. (timriley)
+
+    ```ruby
+    # Match `[:ok, some_value]` for success
+    success_case = Dry::Matcher::Case.new(
+      match: -> value { value.first == :ok },
+      resolve: -> value { value.last }
+    )
+
+    # Match `[:err, some_error_code, some_value]` for failure
+    failure_case = Dry::Matcher::Case.new(
+      match: -> value, *pattern {
+        value[0] == :err && (pattern.any? ? pattern.include?(value[1]) : true)
+      },
+      resolve: -> value { value.last }
+    )
+
+    # Build the matcher
+    matcher = Dry::Matcher.new(success: success_case, failure: failure_case)
+
+    # Then put it to use
+    my_success = [:ok, "success!"]
+
+    result = matcher.(my_success) do |m|
+      m.success do |v|
+        "Yay: #{v}"
+      end
+
+      m.failure :not_found do |v|
+        "Oops, not found: #{v}"
+      end
+
+      m.failure do |v|
+        "Boo: #{v}"
+      end
+    end
+
+    result # => "Yay: success!"
+    ```
+
+## Changed
+
+- Renamed to `dry-matcher`, since this is now a flexible, general purpose pattern matching API. All components are now available under the `Dry::Matcher` namespace. (timriley)
+- `Dry::Matcher.for` requires a matcher object to be passed when being included in a class:
+
+    ```ruby
+    MyMatcher = Dry::Matcher.new(...)
+
+    class MyOperation
+      include Dry::Matcher.for(:call, with: MyMatcher)
+
+      def call
+      end
+    end
+    ```
+- The previous `Dry::ResultMatcher.match` behaviour (for matching `Either` monads) has been moved to `Dry::Matcher::EitherMatcher.call`
+
+# 0.4.0 / 2016-06-08
+
+## Added
+
+* Support convertible result objects responding to `#to_either` (ttdonovan)
+
+## Changed
+
+* Expect monads from [dry-monads](https://github.com/dry-rb/dry-monads) instead of [Kleisli](https://github.com/txus/kleisli) (ttdonovan)
+
+[Compare v0.3.0...v0.4.0](https://github.com/dry-rb/dry-result_matcher/compare/v0.3.0...v0.4.0)
+
+# 0.3.0 / 2016-03-23
+
+## Changed
+
+* Renamed to `dry-result_matcher`. Match results using `Dry::ResultMatcher.match` or extend your own classes with `Dry::ResultMatcher.for`.
+
+[Compare v0.2.0...v0.3.0](https://github.com/dry-rb/dry-result_matcher/compare/v0.2.0...v0.3.0)
+
+# 0.2.0 / 2016-02-10
+
+## Added
+
+* Added `EitherResultMatcher.for(*methods)` to return a module wrapping the specified methods (returning an `Either`) with the match block API. Example usage, in a class with a `#call` method: `include EitherResultMatcher.for(:call)`.
+
+[Compare v0.1.0...v0.22.0](https://github.com/dry-rb/dry-result_matcher/compare/v0.1.0...v0.2.0)
+
+# 0.1.0 / 2015-12-03
+
+Initial release.

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "codeclimate-test-reporter", "~> 0.5.0"
+  gem "dry-monads", "~> 0.0.2"
+end
+
+group :tools do
+  gem "byebug", platform: :mri
+  gem "pry"
+end

data/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2015-2016 [Icelab](http://icelab.com.au/).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+[gitter]: https://gitter.im/dry-rb/chat
+[gem]: https://rubygems.org/gems/dry-matcher
+[travis]: https://travis-ci.org/dry-rb/dry-matcher
+[code_climate]: https://codeclimate.com/github/dry-rb/dry-matcher
+[inch]: http://inch-ci.org/github/dry-rb/dry-matcher
+
+# dry-matcher [![Join the Gitter chat](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+
+[![Gem Version](https://img.shields.io/gem/v/dry-matcher.svg)][gem]
+[![Build Status](https://img.shields.io/travis/dry-rb/dry-matcher.svg)][travis]
+[![Code Climate](https://img.shields.io/codeclimate/github/dry-rb/dry-matcher.svg)][code_climate]
+[![Test Coverage](https://img.shields.io/codeclimate/coverage/github/dry-rb/dry-matcher.svg)][code_climate]
+[![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-matcher.svg)][inch]
+
+Flexible, expressive pattern matching for Ruby.
+
+## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-matcher)
+
+## License
+
+Copyright © 2015-2016 [Icelab](http://icelab.com.au/). dry-matcher is free software, and may be redistributed under the terms specified in the [license](LICENSE.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+task default: :spec

data/lib/dry-matcher.rb

@@ -0,0 +1 @@
+require "dry/matcher"

data/lib/dry/matcher.rb

@@ -0,0 +1,42 @@
+require "dry/matcher/case"
+require "dry/matcher/evaluator"
+
+module Dry
+  class Matcher
+    def self.for(*match_methods, with:)
+      matcher = with
+
+      matchers_mod = Module.new do
+        match_methods.each do |match_method|
+          define_method(match_method) do |*args, &block|
+            result = super(*args)
+
+            if block
+              matcher.(result, &block)
+            else
+              result
+            end
+          end
+        end
+      end
+
+      Module.new do
+        const_set :Matchers, matchers_mod
+
+        def self.included(klass)
+          klass.prepend const_get(:Matchers)
+        end
+      end
+    end
+
+    attr_reader :cases
+
+    def initialize(cases = {})
+      @cases = cases
+    end
+
+    def call(result, &block)
+      Evaluator.new(result, cases).call(&block)
+    end
+  end
+end

data/lib/dry/matcher/case.rb

@@ -0,0 +1,18 @@
+module Dry
+  class Matcher
+    class Case
+      def initialize(match:, resolve:)
+        @match = match
+        @resolve = resolve
+      end
+
+      def matches?(value, *pattern)
+        @match.(value, *pattern)
+      end
+
+      def resolve(value)
+        @resolve.(value)
+      end
+    end
+  end
+end

data/lib/dry/matcher/either_matcher.rb

@@ -0,0 +1,28 @@
+require "dry/matcher"
+
+module Dry
+  class Matcher
+    EitherMatcher = Dry::Matcher.new(
+      success: Case.new(
+        match: -> result, *pattern {
+          result = result.to_either
+          result.right?
+        },
+        resolve: -> result {
+          result = result.to_either
+          result.value
+        },
+      ),
+      failure: Case.new(
+        match: -> result, *pattern {
+          result = result.to_either
+          result.left?
+        },
+        resolve: -> result {
+          result = result.to_either
+          result.value
+        },
+      )
+    )
+  end
+end

data/lib/dry/matcher/evaluator.rb

@@ -0,0 +1,38 @@
+module Dry
+  class Matcher
+    class Evaluator < BasicObject
+      def initialize(result, cases)
+        @cases = cases
+        @result = result
+        @matched = false
+        @output = nil
+      end
+
+      def call
+        yield self
+        @output
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @cases.key?(name) || super
+      end
+
+      def method_missing(name, *args, &block)
+        return super unless @cases.key?(name)
+
+        handle_case @cases[name], *args, &block
+      end
+
+      private
+
+      def handle_case(kase, *pattern)
+        return @output if @matched
+
+        if kase.matches?(@result, *pattern)
+          @matched = true
+          @output = yield(kase.resolve(@result))
+        end
+      end
+    end
+  end
+end

data/lib/dry/matcher/version.rb

@@ -0,0 +1,5 @@
+module Dry
+  class Matcher
+    VERSION = "0.5.0".freeze
+  end
+end

data/spec/examples.txt

@@ -0,0 +1,14 @@
+example_id                                            | status | run_time        |
+----------------------------------------------------- | ------ | --------------- |
+./spec/integration/class_enhancement_spec.rb[1:1:1:1] | passed | 0.00016 seconds |
+./spec/integration/class_enhancement_spec.rb[1:1:2:1] | passed | 0.00013 seconds |
+./spec/integration/class_enhancement_spec.rb[1:2:1:1] | passed | 0.00022 seconds |
+./spec/integration/class_enhancement_spec.rb[1:2:2:1] | passed | 0.00141 seconds |
+./spec/integration/either_matcher_spec.rb[1:1:1:1]    | passed | 0.00008 seconds |
+./spec/integration/either_matcher_spec.rb[1:1:2:1]    | passed | 0.00008 seconds |
+./spec/integration/either_matcher_spec.rb[1:1:3:1:1]  | passed | 0.00015 seconds |
+./spec/integration/either_matcher_spec.rb[1:1:3:2:1]  | passed | 0.00016 seconds |
+./spec/integration/matcher_spec.rb[1:1:1]             | passed | 0.00013 seconds |
+./spec/integration/matcher_spec.rb[1:1:2]             | passed | 0.00012 seconds |
+./spec/integration/matcher_spec.rb[1:1:3:1]           | passed | 0.00015 seconds |
+./spec/integration/matcher_spec.rb[1:1:3:2]           | passed | 0.00224 seconds |

data/spec/integration/class_enhancement_spec.rb

@@ -0,0 +1,64 @@
+require "dry-monads"
+require "dry/matcher/either_matcher"
+
+RSpec.describe "Class enhancement with Dry::Matcher.for" do
+  let(:operation) {
+    Class.new do
+      include Dry::Matcher.for(:call, with: Dry::Matcher::EitherMatcher)
+
+      def call(bool)
+        bool ? Dry::Monads::Right("a success") : Dry::Monads::Left("a failure")
+      end
+    end.new
+  }
+
+  describe "match blocks" do
+    subject(:match) {
+      operation.call(input) do |m|
+        m.success do |v|
+          "Matched success: #{v}"
+        end
+
+        m.failure do |v|
+          "Matched failure: #{v}"
+        end
+      end
+    }
+
+    context "successful result" do
+      let(:input) { true }
+
+      it "matches on success" do
+        expect(match).to eq "Matched success: a success"
+      end
+    end
+
+    context "failed result" do
+      let(:input) { false }
+
+      it "matches on failure" do
+        expect(match).to eq "Matched failure: a failure"
+      end
+    end
+  end
+
+  describe "without match blocks" do
+    subject(:result) { operation.call(input) }
+
+    context "successful result" do
+      let(:input) { true }
+
+      it "returns the result" do
+        expect(result).to eq Dry::Monads::Right("a success")
+      end
+    end
+
+    context "failed result" do
+      let(:input) { false }
+
+      it "returns the result" do
+        expect(result).to eq Dry::Monads::Left("a failure")
+      end
+    end
+  end
+end

data/spec/integration/either_matcher_spec.rb

@@ -0,0 +1,56 @@
+require "dry-monads"
+require "dry/matcher/either_matcher"
+
+RSpec.describe "Dry::Matcher::EitherMatcher" do
+  describe "external matching" do
+    subject(:match) {
+      Dry::Matcher::EitherMatcher.(result) do |m|
+        m.success do |v|
+          "Matched success: #{v}"
+        end
+
+        m.failure do |v|
+          "Matched failure: #{v}"
+        end
+      end
+    }
+
+    context "successful result" do
+      let(:result) { Dry::Monads::Right("a success") }
+
+      it "matches on success" do
+        expect(match).to eq "Matched success: a success"
+      end
+    end
+
+    context "failed result" do
+      let(:result) { Dry::Monads::Left("a failure") }
+
+      it "matches on failure" do
+        expect(match).to eq "Matched failure: a failure"
+      end
+    end
+
+    context "result convertible to either" do
+      context "converts to success" do
+        let(:result) {
+          Dry::Monads::Try.lift([StandardError], -> { 'a success' })
+        }
+
+        it "matches on success" do
+          expect(match).to eq "Matched success: a success"
+        end
+      end
+
+      context "converts to failure" do
+        let(:result) {
+          Dry::Monads::Try.lift([StandardError], -> { raise('a failure') })
+        }
+
+        it "matches on failure" do
+          expect(match).to eq "Matched failure: a failure"
+        end
+      end
+    end
+  end
+end

data/spec/integration/matcher_spec.rb

@@ -0,0 +1,77 @@
+require "dry-monads"
+
+RSpec.describe Dry::Matcher do
+  context "with match cases provided" do
+    let(:success_case) {
+      Dry::Matcher::Case.new(
+        match: -> result { result.right? },
+        resolve: -> result { result.value },
+      )
+    }
+
+    let(:failure_case) {
+      Dry::Matcher::Case.new(
+        match: -> result { result.left? },
+        resolve: -> result { result.value },
+      )
+    }
+
+    let(:matcher) {
+      Dry::Matcher.new(
+        success: success_case,
+        failure: failure_case,
+      )
+    }
+
+    def call_match(input)
+      matcher.(input) do |m|
+        m.success do |v|
+          "Success: #{v}"
+        end
+
+        m.failure do |v|
+          "Failure: #{v}"
+        end
+      end
+    end
+
+    it "matches on success" do
+      input = Dry::Monads::Right("Yes!")
+      expect(call_match(input)).to eq "Success: Yes!"
+    end
+
+    it "matches on failure" do
+      input = Dry::Monads::Left("No!")
+      expect(call_match(input)).to eq "Failure: No!"
+    end
+
+    context "with patterns" do
+      let(:failure_case) {
+        Dry::Matcher::Case.new(
+          match: -> result, failure_type {
+            result.length == 3 && result[0] == :failure && result[1] == failure_type
+          },
+          resolve: -> result { result.last },
+        )
+      }
+
+      def call_match(input)
+        matcher.(input) do |m|
+          m.failure :my_error do |v|
+            "Pattern-matched failure: #{v}"
+          end
+        end
+      end
+
+      it "matches using the provided pattern" do
+        input = [:failure, :my_error, "No!"]
+        expect(call_match(input)).to eq "Pattern-matched failure: No!"
+      end
+
+      it "doesn't match if the pattern doesn't match" do
+        input = [:failure, :non_matching_error, "No!"]
+        expect(call_match(input)).to be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+if RUBY_ENGINE == "ruby"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+begin
+  require "byebug"
+rescue LoadError; end
+
+require "dry-matcher"
+
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each do |f| require f end
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4.
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # This option will default to `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output, unless a formatter
+    # has already been configured (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: dry-matcher
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Tim Riley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Flexible, expressive pattern matching for Ruby
+email:
+- tim@icelab.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/dry-matcher.rb
+- lib/dry/matcher.rb
+- lib/dry/matcher/case.rb
+- lib/dry/matcher/either_matcher.rb
+- lib/dry/matcher/evaluator.rb
+- lib/dry/matcher/version.rb
+- spec/examples.txt
+- spec/integration/class_enhancement_spec.rb
+- spec/integration/either_matcher_spec.rb
+- spec/integration/matcher_spec.rb
+- spec/spec_helper.rb
+homepage: http://dry-rb.org/gems/dry-matcher
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Flexible, expressive pattern matching for Ruby
+test_files: []
+has_rdoc: