eqq 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bca6982f43fb57004acdca8facb594d0d178999bdcb323a41663138d9f00325
-  data.tar.gz: 31f2e909e814925d47cf64824ac1267597fc2b85d3a4704ed9612704f6b41071
+  metadata.gz: d0645f6178f68b0a105efa1bcf389bd3c0b1f056cd94a6c6684b0d18bc9284f8
+  data.tar.gz: a93f3a7df8098fbb1e7bdb61b5ad36c29a67e4471e563c63bb562b7896cfa60d
 SHA512:
-  metadata.gz: e30c7e8c661ffb9764e9c604503454e3bd29de40075f6e8296540d0b3a41a482c1221178d155e2c090b1b075ea4ec4d6f63306d5eaeba3b69e505e981abd0712
-  data.tar.gz: '0885388e12a098f0c26415b252f0bc552c39e526df9ffbed2beffcc046ffe778eee99a71120e23e6ea80c61c1aee67b5769208196fee9d422646a6d90e4e92d4'
+  metadata.gz: a5d02720dfa28fc5aefed2907008e14e76dc00fd087eb83eb6c89bbf8c976b0258410d554592fc1368938bfcda8e96efc99ae2a811f285dfba33b210bf795ba5
+  data.tar.gz: e8077c6bd4ab3c5e363abeaa5154dca3bf8154140a73f75d238883cefe92855fb8da843ba46037c12ffb9bc710b9449b1d121a6e2119dc774520bd237f71d564

data/MIT-LICENSE.txt

@@ -7,7 +7,7 @@ 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:
+furnished to do so, subject to the following patterns:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

data/README.md

@@ -3,18 +3,16 @@
 ![Build Status](https://github.com/kachick/eqq/actions/workflows/test_behaviors.yml/badge.svg?branch=main)
 [![Gem Version](https://badge.fury.io/rb/eqq.png)](http://badge.fury.io/rb/eqq)
 
-Pattern objects builder.
-
-`eqq` means `#===`
+Pattern objects builder
 
 ## Usage
 
-Require Ruby 2.5 or later
+Require Ruby 2.6 or later
 
 Add below code into your Gemfile
 
 ```ruby
-gem 'eqq', '>= 0.0.1', '< 0.1.0'
+gem 'eqq', '>= 0.0.6', '< 0.1.0'
 ```
 
 ### Overview
@@ -29,10 +27,129 @@ require 'eqq'
 pattern = Eqq.define do
   OR(AND(Float, 20..50), Integer)
 end
+
+p pattern #=> "OR(AND(Float, 20..50), Integer)"
 [4.2, 42, 42.0, 420].grep(pattern) #=> [42, 42.0, 420]
+
+inverted = Eqq.NOT(pattern)
+p inverted #=> "NOT(OR(AND(Float, 20..50), Integer))"
+[4.2, 42, 42.0, 420].grep(inverted) #=> [4.2]
+
+Eqq.SEND(:all?, pattern) === [4.2, 42, 42.0, 420] #=> false
+Eqq.SEND(:any?, pattern) === [4.2, 42, 42.0, 420] #=> true
+
+ret_in_case = (
+  case 42
+  when pattern
+    'Should be matched here! :)'
+  when inverted
+    'Should not be matched here! :<'
+  else
+    'Should not be matched here too! :<'
+  end
+)
+
+p ret_in_case #=> Should be matched here! :)
+
+ret_in_case = (
+  case 4.2
+  when pattern
+    'Should not be matched here! :<'
+  when inverted
+    'Should be matched here! :)'
+  else
+    'Should not be matched here too! :<'
+  end
+)
+
+p ret_in_case #=> Should be matched here! :)
+
+class MyClass
+  include Eqq::Buildable
+
+  def example
+    [4.2, 42, 42.0, 420].grep(OR(AND(Float, 20..50), Integer))
+  end
+end
+MyClass.new.example #=> [42, 42.0, 420]
 ```
 
+### Explanation
+
+All products can be called as `pattern === other`.
+
+This signature will fit in most Ruby code.
+
+* `case ~ when` syntax
+* Enumerable#grep
+* Enumerable#grep_v
+* Enumerable#all?
+* Enumerable#any?
+* Enumerable#none?
+* Enumerable#one?
+* Enumerable#slice_after
+* Enumerable#slice_before
+
+They can take this interface as the `pattern`.
+
+And you already saw. All of patterns can be mixed with other patterns as a parts.
+Reuse as you wish!
+
+### Builders
+
+* OR(*patterns) - Product returns `true` when matched even one pattern
+* AND(*patterns) - Product returns `true` when matched all patterns
+* NOT(pattern) - Product returns `true` when not matched the pattern
+* CAN(*method_names) - Product returns `true` when it has all of the methods (checked with `respond_to?`)
+* RESCUE(exception_class/module, pattern) - Product returns `true` when the pattern raises the exception
+* QUIET(*patterns) - Product returns `true` when all patterns did not raise any exception
+* EQ(object) - Product returns `true` when matched with `#==`
+* SAME(object) - Product returns `true` when matched with `#equal?`
+* SEND(name, pattern) - Basically provided for Enumerable
+* BOOLEAN() - Product returns `true` when matched to `true` or `false`
+* ANYTHING() - Product returns `true`, always `true`
+* NEVER() - Product returns `false`, always `false`
+* XOR(pattern1, pattern2) - Product returns `true` when matched one of the pattern, when matched both returns `false`
+* NAND(*patterns) - Product is an inverted `AND`
+* NOR(*patterns) - Product is an inverted `OR`
+
+### Best fit for RSpec's `satisfy` matcher too
+
+All builders actually generate a `Proc (lambda)` instance.
+The signature will fit for RSpec's built-in [`satisfy` matcher](https://relishapp.com/rspec/rspec-expectations/v/3-10/docs/built-in-matchers/satisfy-matcher) too.
+
+```ruby
+RSpec.describe RSpec::Matchers::BuiltIn::Satisfy do
+  let(:product) { Eqq.AND(Integer, 24..42) }
+
+  it 'perfectly works' do
+    expect(23).not_to satisfy(&product)
+    expect(24).to satisfy(&product)
+    expect(24.0).not_to satisfy(&product)
+    expect(42).to satisfy(&product)
+    expect(42.0).not_to satisfy(&product)
+    expect(43).not_to satisfy(&product)
+  end
+end
+```
+
+### Use builders without receiver specifying
+
+When you felt annoy to write `Eqq` in many place, some ways exist.
+
+* `Eqq.define(&block)` - In the block scope, all builder methods can be used without receiver
+* `extend Eqq::Buildable` - In the class/module, all builders can be used as class methods
+* `include Eqq::Buildable` - In the class/module, all builders can be used as instance methods
+
+### Signature
+
+* This gem provides [ruby/rbs](https://github.com/ruby/rbs) signature file
+
 ## Links
 
 * [Repository](https://github.com/kachick/eqq)
 * [API documents](https://kachick.github.io/eqq)
+
+## NOTE
+
+* [`eqq` is the implementation name of `#===` in CRuby](https://github.com/ruby/ruby/blob/2a685da1fcd928530509e99f5edb4117bc377994/range.c#L1859)

data/lib/eqq.rb

@@ -2,238 +2,60 @@
 # frozen_string_literal: true
 
 # Copyright (c) 2011 Kenichi Kamiya
-# Forked from https://github.com/kachick/eqq at 2021
+# Forked from https://github.com/kachick/validation at 2021
 
-module Eqq
-  def self.conditionable?(object)
-    case object
-    when Proc, Method
-      object.arity == 1
-    else
-      begin
-        object.respond_to?(:===)
-      rescue NoMethodError
-        false
-      end
-    end
-  end
-
-  def self.define(&block)
-    module_exec(&block)
-  end
-
-  module_function
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  #   this lambda return true if match all conditions
-  def AND(condition1, condition2, *conditions)
-    ->v {
-      [condition1, condition2, *conditions].all? { |condition| condition === v }
-    }
-  end
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  def NAND(condition1, condition2, *conditions)
-    NOT(AND(condition1, condition2, *conditions))
-  end
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  #   this lambda return true if match a any condition
-  def OR(condition1, condition2, *conditions)
-    ->v {
-      [condition1, condition2, *conditions].any? { |condition| condition === v }
-    }
-  end
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  def NOR(condition1, condition2, *conditions)
-    NOT(OR(condition1, condition2, *conditions))
-  end
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  def XOR(condition1, condition2, *conditions)
-    ->v {
-      [condition1, condition2, *conditions].one? { |condition| condition === v }
-    }
-  end
-
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  def XNOR(condition1, condition2, *conditions)
-    NOT(XOR(condition1, condition2, *conditions))
-  end
-
-  # A condition builder.
-  # @param condition [Proc, Method, #===]
-  # @return [Proc] A condition invert the original condition.
-  def NOT(condition)
-    unless Eqq.conditionable?(condition)
-      raise TypeError, 'wrong object for condition'
-    end
-
-    ->v { !(condition === v) }
-  end
-
-  # A condition builder.
-  # @param obj [#==]
-  # @return [Proc]
-  #   this lambda return true if a argument match under #== method
-  def EQ(obj)
-    ->v { obj == v }
-  end
-
-  # A condition builder.
-  # @param obj [#equal?]
-  # @return [Proc]
-  #   this lambda return true if a argument match under #equal? method
-  def SAME(obj)
-    ->v { obj.equal?(v) }
-  end
-
-  # A condition builder.
-  # @param message1 [Symbol, String]
-  # @param messages [Array<Symbol, String>]
-  # @return [Proc]
-  #   this lambda return true if a argument respond to all messages
-  def CAN(message1, *messages)
-    messages = [message1, *messages].map(&:to_sym)
+require_relative 'eqq/version'
 
-    ->v {
-      messages.all? { |message| v.respond_to?(message) }
-    }
-  end
+# Pattern objects builder
+module Eqq
+  # Base error of this library
+  class Error < StandardError; end
 
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  #   this lambda return true
-  #   if face no exception when a argument checking under all conditions
-  def QUIET(condition1, *conditions)
-    conditions = [condition1, *conditions]
-    unless conditions.all? { |c| Eqq.conditionable?(c) }
-      raise TypeError, 'wrong object for condition'
-    end
+  # Raised when found some products are invalid as a pattern object
+  class InvalidProductError < Error; end
 
-    ->v {
-      conditions.all? { |condition|
+  class << self
+    def pattern?(object)
+      case object
+      when Proc, Method
+        object.arity == 1
+      else
         begin
-          condition === v
-        rescue Exception
+          object.respond_to?(:===)
+        rescue NoMethodError
           false
-        else
-          true
         end
-      }
-    }
-  end
-
-  # A condition builder.
-  # @param exception [Exception]
-  # @param exceptions [Array<Exception>]
-  # @return [Proc]
-  #   this lambda return true
-  #   if catch any kindly exceptions when a argument checking in a block parameter
-  def RESCUE(exception, *exceptions, &condition)
-    exceptions = [exception, *exceptions]
-    raise ArgumentError unless Eqq.conditionable?(condition)
-    raise ArgumentError unless exceptions.all?(Exception)
-
-    ->v {
-      begin
-        condition.call(v)
-        false
-      rescue *exceptions
-        true
-      rescue Exception
-        false
       end
-    }
-  end
-
-  # A condition builder.
-  # @param exception [Exception]
-  # @return [Proc]
-  #   this lambda return true
-  #   if catch a specific exception when a argument checking in a block parameter
-  def CATCH(exception, &condition)
-    raise ArgumentError unless Eqq.conditionable?(condition)
-    raise ArgumentError unless exceptions.all?(Exception)
+    end
 
-    ->v {
-      begin
-        condition.call(v)
-      rescue Exception => err
-        err.instance_of?(exception)
-      else
-        false
-      end
-    }
-  end
+    # @deprecated Use {pattern?} instead. This will be dropped since `0.1.0`
+    def valid?(object)
+      pattern?(object)
+    end
 
-  # A condition builder.
-  # @param condition1 [Proc, Method, #===]
-  # @param condition2 [Proc, Method, #===]
-  # @param conditions [Array<Proc, Method, #===>]
-  # @return [Proc]
-  #   this lambda return true
-  #   if all included objects match all conditions
-  def ALL(condition1, condition2, *conditions)
-    condition = Eqq.AND(condition1, condition2, *conditions)
+    # @api private
+    def satisfy?(object)
+      (Proc === object) && object.lambda? && (object.arity == 1)
+    end
 
-    ->list {
-      enum = (
-        case
-        when list.respond_to?(:each_value)
-          list.each_value
-        when list.respond_to?(:all?)
-          list
-        when list.respond_to?(:each)
-          list.each
-        else
-          return false
-        end
-      )
+    # @return [#===]
+    # @raise [InvalidProductError] if the return value is invalid as a pattern object
+    def define(&block)
+      pattern = DSLScope.new.instance_exec(&block)
+      raise InvalidProductError unless satisfy?(pattern)
 
-      enum.all?(condition)
-    }
+      pattern
+    end
   end
+end
 
-  def ANYTHING
-    # BasicObject.=== always passing
-    BasicObject
-  end
+require_relative 'eqq/buildable'
 
-  BOOLEAN = OR(SAME(true), SAME(false))
+module Eqq
+  extend Buildable
 
-  # A getter for a useful condition.
-  # @return [BOOLEAN] "true or false"
-  def BOOLEAN
-    BOOLEAN
+  class DSLScope
+    include Buildable
   end
+  private_constant :DSLScope
 end
-
-require_relative 'eqq/version'

data/lib/eqq/buildable.rb

@@ -0,0 +1,292 @@
+# coding: us-ascii
+# frozen_string_literal: true
+
+module Eqq
+  # Actually having definitions for the pattern builders
+  module Buildable
+    class << self
+      # When the inspection is failed some unexpected reasons, it will fallback to this value
+      # This value is not fixed as a spec, might be changed in future
+      INSPECTION_FALLBACK = 'UninspectableObject'
+
+      # @api private
+      # @return [String]
+      def safe_inspect_for(object)
+        String.try_convert(object.inspect) || INSPECTION_FALLBACK
+      rescue Exception
+        # This implementation used `RSpec::Support::ObjectFormatter::UninspectableObjectInspector` as a reference, thank you!
+        # ref: https://github.com/kachick/times_kachick/issues/97
+        singleton_class = class << object; self; end
+        begin
+          klass = singleton_class.ancestors.detect { |ancestor| !ancestor.equal?(singleton_class) }
+          native_object_id = '%#016x' % (object.__id__ << 1)
+          "#<#{klass}:#{native_object_id}>"
+        rescue Exception
+          INSPECTION_FALLBACK
+        end
+      end
+
+      # @api private
+      # @return [void]
+      def define_inspect_on(product, name:, arguments:)
+        inspect = "#{name}(#{arguments.map { |argument| safe_inspect_for(argument) }.join(', ')})".freeze
+        product.define_singleton_method(:inspect) do
+          inspect
+        end
+      end
+
+      # @api private
+      # @return [void]
+      def validate_patterns(*patterns)
+        invalids = patterns.reject { |pattern| Eqq.pattern?(pattern) }
+        invalid_inspections = invalids.map { |invalid| safe_inspect_for(invalid) }.join(', ')
+        raise ArgumentError, "given `#{invalid_inspections}` are invalid as pattern objects" unless invalids.empty?
+      end
+    end
+
+    # Product returns `true` when matched all patterns
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param pattern2 [Proc, Method, #===]
+    # @param patterns [Array<Proc, Method, #===>]
+    # @return [Proc]
+    def AND(pattern1, pattern2, *patterns)
+      patterns = [pattern1, pattern2, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.all? { |pattern| pattern === v }
+      }
+
+      Buildable.define_inspect_on(product, name: 'AND', arguments: patterns)
+
+      product
+    end
+
+    # Product is an inverted {#AND}
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param pattern2 [Proc, Method, #===]
+    # @param patterns [Array<Proc, Method, #===>]
+    # @return [Proc]
+    def NAND(pattern1, pattern2, *patterns)
+      NOT(AND(pattern1, pattern2, *patterns))
+    end
+
+    # Product returns `true` when matched even one pattern
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param pattern2 [Proc, Method, #===]
+    # @param patterns [Array<Proc, Method, #===>]
+    # @return [Proc]
+    def OR(pattern1, pattern2, *patterns)
+      patterns = [pattern1, pattern2, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.any? { |pattern| pattern === v }
+      }
+      Buildable.define_inspect_on(product, name: 'OR', arguments: patterns)
+
+      product
+    end
+
+    # Product is an inverted {#OR}
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param pattern2 [Proc, Method, #===]
+    # @param patterns [Array<Proc, Method, #===>]
+    # @return [Proc]
+    def NOR(pattern1, pattern2, *patterns)
+      NOT(OR(pattern1, pattern2, *patterns))
+    end
+
+    # Product returns `true` when matched one of the pattern, when matched both returns `false`
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param pattern2 [Proc, Method, #===]
+    # @return [Proc]
+    def XOR(pattern1, pattern2)
+      patterns = [pattern1, pattern2].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.one? { |pattern| pattern === v }
+      }
+      Buildable.define_inspect_on(product, name: 'XOR', arguments: patterns)
+
+      product
+    end
+
+    # Product returns `true` when not matched the pattern
+    #
+    # @param pattern [Proc, Method, #===]
+    # @return [Proc]
+    def NOT(pattern)
+      Buildable.validate_patterns(pattern)
+
+      product = ->v { !(pattern === v) }
+
+      Buildable.define_inspect_on(product, name: 'NOT', arguments: [pattern])
+
+      product
+    end
+
+    # Product returns `true` when matched with `#==`
+    #
+    # @param obj [#==]
+    # @return [Proc]
+    def EQ(obj)
+      product = ->v { obj == v }
+      Buildable.define_inspect_on(product, name: 'EQ', arguments: [obj])
+      product
+    end
+
+    # Product returns `true` when matched with `#equal?`
+    #
+    # @param obj [#equal?]
+    # @return [Proc]
+    def SAME(obj)
+      product = ->v { obj.equal?(v) }
+      Buildable.define_inspect_on(product, name: 'SAME', arguments: [obj])
+      product
+    end
+
+    # Product returns `true` when it has all of the methods (checked with `respond_to?`)
+    #
+    # @param message1 [Symbol, String, #to_sym]
+    # @param messages [Array<Symbol, String, #to_sym>]
+    # @return [Proc]
+    def CAN(message1, *messages)
+      messages = (
+        begin
+          [message1, *messages].map(&:to_sym).freeze
+        rescue NoMethodError
+          raise ArgumentError
+        end
+      )
+
+      product = ->v {
+        messages.all? { |message|
+          begin
+            v.respond_to?(message)
+          rescue NoMethodError
+            false
+          end
+        }
+      }
+
+      Buildable.define_inspect_on(product, name: 'CAN', arguments: messages)
+
+      product
+    end
+
+    # Product returns `true` when all patterns did not raise any exception
+    #
+    # @param pattern1 [Proc, Method, #===]
+    # @param patterns [Array<Proc, Method, #===>]
+    # @return [Proc]
+    def QUIET(pattern1, *patterns)
+      patterns = [pattern1, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.all? { |pattern|
+          begin
+            pattern === v
+          rescue Exception
+            false
+          else
+            true
+          end
+        }
+      }
+
+      Buildable.define_inspect_on(product, name: 'QUIET', arguments: patterns)
+
+      product
+    end
+
+    # Product returns `true` when the pattern raises the exception
+    #
+    # @param mod [Module]
+    # @param pattern [Proc, Method, #===]
+    # @return [Proc]
+    def RESCUE(mod, pattern)
+      Buildable.validate_patterns(pattern)
+      raise ArgumentError unless Module === mod
+
+      product = ->v {
+        begin
+          pattern === v
+          false
+        rescue mod
+          true
+        rescue Exception
+          false
+        end
+      }
+
+      Buildable.define_inspect_on(product, name: 'RESCUE', arguments: [mod, pattern])
+
+      product
+    end
+
+    # Basically provided for Enumerable
+    #
+    # @param name [Symbol, String, #to_sym]
+    # @param pattern [Proc, Method, #===]
+    # @return [Proc]
+    def SEND(name, pattern)
+      name = (
+        begin
+          name.to_sym
+        rescue NoMethodError
+          raise ArgumentError
+        end
+      )
+      Buildable.validate_patterns(pattern)
+
+      product = ->v {
+        v.__send__(name, pattern)
+      }
+
+      Buildable.define_inspect_on(product, name: 'SEND', arguments: [name, pattern])
+
+      product
+    end
+
+    ANYTHING = ->_v { true }
+    define_inspect_on(ANYTHING, name: 'ANYTHING', arguments: [])
+    private_constant :ANYTHING
+
+    # Product returns `true`, always `true`
+    #
+    # @return [Proc]
+    def ANYTHING
+      ANYTHING
+    end
+
+    NEVER = ->_v { false }
+    define_inspect_on(NEVER, name: 'NEVER', arguments: [])
+    private_constant :NEVER
+
+    # Product returns `false`, always `false`
+    #
+    # @return [Proc]
+    def NEVER
+      NEVER
+    end
+
+    BOOLEAN = ->v { true.equal?(v) || false.equal?(v) }
+    define_inspect_on(BOOLEAN, name: 'BOOLEAN', arguments: [])
+    private_constant :BOOLEAN
+
+    # Product returns `true` when matched to `true` or `false`
+    #
+    # @return [Proc]
+    def BOOLEAN
+      BOOLEAN
+    end
+  end
+end

data/lib/eqq/version.rb

@@ -2,5 +2,6 @@
 # frozen_string_literal: true
 
 module Eqq
-  VERSION = '0.0.1'
+  # This will be same as latest published gem version
+  VERSION = '0.0.6'
 end

data/sig/eqq.rbs

@@ -0,0 +1,112 @@
+# Pattern objects builder
+module Eqq
+  interface _Patternable
+    def ===: (untyped object) -> bool
+  end
+
+  interface _ToSym
+    def to_sym: -> Symbol
+  end
+
+  interface _Inspectable
+    def inspect: () -> String
+  end
+
+  module Buildable
+    type patternable_lambda = ^(untyped object) -> bool
+    type product = patternable_lambda & _Inspectable
+
+    # A private constant. Should not be used in your code.
+    ANYTHING: product
+
+    # A private constant. Should not be used in your code.
+    NEVER: product
+
+    # A private constant. Should not be used in your code.
+    BOOLEAN: product
+
+    # A private API. Should not be used in your code.
+    def self.safe_inspect_for: (untyped object)-> String
+
+    # A private API. Should not be used in your code.
+    def self.define_inspect_on: (patternable_lambda product, name: String, arguments: Array[untyped])-> void
+
+    # A private API. Should not be used in your code.
+    def self.validate_patterns: (*untyped) -> void
+
+    # Product returns `true` when matched even one pattern
+    def OR: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product returns `true` when matched all patterns
+    def AND: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product is an inverted `AND`
+    def NAND: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product is an inverted `OR`
+    def NOR: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product returns `true` when matched one of the pattern, when matched both returns `false`
+    def XOR: (_Patternable, _Patternable) -> product
+
+    # Product returns `true` when not matched the pattern
+    def NOT: (_Patternable) -> product
+
+    # Product returns `true` when matched with `#==`
+    def EQ: (untyped object) -> product
+
+    # Product returns `true` when matched with `#equal?`
+    def SAME: (untyped object) -> product
+
+    # Product returns `true` when it has all of the methods (checked with `respond_to?`)
+    def CAN: (_ToSym, *_ToSym) -> product
+
+    # Product returns `true` when the pattern raises the exception
+    def RESCUE: (Module, _Patternable) -> product
+
+    # Product returns `true` when all patterns did not raise any exception
+    def QUIET: (_Patternable, *_Patternable) -> product
+
+    # Basically provided for Enumerable
+    def SEND: (Symbol | String name, _Patternable) -> product
+
+    # Product returns `true`, always `true`
+    def ANYTHING: () -> product
+
+    # Product returns `false`, always `false`
+    def NEVER: () -> product
+
+    # Product returns `true` when matched to `true` or `false`
+    def BOOLEAN: () -> product
+  end
+
+  extend Buildable
+
+  # Base error of this library
+  class Error < StandardError
+  end
+
+  # Raised when found some products are invalid as a pattern object
+  class InvalidProductError < Error
+  end
+
+  # A private API. Should not be used in your code.
+  class DSLScope
+    include Buildable
+  end
+
+  VERSION: String
+
+  # Returns `true` when given object has patternable signature
+  def self.pattern?: (untyped object) -> bool
+
+  # Alias of `pattern?`. But deperecated. Do not use in your code anymore.
+  def self.valid?: (untyped object) -> bool
+
+  # Returns `true` when given object has correct signature as a product of builders
+  # Basically this is a private API. Should not be used in your code.
+  def self.satisfy?: (untyped object) -> bool
+
+  # In the block scope, all builder methods can be used without receiver
+  def self.define:  { () -> _Patternable } -> _Patternable
+end

metadata

@@ -1,230 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: eqq
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
 platform: ruby
 authors:
 - Kenichi Kamiya
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-01 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.4.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.4.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: irb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.5
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.5
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: irb-power_assert
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.0.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.0.2
-- !ruby/object:Gem::Dependency
-  name: warning
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 13.0.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '20.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 13.0.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '20.0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.9.26
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.9.26
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.16.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.16.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.11.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.12.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.11.3
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.12.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-rubycw
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.6
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.2.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.6
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.2.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-md
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-description: "    [4.2, 42, 42.0, 420].grep(Eqq.AND(Integer, 20..50)) #=> [42]\n"
+date: 2021-06-06 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      Pattern objects builder.
+
+      All products can be used as `pattern === something`.
+
+      All products can be mixed with other products as a parts.
+
+      Reuse as you wish!
 email:
 - kachick1+ruby@gmail.com
 executables: []
@@ -234,7 +27,9 @@ files:
 - MIT-LICENSE.txt
 - README.md
 - lib/eqq.rb
+- lib/eqq/buildable.rb
 - lib/eqq/version.rb
+- sig/eqq.rbs
 homepage: https://github.com/kachick/eqq
 licenses:
 - MIT
@@ -251,7 +46,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -261,5 +56,5 @@ requirements: []
 rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
-summary: Pattern objects builder. `eqq` means `#===`
+summary: Pattern objects builder
 test_files: []