qo 0.5.0 → 0.99.0

data/lib/qo/version.rb

@@ -1,3 +1,3 @@
 module Qo
-  VERSION = '0.5.0'
+  VERSION = '0.99.0'
 end

data/qo.gemspec

@@ -13,6 +13,17 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://www.github.com/baweaver/qo"
   spec.license       = "MIT"
 
+  spec.post_install_message = <<~MESSAGE
+    Qo 0.99.0 is the last version of Qo under the official name "Qo". After this
+    version, Qo will be adopted into dry-rb (https://dry-rb.org/) as the new
+    dry-matcher.
+
+    As I'm fond of the name, "Qo" will remain an alias for "Dry::Matcher"
+    so you can use it as you have before. Qo v0.99.0 and Dry Matcher v1.0.0
+    will be directly compatible with eachother, and semantic versioning will
+    take over from there.
+  MESSAGE
+
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qo
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.99.0
 platform: ruby
 authors:
 - Brandon Weaver
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-09 00:00:00.000000000 Z
+date: 2019-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -206,13 +206,23 @@ files:
 - img/qo_logo.png
 - img/whoa_lemur.png
 - lib/qo.rb
+- lib/qo/branches/branch.rb
+- lib/qo/branches/branches.rb
+- lib/qo/branches/else_branch.rb
+- lib/qo/branches/error_branch.rb
+- lib/qo/branches/failure_branch.rb
+- lib/qo/branches/monadic_else_branch.rb
+- lib/qo/branches/monadic_when_branch.rb
+- lib/qo/branches/success_branch.rb
+- lib/qo/branches/when_branch.rb
+- lib/qo/destructurers/destructurer.rb
+- lib/qo/destructurers/destructurers.rb
 - lib/qo/exceptions.rb
-- lib/qo/helpers.rb
-- lib/qo/matchers/array_matcher.rb
-- lib/qo/matchers/base_matcher.rb
-- lib/qo/matchers/guard_block_matcher.rb
-- lib/qo/matchers/hash_matcher.rb
-- lib/qo/matchers/pattern_match.rb
+- lib/qo/matchers/matcher.rb
+- lib/qo/pattern_matchers/branching.rb
+- lib/qo/pattern_matchers/pattern_match.rb
+- lib/qo/pattern_matchers/pattern_matchers.rb
+- lib/qo/pattern_matchers/result_pattern_match.rb
 - lib/qo/public_api.rb
 - lib/qo/version.rb
 - performance_report.txt
@@ -221,7 +231,15 @@ homepage: https://www.github.com/baweaver/qo
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |
+  Qo 0.99.0 is the last version of Qo under the official name "Qo". After this
+  version, Qo will be adopted into dry-rb (https://dry-rb.org/) as the new
+  dry-matcher.
+
+  As I'm fond of the name, "Qo" will remain an alias for "Dry::Matcher"
+  so you can use it as you have before. Qo v0.99.0 and Dry Matcher v1.0.0
+  will be directly compatible with eachother, and semantic versioning will
+  take over from there.
 rdoc_options: []
 require_paths:
 - lib
@@ -236,8 +254,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Qo is a querying library for Ruby pattern matching

data/lib/qo/helpers.rb

@@ -1,44 +0,0 @@
-module Qo
-  module Helpers
-    # A curried variant of Hash#dig meant to be passed as a matcher util.
-    #
-    # @note This method will attempt to coerce path segments to Symbols
-    #       if unsuccessful in first dig.
-    #
-    # @param path_map [String]
-    #   Dot-delimited path
-    #
-    # @param expected_value [Any]
-    #   Matcher
-    #
-    # @return [Proc]
-    #     Hash -> Bool # Status of digging against the hash
-    def dig(path_map, expected_value)
-      Proc.new { |hash|
-        segments = path_map.split('.')
-
-        expected_value === hash.dig(*segments) ||
-        expected_value === hash.dig(*segments.map(&:to_sym))
-      }
-    end
-
-    # Counts by a function. This is entirely because I hackney this everywhere in
-    # pry anyways, so I want a function to do it for me already.
-    #
-    # @param targets [Array[Any]]
-    #   Targets to count
-    #
-    # @param &fn [Proc]
-    #   Function to define count key
-    #
-    # @return [Hash[Any, Integer]]
-    #   Counts
-    def count_by(targets, &fn)
-      fn ||= -> v { v }
-
-      targets.each_with_object(Hash.new(0)) { |target, counts|
-        counts[fn[target]] += 1
-      }
-    end
-  end
-end

data/lib/qo/matchers/array_matcher.rb

@@ -1,99 +0,0 @@
-module Qo
-  module Matchers
-    # An Array Matcher is a matcher that uses only `*varargs` to define a sequence
-    # of matches to perform against either an object or another Array.
-    #
-    # In the case of an Array matching against an Array it will compare via index.
-    #
-    # ```ruby
-    # # Shorthand
-    # Qo[1..10, 1..10].call([1, 2])
-    # # => true
-    #
-    # Qo::Matchers::ArrayMatcher.new([1..10, 1..10]).call([1, 2])
-    # # => true
-    # ```
-    #
-    # It should be noted that arrays of dissimilar size will result in an instant
-    # false return value. If you wish to do a single value match, simply use the
-    # provided `Any` type as such:
-    #
-    # ```ruby
-    # array.select(&Any)
-    # ```
-    #
-    # In the case of an Array matching against an Object, it will match each provided
-    # matcher against the object.
-    #
-    # ```ruby
-    # # Shorthand
-    # Qo[Integer, 1..10].call(1)
-    # # => true
-    #
-    # Qo::Matchers::ArrayMatcher.new([1..10, 1..10]).call(1)
-    # # => true
-    # ```
-    #
-    # All variants present in the BaseMatcher are present here, including 'and',
-    # 'not', and 'or'.
-    #
-    # @author baweaver
-    # @since 0.2.0
-    #
-    class ArrayMatcher < BaseMatcher
-      def initialize(type, array_matchers)
-        @array_matchers = array_matchers
-        @type           = type
-      end
-
-      # Wrapper around call to allow for invocation in an Enumerable function,
-      # such as:
-      #
-      # ```ruby
-      # people.select(&Qo[/Foo/, 20..40])
-      # ```
-      #
-      # @return [Proc[Any]]
-      #   Proc awaiting a target to match against
-      def to_proc
-        Proc.new { |target| self.call(target) }
-      end
-
-      # Runs the matcher directly.
-      #
-      # If the target is an Array, it will be matched via index
-      #
-      # If the target is an Object, it will be matched via public send
-      #
-      # @param target [Any] Target to match against
-      #
-      # @return [Boolean] Result of the match
-      def call(target)
-        return true if @array_matchers == target
-
-        if target.is_a?(::Array)
-          return false unless target.size == @array_matchers.size
-
-          match_with(@array_matchers.each_with_index) { |matcher, i|
-            match_value?(target[i], matcher)
-          }
-        else
-          match_with(@array_matchers) { |matcher|
-            match_value?(target, matcher)
-          }
-        end
-      end
-
-      # Defines what it means for a value to match a matcher
-      #
-      # @param target  [Any] Target to match against
-      # @param matcher [Any] Any matcher to run against, most frequently responds to ===
-      #
-      # @return [Boolean] Match status
-      private def match_value?(target, matcher)
-        case_match?(target, matcher) ||
-        method_matches?(target, matcher)
-      end
-    end
-  end
-end

data/lib/qo/matchers/base_matcher.rb

@@ -1,110 +0,0 @@
-module Qo
-  # A Qo Matcher is a class that acts like a Proc. It takes in a set of match
-  # values or key value pairs and a target value to evaluate against, and returns
-  # the status of that match.
-  #
-  # It is possible to override this behavior via `to_proc` overloading and
-  # utilization of `super` as noted in `GuardBlockMatcher`.
-  #
-  # @see Qo::Matchers::GuardBlockMatcher
-  #
-  # @author baweaver
-  # @since 0.2.0
-  #
-  module Matchers
-    # Base instance of matcher which is meant to take in either Array style or
-    # Keyword style arguments to run a match against various datatypes.
-    #
-    # Will delegate responsibilities to either Array or Hash style matchers if
-    # invoked directly.
-    #
-    # @author baweaver
-    # @since 0.2.0
-    #
-    class BaseMatcher
-      def initialize(type, array_matchers, keyword_matchers)
-        @type = type
-
-        @full_matcher = array_matchers.empty? ?
-          Qo::Matchers::HashMatcher.new(type, keyword_matchers) :
-          Qo::Matchers::ArrayMatcher.new(type, array_matchers)
-      end
-
-      # Converts a Matcher to a proc for use in querying, such as:
-      #
-      #     data.select(&Qo[...])
-      #
-      # @return [Proc[Any]]
-      def to_proc
-        @full_matcher.to_proc
-      end
-
-      # You can directly call a matcher as well, much like a Proc,
-      # using one of call, ===, or []
-      #
-      # @param target [Any] Object to match against
-      #
-      # @return [Boolean] Result of the match
-      def call(target)
-        @full_matcher.call(target)
-      end
-
-      alias_method :===, :call
-      alias_method :[],  :call
-      alias_method :match?,  :call
-
-      # Runs the relevant match method against the given collection with the
-      # given matcher function.
-      #
-      # @param collection [Enumerable] Any collection that can be enumerated over
-      # @param fn         [Proc]       Function to match with
-      #
-      # @return [Boolean] Result of the match
-      private def match_with(collection, &fn)
-        case @type
-        when 'and' then collection.all?(&fn)
-        when 'or'  then collection.any?(&fn)
-        when 'not' then collection.none?(&fn)
-        else false
-        end
-      end
-
-      # Wraps a case equality statement to make it a bit easier to read. The
-      # typical left bias of `===` can be confusing reading down a page, so
-      # more of a clarity thing than anything. Also makes for nicer stack traces.
-      #
-      # @param target  [Any]
-      #   Target to match against
-      # @param matcher [#===]
-      #   Anything that responds to ===, preferably in a unique and entertaining way.
-      #
-      # @return [Boolean]
-      private def case_match?(target, matcher)
-        matcher === target
-      end
-
-      # Guarded version of `public_send` meant to stamp out more
-      # obscure errors when running against non-matching types.
-      #
-      # @param target  [Any] Object to send to
-      # @param matcher [#to_sym] Anything that can be coerced into a method name
-      #
-      # @return [Any] Response of sending to the method, or false if failed
-      private def method_send(target, matcher)
-        matcher.respond_to?(:to_sym) &&
-        target.respond_to?(matcher.to_sym) &&
-        target.public_send(matcher)
-      end
-
-      # Predicate variant of `method_send` with the same guard concerns
-      #
-      # @param target  [Any]     Object to send to
-      # @param matcher [#to_sym] Anything that can be coerced into a method name
-      #
-      # @return [Boolean] Success status of predicate
-      private def method_matches?(target, matcher)
-        !!method_send(target, matcher)
-      end
-    end
-  end
-end

data/lib/qo/matchers/guard_block_matcher.rb

@@ -1,91 +0,0 @@
-module Qo
-  module Matchers
-    # A GuardBlockMatcher is like a regular matcher, except in that if it
-    # "matches" it will provide its match target to its associated block.
-    #
-    # It returns tuples of (status, result) in order to prevent masking of
-    # legitimate falsy or nil values returned.
-    #
-    # Guard Block Matchers are best used with a PatternMatch, and chances are
-    # you're going to want to read that documentation first.
-    #
-    # @example
-    #     Qo::Matchers::GuardBlockMatcher
-    #
-    #     guard_matcher = Qo::Matchers::GuardBlockMatcher.new(Integer) { |v| v * 2 }
-    #     guard_matcher.call(1)  # => [true, 2]
-    #     guard_matcher.call(:x) # => [false, false]
-    #
-    # @see Qo::Matchers::PatternMatch
-    #   Pattern Match using GuardBlockMatchers
-    #
-    # @author baweaver
-    # @since 0.1.5
-    #
-    class GuardBlockMatcher < BaseMatcher
-      # Definition of a non-match
-      NON_MATCH = [false, false]
-
-      def initialize(array_matchers, keyword_matchers, &fn)
-        @fn = fn || Qo::IDENTITY
-
-        super('and', array_matchers, keyword_matchers)
-      end
-
-      # Direct test of whether or not a target matches the GuardBlock's
-      # condition
-      #
-      # @param target [Any]
-      #   Target value to match against
-      #
-      # @return [Boolean]
-      #   Whether or not the target matched
-      def match?(target)
-        super(target)
-      end
-
-      # Forces a resolution of a match. Note that this method should
-      # not be used outside of pattern matches, as only a pattern
-      # match will have the necessary additional context to call
-      # it correctly.
-      #
-      # @param target [Any]
-      #   Target value to match against
-      #
-      # @return [Any]
-      #   Result of the function being called on the target
-      def match(target)
-        @fn.call(target)
-      end
-
-      # Overrides the base matcher's #to_proc to wrap the value in a status
-      # and potentially call through to the associated block if a base
-      # matcher would have passed
-      #
-      # @see Qo::Matchers::GuardBlockMatcher#call
-      #
-      # @return [Proc[Any]]
-      #   Function awaiting target value
-      def to_proc
-        Proc.new { |target| self.call(target) }
-      end
-
-
-      # Overrides the call method to wrap values in a return tuple to represent
-      # a positive match to guard against valid falsy returns
-      #
-      # @param target [Any]
-      #   Target value to match against
-      #
-      # @return [Array[false, false]]
-      #   The guard block did not match
-      #
-      # @return [Array[true, Any]]
-      #   The guard block matched, and the provided function called through
-      #   providing a return value.
-      def call(target)
-        super(target) ? [true, @fn.call(target)] : NON_MATCH
-      end
-    end
-  end
-end

data/lib/qo/matchers/hash_matcher.rb

@@ -1,144 +0,0 @@
-module Qo
-  module Matchers
-    # A Hash Matcher is a matcher that uses only keyword args to define a sequence
-    # of matches to perform against either an Object or another Hash.
-    #
-    # In the case of a Hash matching against a Hash, it will compare the intersection
-    # of keys and match the values against eachother.
-    #
-    # ```ruby
-    # Qo[name: /Foo/, age: 30..50].call({name: 'Foo', age: 42})
-    # # => true
-    # ```
-    #
-    # In the case of a Hash matching against an Object, it will treat the keys as
-    # method property invocations to be matched against the provided values.
-    #
-    # # ```ruby
-    # Qo[name: /Foo/, age: 30..50].call(Person.new('Foo', 42))
-    # # => true
-    # ```
-    #
-    # All variants present in the BaseMatcher are present here, including 'and',
-    # 'not', and 'or'.
-    #
-    # @author baweaver
-    # @since 0.2.0
-    #
-    class HashMatcher < BaseMatcher
-      def initialize(type, keyword_matchers)
-        @keyword_matchers = keyword_matchers
-        @type             = type
-      end
-
-      # Wrapper around call to allow for invocation in an Enumerable function,
-      # such as:
-      #
-      # ```ruby
-      # people.select(&Qo[name: /Foo/, age: 20..40])
-      # ```
-      #
-      # @return [Proc[Any]]
-      #   Proc awaiting a target to match against
-      def to_proc
-        Proc.new { |target| self.call(target) }
-      end
-
-      # Used to match against a matcher made from Keyword Arguments (a Hash)
-      #
-      # @param matchers [Hash[Any, #===]]
-      #     Any key mapping to any value that responds to `===`. Notedly more
-      #     satisfying when `===` does something fun.
-      #
-      # @return [Boolean] Result of the match
-      def call(target)
-        return true if @keyword_matchers == target
-
-        match_fn = target.is_a?(::Hash) ?
-          Proc.new { |match_key, matcher| match_hash_value?(target, match_key, matcher)   } :
-          Proc.new { |match_key, matcher| match_object_value?(target, match_key, matcher) }
-
-        match_with(@keyword_matchers, &match_fn)
-      end
-
-      # Checks if a hash value matches a given matcher
-      #
-      # @param target    [Any]    Target of the match
-      # @param match_key [Symbol] Key of the hash to reference
-      # @param matcher   [#===]   Any matcher responding to ===
-      #
-      # @return [Boolean] Match status
-      private def match_hash_value?(target, match_key, matcher)
-        return false unless target.key?(match_key)
-
-        return hash_recurse(target[match_key], matcher) if target.is_a?(Hash) && matcher.is_a?(Hash)
-
-        hash_case_match?(target, match_key, matcher) ||
-        hash_method_predicate_match?(target, match_key, matcher)
-      end
-
-      # Checks if an object property matches a given matcher
-      #
-      # @param target         [Any]    Target of the match
-      # @param match_property [Symbol] Property of the object to reference
-      # @param matcher        [#===]   Any matcher responding to ===
-      #
-      # @return [Boolean] Match status
-      private def match_object_value?(target, match_property, matcher)
-        return false unless target.respond_to?(match_property)
-
-        hash_method_case_match?(target, match_property, matcher)
-      end
-
-      # Double wraps case match in order to ensure that we try against both Symbol
-      # and String variants of the keys, as this is a very common mixup in Ruby.
-      #
-      # @param target    [Hash]   Target of the match
-      # @param match_key [Symbol] Key to match against
-      # @param matcher   [#===]   Matcher
-      #
-      # @return [Boolean]
-      private def hash_case_match?(target, match_key, matcher)
-        return true if case_match?(target[match_key], matcher)
-        return false unless target.keys.first.is_a?(String)
-
-        match_key.respond_to?(:to_s) &&
-        target.key?(match_key.to_s) &&
-        case_match?(target[match_key.to_s], matcher)
-      end
-
-      # Attempts to run a matcher as a predicate method against the target
-      #
-      # @param target          [Hash]   Target of the match
-      # @param match_key       [Symbol] Method to call
-      # @param match_predicate [Symbol] Matcher
-      #
-      # @return [Boolean]
-      private def hash_method_predicate_match?(target, match_key, match_predicate)
-        method_matches?(target[match_key], match_predicate)
-      end
-
-      # Attempts to run a case match against a method call derived from a hash
-      # key, and checks the result.
-      #
-      # @param target         [Hash]   Target of the match
-      # @param match_property [Symbol] Method to call
-      # @param matcher        [#===]   Matcher
-      #
-      # @return [Boolean]
-      private def hash_method_case_match?(target, match_property, matcher)
-        case_match?(method_send(target, match_property), matcher)
-      end
-
-      # Recurses on nested hashes.
-      #
-      # @param target  [Hash]
-      # @param matcher [Hash]
-      #
-      # @return [Boolean]
-      private def hash_recurse(target, matcher)
-        Qo::Matchers::HashMatcher.new(@type, **matcher).call(target)
-      end
-    end
-  end
-end