eqq 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53f4f6ec548d800742874bd0d98b015891227be295c9b22a0a3cb89eafce301b
-  data.tar.gz: 58d3f0a0513a7a4eff20d5aea9d60682d415e1582bc7fd9f39166894d03c75da
+  metadata.gz: 3d6619f43d14ad7f0519f68caabc8cf3128ebc3898608aaad753adb81c929201
+  data.tar.gz: ef9edac7cfd62cc0ba23f55e86ad9194a5396550ec9b9d1ec17614f36a0f21c4
 SHA512:
-  metadata.gz: 0eb69ecb3e22473df10aa8256191d03d02cfbd0cc7243d096c574d56f3d00e1932bda1b5d58fe3504b5da7cd68cdd0fb5c59ca91bba94bdef60a9e65d21eaf6e
-  data.tar.gz: 8d0393dc91eef5a40e144ab72e374e422f75302ca3b187bb8b24014ff074eca187c84ddd060e9344e3d5b75d56ed34b75e8869ed5d3cb5812f7a59a3080500b1
+  metadata.gz: a48164a2c1cea62810b4930fa92ca3ebb0b5a2a1b4877f743f1902de52b4ec429d590333437e54eae41ee917463ee5b3166f5c77394369bf2402ff6122cb4ee9
+  data.tar.gz: 880f51dbce3e27f845b05a520decd8c9a17b7c400837d29cb1ad0597ae00279d888c708632dd64eb5457f7ed9d023c9e71951e5b5c4a28c04252727043852f0f

data/README.md

@@ -12,7 +12,7 @@ Require Ruby 2.6 or later
 Add below code into your Gemfile
 
 ```ruby
-gem 'eqq', '0.0.4'
+gem 'eqq', '>= 0.0.5', '< 0.1.0'
 ```
 
 ### Overview
@@ -97,26 +97,27 @@ Reuse as you wish!
 
 ### Builders
 
-* OR(*patterns) / {Eqq::Buildable#OR} - Product returns `true` when matched even one pattern
-* AND(*patterns) / {Eqq::Buildable#AND} - Product returns `true` when matched all patterns
-* NOT(pattern) / {Eqq::Buildable#NOT} - Product returns `true` when not matched the pattern
-* CAN(*method_names) / {Eqq::Buildable#CAN} - Product returns `true` when it has all of the methods (checked with `respond_to?`)
-* RESCUE(exception_class/module, pattern) / {Eqq::Buildable#RESCUE} - Product returns `true` when the pattern raises the exception
-* QUIET(*patterns) / {Eqq::Buildable#QUIET} - Product returns `true` when all patterns did not raise any exception
-* EQ(object) / {Eqq::Buildable#EQ} - Product returns `true` when matched with `#==`
-* SAME(object) / {Eqq::Buildable#SAME} - Product returns `true` when matched with `#equal?`
-* SEND(name, pattern) / {Eqq::Buildable#SEND} - Basically provided for Enumerable
-* BOOLEAN() / {Eqq::Buildable#BOOLEAN} - Product returns `true` when matched to `true` or `false`
-* ANYTHING() / {Eqq::Buildable#ANYTHING} - Product returns `true`, always `true`
-* XOR(pattern1, pattern2) / {Eqq::Buildable#XOR} - Product returns `true` when matched one of the pattern, when matched both returns `false`
-* NAND(*patterns) / {Eqq::Buildable#NAND} - Product is inverted {Eqq::Buildable#AND}
-* NOR(*patterns) / {Eqq::Buildable#NOR} - Product is inverted {Eqq::Buildable#OR}
+* 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`
 
 ### Additional information
 
 When you feel annoy to write `Eqq` in many place, 2 ways exist.
 
-* `Eqq.define` - In the block scope, all builder methods can be used without receiver
+* `Eqq.define(&block)` - In the block scope, all builder methods can be used without receiver
 * `include Eqq::Buildable` - In the class/module, all builders can be used as own method
 
 This gem provides [ruby/rbs](https://github.com/ruby/rbs) signatures

data/lib/eqq/buildable.rb

@@ -11,7 +11,7 @@ module Eqq
 
       # @api private
       # @return [String]
-      def safe_inspect(object)
+      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!
@@ -28,8 +28,8 @@ module Eqq
 
       # @api private
       # @return [void]
-      def set_inspect(name:, product:, arguments:)
-        inspect = "#{name}(#{arguments.map { |argument| safe_inspect(argument) }.join(', ')})".freeze
+      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
@@ -39,7 +39,7 @@ module Eqq
       # @return [void]
       def validate_patterns(*patterns)
         invalids = patterns.reject { |pattern| Eqq.valid?(pattern) }
-        invalid_inspections = invalids.map { |invalid| safe_inspect(invalid) }.join(', ')
+        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
@@ -58,12 +58,12 @@ module Eqq
         patterns.all? { |pattern| pattern === v }
       }
 
-      Buildable.set_inspect(name: 'AND', product: product, arguments: patterns)
+      Buildable.define_inspect_on(product, name: 'AND', arguments: patterns)
 
       product
     end
 
-    # Product is inverted {#AND}
+    # Product is an inverted {#AND}
     #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
@@ -86,12 +86,12 @@ module Eqq
       product = ->v {
         patterns.any? { |pattern| pattern === v }
       }
-      Buildable.set_inspect(name: 'OR', product: product, arguments: patterns)
+      Buildable.define_inspect_on(product, name: 'OR', arguments: patterns)
 
       product
     end
 
-    # Product is inverted {#OR}
+    # Product is an inverted {#OR}
     #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
@@ -113,7 +113,7 @@ module Eqq
       product = ->v {
         patterns.one? { |pattern| pattern === v }
       }
-      Buildable.set_inspect(name: 'XOR', product: product, arguments: patterns)
+      Buildable.define_inspect_on(product, name: 'XOR', arguments: patterns)
 
       product
     end
@@ -127,7 +127,7 @@ module Eqq
 
       product = ->v { !(pattern === v) }
 
-      Buildable.set_inspect(name: 'NOT', product: product, arguments: [pattern])
+      Buildable.define_inspect_on(product, name: 'NOT', arguments: [pattern])
 
       product
     end
@@ -137,9 +137,9 @@ module Eqq
     # @param obj [#==]
     # @return [Proc]
     def EQ(obj)
-      ->v { obj == v }.tap do |product|
-        Buildable.set_inspect(name: 'EQ', product: product, arguments: [obj])
-      end
+      product = ->v { obj == v }
+      Buildable.define_inspect_on(product, name: 'EQ', arguments: [obj])
+      product
     end
 
     # Product returns `true` when matched with `#equal?`
@@ -147,9 +147,9 @@ module Eqq
     # @param obj [#equal?]
     # @return [Proc]
     def SAME(obj)
-      ->v { obj.equal?(v) }.tap do |product|
-        Buildable.set_inspect(name: 'SAME', product: product, arguments: [obj])
-      end
+      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?`)
@@ -176,7 +176,7 @@ module Eqq
         }
       }
 
-      Buildable.set_inspect(name: 'CAN', product: product, arguments: messages)
+      Buildable.define_inspect_on(product, name: 'CAN', arguments: messages)
 
       product
     end
@@ -202,7 +202,7 @@ module Eqq
         }
       }
 
-      Buildable.set_inspect(name: 'QUIET', product: product, arguments: patterns)
+      Buildable.define_inspect_on(product, name: 'QUIET', arguments: patterns)
 
       product
     end
@@ -227,7 +227,7 @@ module Eqq
         end
       }
 
-      Buildable.set_inspect(name: 'RESCUE', product: product, arguments: [mod, pattern])
+      Buildable.define_inspect_on(product, name: 'RESCUE', arguments: [mod, pattern])
 
       product
     end
@@ -251,13 +251,13 @@ module Eqq
         v.__send__(name, pattern)
       }
 
-      Buildable.set_inspect(name: 'SEND', product: product, arguments: [name, pattern])
+      Buildable.define_inspect_on(product, name: 'SEND', arguments: [name, pattern])
 
       product
     end
 
     ANYTHING = ->_v { true }
-    Buildable.set_inspect(name: 'ANYTHING', product: ANYTHING, arguments: [])
+    define_inspect_on(ANYTHING, name: 'ANYTHING', arguments: [])
     private_constant :ANYTHING
 
     # Product returns `true`, always `true`
@@ -267,8 +267,19 @@ module Eqq
       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) }
-    Buildable.set_inspect(name: 'BOOLEAN', product: BOOLEAN, arguments: [])
+    define_inspect_on(BOOLEAN, name: 'BOOLEAN', arguments: [])
     private_constant :BOOLEAN
 
     # Product returns `true` when matched to `true` or `false`

data/lib/eqq/version.rb

@@ -3,5 +3,5 @@
 
 module Eqq
   # This will be same as latest published gem version
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/sig/eqq.rbs

@@ -1,3 +1,4 @@
+# Pattern objects builder
 module Eqq
   interface _Patternable
     def ===: (untyped object) -> bool
@@ -18,39 +19,74 @@ module Eqq
     # 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: (untyped object)-> String
+    def self.safe_inspect_for: (untyped object)-> String
 
     # A private API. Should not be used in your code.
-    def self.set_inspect: (name: String, product: patternable_lambda, arguments: Array[untyped])-> void
+    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
 
@@ -61,9 +97,9 @@ module Eqq
 
   VERSION: String
 
-  # A private constant. Should not be used in your code.
-  INSPECTION_FALLBACK: String
-
+  # Returns `true` when given object has patternable signature
   def self.valid?: (untyped object) -> bool
+
+  # In the block scope, all builder methods can be used without receiver
   def self.define:  { () -> _Patternable } -> _Patternable
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eqq
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Kenichi Kamiya
@@ -10,7 +10,14 @@ bindir: bin
 cert_chain: []
 date: 2021-06-03 00:00:00.000000000 Z
 dependencies: []
-description: "    [4.2, 42, 42.0, 420].grep(Eqq.AND(Integer, 20..50)) #=> [42]\n"
+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: []
@@ -49,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: []