typ 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a726dc4e0d96b4f5bdad9858d10063bf818af3e5bd1293135acffa040bbde236
-  data.tar.gz: fbc8d499fb78954604a757593e2e46a9e2af7f5fba4102783d6011aa991a10f3
+  metadata.gz: a3d4190e37bd4aadc5b0d529256c441835cdf9f3673cbdb23a1d0b2e583926a7
+  data.tar.gz: edc5160b73a35c92c08d27ea5a13998f37e37f47838f4f986dc4c81d69045b72
 SHA512:
-  metadata.gz: 2d3679f431008960d32befdaea22720e3a3cf49692c7a81f19463476b8cae6d67c8069d3920c1325a3c68d743058a348f2087295219f75bde0261bb780b95cdd
-  data.tar.gz: 20af3243c88900e428928f2c770cb661ee69835187fb0834f55d7be701ab3cfbf0f848b2a854f8998e42cd85291c4551da5b6eaf7ceb7946d63f71aadc823bfb
+  metadata.gz: 2994b127d25415c59392d1561c7b067bb578a1fc62c4e3936e0c74184222c40621af22003e2fd901ef17671d93eb2db2015eafd34f7450ece569f36066ebf615
+  data.tar.gz: 26a90c3294320ee43b78b2c1a4c8ad9939060910b3d5265b400a30889c7e8bff6dd67e1955fb888ad0e41fd0c48e6602ecca62c39b3e4fbbdbfa189e08014230

data/lib/typ.rb

@@ -1,15 +1,45 @@
 module Typ
   module Gate
-    attr_reader :it
+    module DSLReaders
+      def dsl_method
+        self.class.dsl_method
+      end
+      
+      def dsl_literal
+        self.class.dsl_literal
+      end
+    end
+  
+    module New
+      def new
+        c = Class.new
+        c.include Gate
+        c.extend Singleton
+        c
+      end
+      
+    end
+  
+    module Singleton
+      attr_accessor :dsl_method, :dsl_literal
+    end
+  
+    extend New
+    include DSLReaders
+    
+    attr_reader :it, :error
     
     def initialize it
       @it = it
-      check
+      @ok = begin
+              check
+            rescue => e
+              @error = e
+              false
+            end
     end
     
-    # Should set @ok to be true or false
     def check
-      @ok = self.class.check === it
     end
     
     def ok?
@@ -19,7 +49,7 @@ module Typ
 
   def self.included mod
     mod.extend DSL
-    mod.extend PatternMatching
+    mod.extend Singleton
   end
   
   include Gate
@@ -29,165 +59,169 @@ module Typ
   def check
     @gates = self.class.gates.map { |gate| gate.new it }
     @fails = gates.reject &:ok?
-    @ok = fails.empty?
+    fails.empty?
   end
 
   module DSL
-    def gates
-      @gates ||= []
-    end
-    
-    def is type
-      case type
-      when Array
-        gates << Is::Array.new(type)
-      when Class
-        if type.include? Typ
-          gates << type
-        else
-          fail "don't know how to create a Gate from #{type}"
+    class Gate
+      module CheckMethod
+        def augment_gate_with_check test
+          check = Module.new do
+            define_method :check do
+              test[it]
+            end
+          end
+        
+          gate.include check
         end
-      else
-        fail "don't know how to create a Gate from #{type}"
       end
-    end
     
-    def is_a type, params = {}
-      case type
-      when Module
-        gates << IsA.new(type, params)
-      else
-        fail "don't know how to create a Gate from #{type}"
-      end
-    end
-  end
-
-  module Is
-  
-    module Array
-      class Check
-        def initialize array
-          @array = array
-          @check = if array[0].is_a?(Symbol)
-            method, *arguments = array
-            -> it { it.send method, *arguments }
-          elsif array[1].is_a?(Symbol)
-            receiver, method = array
-            -> it { receiver.send method, it }
-          else
-            fail "not sure how to handle #{array} yet"
+      module TestFor
+        def test_for type
+          case type
+          when Symbol
+            -> it { it.send type or bad_assertion(it, type) }
+          when Array
+            cannot_create_gate type unless type.size == 2
+            unless type[0].is_a?(Symbol) || type[1].is_a?(Symbol)
+              cannot_create_gate type
+            end
+        
+            if type[0].is_a? Symbol
+              method, argument = type
+              -> it { it.send method, argument or bad_assertion(it, type) }
+            else
+              receiver, method = type
+              -> it { receiver.send method, it or bad_assertion(it, type) }
+            end
+          when Class
+            type if type.include? Typ
           end
         end
-      
-        def === it
-          @check === it
+        
+        def cannot_create_gate type
+          fail Typ::Error::CannotCreateGate.new(type)
         end
-      
-        def to_a
-          @array
+        
+        def bad_assertion it, name
+          fail Typ::Error::BadAssertion.new(it, name)
         end
       end
-      
-      class << self
-        def new array
-          check = Check.new array
-      
-          gate = Class.new
-          gate.include self
-          gate.check = check
-          gate
-        end
+    
+      def initialize method, literal, **kwargs
+        @method, @literal, @kwargs = method, literal, kwargs
+        make
       end
       
-      def self.included gate
-        gate.extend Singleton
+      def gate
+        @gate ||= Typ::Gate.new
       end
       
-      module Singleton
-        attr_accessor :check
+      def make
       end
       
-      def to_a
-        self.class.check.to_a
-      end
+      include TestFor
+      include CheckMethod
       
-      include Gate
+      def enrich_gate
+        augment_gate_with_check @test
+        gate.dsl_method = @method
+        gate.dsl_literal = @literal
+      end
+    end
+  
+    def gates
+      @gates ||= []
     end
-  end
-
-  module IsA
-    class << self
-      def new type, params = {}
-        type = Type.new type, params
     
-        gate = Class.new
-        gate.include self
-        gate.check = type
-        gate
-      end
+    def is literal
+      gates << Is.new(__method__, literal).gate
     end
     
-    def self.included gate
-      gate.extend Singleton
+    def is_a literal
+      gates << IsA.new(__method__, literal).gate
     end
     
-    module Singleton
-      attr_accessor :check
+    def its name, literal
+      gates << Its.new(__method__, literal, name: name).gate
     end
     
-    include Gate
+    def key name, literal
+      gates << Key.new(__method__, literal, name: name).gate
+    end
   
-    class Type
-      def initialize type, params = {}
-        @type, @params = type, params
-      
-        @param = params[:of]
-      
-        @check = if @params.empty?
-                   -> it { it.is_a? @type }
-                 else
-                   if @param
-                     check_Array
-                   else
-                     check_Hash
-                   end
-                 end
-      end
-      
-      def === it
-        @check === it
+    class FetchGate < Gate
+      def make
+        type_check = test_for @literal
+        @test = fetch_check >> type_check
+        enrich_gate
       end
+    end
+  
+    class Is < Gate
+      def make
+        @test = test_for @literal
       
-      def to_s
-        if @params.empty?
-          @type.to_s
+        if @test
+          if Class === @literal
+            @gate = @literal
+          else
+            enrich_gate
+          end
         else
-          "#{@type}, #{@params}"
+          cannot_create_gate @literal
         end
       end
-      
-      private
-        def check_Array
-          -> it {
-            it.is_a?(@type) &&
-              it.all? { |element| element.is_a? @param }
-          }
-        end
-      
-        def check_Hash
-          key_type, value_type = @params.first
-          -> it {
-           it.is_a?(@type) &&
-             it.keys.all? {|k| k.is_a? key_type } &&
-             it.values.all? {|v| v.is_a? value_type }
-          }
-        end
+    end
+  
+    class IsA < Gate
+      def make
+        @test = test_for [:is_a?, @literal]
+        enrich_gate
+      end
+    end
+  
+    class Its < FetchGate
+      def fetch_check
+        @fetch_check ||= begin
+                           name = @kwargs[:name]
+                           -> it { it.send name }
+                         end
+      end
+    end
+  
+    class Key < FetchGate
+      def fetch_check
+        @fetch_check ||= begin
+                           name = @kwargs[:name]
+                           -> it { it[name] }
+                         end
+      end
     end
   end
 
-  module PatternMatching
-    def === it
+  class Error < StandardError
+  
+    class BadAssertion < self
+      def initialize it, method_name
+        message = "#{it} is #{method_name}"
+        super message
+      end
+    end
+  
+    class CannotCreateGate < self
+      def initialize object
+        message = "Don't know how to create a gate from #{object.inspect}:#{object.class}."
+        super message
+      end
+    end
+  end
+
+  module Singleton
+    def call it
       new(it).ok?
     end
+    
+    alias_method :===, :call
   end
 end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: typ
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
-- Anatoly Chernow
+- Anatoly Chernov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-03 00:00:00.000000000 Z
+date: 2023-08-01 00:00:00.000000000 Z
 dependencies: []
 description: 
-email: 
+email:
+- chertoly@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -35,9 +36,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.4.15
 signing_key: 
 specification_version: 4
-summary: A tool for defining and enforcing types of Ruby objects.
+summary: To type Ruby objects.
 test_files: []