taipo 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ae496b6a69d19aceb9f158a587cb7c2f7d0faa1
-  data.tar.gz: ec0096547e644b51f8759529a246b273ff5354e8
+  metadata.gz: cb7fcacea028acafa7344ccfc04fbc3c66e50c13
+  data.tar.gz: 052b196e3ed53b4ade6d95abee2b57a266c12a9f
 SHA512:
-  metadata.gz: cb51c506c37aaaca6232488649b8cf59246ea2a3f69e7efb5230b677e1c8d32e276949126202325ebea6c9e8f4d5f652287a47e0a6aa6afd08c23da0f4cd86eb
-  data.tar.gz: 6c1b5b0bb7512d4829167bb5d8400f204fb114cedf16350a0099f71a43a54139a5908c16f08d9a513f9ce23c6c4bbc80b0f4a29c1cd2289411f048bd295006c6
+  metadata.gz: 6cced24c850830e10102f010b0b098ff5ed7ebab426f10cee4b51dcdf1ff29622721e75228b9fc4be9f6fa35b8e4917e14961254a4dbfddb0b8110969aad3b0a
+  data.tar.gz: 4e9bd2e042ef2f87808bbdab7c10657d96f75bb969aa725e0b02666e4160a433eb3279b601c232c87f4fce37163b23204d504a31a8307ee0649b7846ff510de4

data/README.md

@@ -91,7 +91,7 @@ The information in this README is only meant as an introduction. [More informati
 The simplest case is to write the name of a class. For example, `'String'`. Inherited class names can also be used.
 
 ```ruby
-check types, a: 'String', b: 'Numeric'
+check types, a: 'String', b: 'Numeric', c: 'Foo::Bar'
 ```
 
 #### Duck Types

data/lib/taipo.rb

@@ -64,90 +64,4 @@ module Taipo
   def self.alias?
     @@alias
   end
-
-  # Check if a string is the name of an instance method
-  #
-  # @note All this does is check whether the given string begins with a hash
-  #   symbol.
-  #
-  # @param str [String] the string to check
-  #
-  # @return [Boolean] the result
-  #
-  # @since 1.0.0
-  # @api private
-  def self.instance_method?(str)
-    str[0] == '#'
-  end
-
-  # Return the type definition for an object
-  #
-  # @note This assume that each element returned by Enumerator#each has the same
-  #   number of components.
-  #
-  # @param obj [Object] the object
-  #
-  # @return [String] a type definition of the object
-  #
-  # @since 1.1.0
-  # @api private
-  def self.object_to_type_def(obj)
-    return obj.class.name unless obj.is_a? Enumerable
-
-    if obj.is_a? Array
-      element_types = Hash.new
-      obj.each { |o| element_types[self.object_to_type_def(o)] = true }
-      if element_types.empty?
-        obj.class.name
-      else
-        obj.class.name + '<' + element_types.keys.join('|') + '>'
-      end
-    else
-      element_types = Array.new
-      obj.each.with_index do |element,index_e|
-        element.each.with_index do |component,index_c|
-          element_types[index_c] = Hash.new if index_e == 0
-          c_type = self.object_to_type_def(component)
-          element_types[index_c][c_type] = true
-        end
-      end
-      inner = element_types.reduce('') do |memo,e|
-        e_type = e.keys.join('|')
-        (memo == '') ? e_type : memo + ',' + e_type
-      end
-      if element_types.empty?
-        obj.class.name
-      else
-        obj.class.name + '<' + inner + '>'
-      end
-    end
-  end
-
-  # Check if a string is the name of a symbol
-  #
-  # @note All this does is check whether the given string begins with a colon.
-  #
-  # @param str [String] the string to check
-  #
-  # @return [Boolean] the result
-  #
-  # @since 1.2.0
-  # @api private
-  def self.symbol?(str)
-    str[0] == ':'
-  end
-
-  # Return a String representation of an array of {Taipo::TypeElement}
-  #
-  # @param types [Array<Taipo::TypeElement>] the array of {Taipo::TypeElement}
-  #
-  # @return [String] the String representation
-  #
-  # @since 1.1.0
-  # @api private
-  def self.types_to_s(types)
-    types.reduce('') do |memo,t|
-      (memo == '') ? t.to_s : memo + '|' + t.to_s
-    end
-  end
 end

data/lib/taipo/cache.rb

@@ -1,10 +1,11 @@
 module Taipo
+
   # A cache of Taipo::TypeElement created from parsed type definitions
   #
   # @since 1.0.0
   # @api private
   module Cache
-    
+
     # The hash that acts as the cache
     #
     # @since 1.0.0

data/lib/taipo/check.rb

@@ -1,7 +1,9 @@
 require 'taipo/cache'
 require 'taipo/exceptions'
 require 'taipo/parser'
+require 'taipo/type_elements'
 require 'taipo/type_element'
+require 'taipo/utilities'
 
 module Taipo
 
@@ -86,12 +88,12 @@ module Taipo
         is_match = types.any? { |t| t.match? arg }
 
         unless collect_invalids || is_match
-          if Taipo::instance_method? v
+          if Taipo::Utilities.instance_method? v
             msg = "Object '#{k}' does not respond to #{v}."
-          elsif Taipo::symbol? v
+          elsif Taipo::Utilities.symbol? v
             msg = "Object '#{k}' is not equal to #{v}."
           elsif arg.is_a? Enumerable
-            type_def = Taipo.object_to_type_def arg
+            type_def = Taipo::Utilities.object_to_type_def arg
             msg = "Object '#{k}' is #{type_def} but expected #{v}."
           else
             msg = "Object '#{k}' is #{arg.class.name} but expected #{v}."
@@ -125,8 +127,8 @@ module Taipo
     #
     # This is the callback called by Ruby when a module is included. In this
     # case, the callback will alias the method +__types__+ as +types+ if
-    # {Taipo.alias?} returns true. {Taipo.alias} is reset to true at the end of
-    # this method.
+    # {Taipo.alias?} returns true. {Taipo::@@alias} is reset to true at the end
+    # of this method.
     #
     # @param extender [Class|Module] the class or module extending this module
     #
@@ -142,8 +144,8 @@ module Taipo
     #
     # This is the callback called by Ruby when a module is included. In this
     # case, the callback will alias the method +__types__+ as +types+ if
-    # {Taipo.alias?} returns true. {Taipo.alias} is reset to true at the end of
-    # this method.
+    # {Taipo.alias?} returns true. {Taipo::@@alias} is reset to true at the end
+    # of this method.
     #
     # @param includer [Class|Module] the class or module including this module
     #

data/lib/taipo/parser.rb

@@ -1,18 +1,27 @@
 require 'taipo/exceptions'
+require 'taipo/parser/stack'
 require 'taipo/parser/validater'
+require 'taipo/refinements'
+require 'taipo/type_elements'
 require 'taipo/type_element'
+require 'taipo/type_element/children'
+require 'taipo/type_element/constraints'
+require 'taipo/type_element/constraint'
 
 module Taipo
 
   # A parser of Taipo type definitions
+  #
   # @since 1.0.0
   module Parser
 
-    # Return an array of Taipo::TypeElements based on +str+
+    using Taipo::Refinements
+
+    # Return a Taipo::TypeElements object based on +str+
     #
     # @param str [String] a type definition
     #
-    # @return [Array<Taipo:TypeElement>] the result
+    # @return [Taipo:TypeElements] the result
     #
     # @raise [::TypeError] if +str+ is not a String
     # @raise [Taipo::SyntaxError] if +str+ is not a valid type definition
@@ -21,198 +30,328 @@ module Taipo
     def self.parse(str)
       Taipo::Parser::Validater.validate str
 
+      stack = Taipo::Parser::Stack.new
+      i = 0
+      subject = :implied
+      chars = str.chars
       content = ''
-      previous = ''
-      is_fallthrough = false
-      fallthroughs = [ '/', '"' ]
-      closing_symbol = ''
-      stack = Array.new
-      elements = Array.new
-      stack.push elements
 
-      str.each_char do |c|
-        c = '+' + c if is_fallthrough
+      while (i < chars.size)
+        reset = true
 
-        case c
+        case chars[i]
+        when ' '
+          i += 1
+          next
         when '|'
-          unless attached? previous # Previous character must have been '>' or ')'.
-            el = Taipo::TypeElement.new name: content
-            content = ''
-            elements = stack.pop
-            elements.push el
-            stack.push elements
-          end
+          stack = process_sum stack, name: content
+          subject = :implied
         when '<'
-          el = Taipo::TypeElement.new name: content
-          content = ''
-          stack.push el
-          child_type = Taipo::TypeElement::ChildType.new
-          stack.push child_type
-          first_component = Array.new
-          stack.push first_component
+          stack = process_collection :open, stack, name: content
+          subject = :implied
         when '>'
-          if attached? previous # Previous character must have been '>' or ')'.
-            last_component = stack.pop
-          else
-            el = Taipo::TypeElement.new name: content.strip
-            content = ''
-            last_component = stack.pop
-            last_component.push el
-          end
-          child_type = stack.pop
-          child_type.push last_component
-          parent_el = stack.pop
-          parent_el.child_type = child_type
-          elements = stack.pop
-          elements.push parent_el
-          stack.push elements
+          stack = process_collection :close, stack, name: content
+          subject = :made
+        when ','
+          stack = process_component stack, name: content
+          subject = :implied
         when '('
-          if unattached? previous
-            el = Taipo::TypeElement.new name: 'Object'
-            content = ''
-          elsif attached_collection? previous # Previous character must have been '>'.
-            elements = stack.pop
-            el = elements.pop
-            stack.push elements
-          else
-            el = Taipo::TypeElement.new name: content
-            content = ''
-          end
-          stack.push el
-          cst_collection = Array.new
-          stack.push cst_collection
-        when '#'
-          if unattached? previous 
-            content = '#'
-          else
-            cst = Taipo::TypeElement::Constraint.new
-            content = ''
-            cst_collection = stack.pop
-            cst_collection.push cst
-            stack.push cst_collection
-          end
-        when ':'
-          if unattached? previous 
-            content = ':'
-          elsif content.strip.empty?
-            content = ':'
-          else
-            content = content
-            cst = Taipo::TypeElement::Constraint.new name: content.strip
-            content = ''
-            cst_collection = stack.pop
-            cst_collection.push cst
-            stack.push cst_collection
-          end
-        when ',' # We could be inside a collection or a set of constraints
-          if inside_collection? stack
-            previous_component = stack.pop
-            el = Taipo::TypeElement.new name: content.strip
-            content = ''
-            previous_component.push el
-            child_type = stack.pop
-            child_type.push previous_component
-            stack.push child_type
-            next_component = Array.new
-            stack.push next_component
-          else
-            cst_collection = stack.pop
-            cst = cst_collection.pop
-            cst.value = content.strip
-            content = ''
-            cst_collection.push cst
-            stack.push cst_collection
-          end
-        when ')'
-          cst_collection = stack.pop
-          cst = cst_collection.pop
-          cst.value = content.strip
+          stack = process_subject stack, name: content, subject: subject
+          stack, i = process_constraints stack, chars: chars, index: i+1
+        else
+          reset = false
+          subject = :unmade
+        end
+
+        content = (reset) ? '' : content + chars[i]
+        i += 1
+      end
+
+      stack = process_end stack, name: content
+
+      stack.result
+    end
+
+    # Check whether the character should be skipped
+    #
+    # This method determines whether a particular character +c+ should be
+    # skipped based on +states+. It also updates +states+.
+    #
+    # @param c [String] the character to check
+    # @param states [Hash<Symbol,Boolean>] a state machine
+    #
+    # @return [Boolean,Hash<Symbol,Boolean>] the result and the updated state
+    #   machine
+    #
+    # @since 1.4.0
+    # @api private
+    def self.escape?(c, states)
+      if states[:esc]
+        states[:esc] = false
+        return skip, states
+      end
+
+      skip = true
+
+      case c
+      when "'"
+        states[:ss] = !states[:ss] unless states[:re] || states[:ds]
+      when '"'
+        states[:ds] = !states[:ds] unless states[:re] || states[:ss]
+      when '/'
+        states[:re] = !states[:re] unless states[:ss] || states[:ds]
+      when '\\'
+        states[:esc] = true
+      else
+        skip = false
+      end
+
+     return skip, states
+    end
+
+    # Parse the constraint expressed as a string
+    #
+    # @note If the constraint is in the form of an instance method (eg. #foo)
+    #   this method uses {Taipo::TypeElement::Constraint::METHOD} as the name
+    #   returned.
+    #
+    # @param str [String] the constraint expressed as a string
+    #
+    # @return [String,String] the name and the value
+    #
+    # @since 1.4.0
+    # @api private
+    def self.parse_constraint(str)
+      str.strip!
+      in_name = nil
+      name = ''
+      content = ''
+      str.each_char do |c|
+        if c == '#' && in_name.nil?
+          name = Taipo::TypeElement::Constraint::METHOD
+          in_name = false
+        elsif c == ':' && in_name.nil?
+          name = 'val'
+          content = content + c
+          in_name = false
+        elsif c == ':' && in_name
+          name = content
           content = ''
-          cst_collection.push cst
-          el = stack.pop
-          el.constraints = cst_collection
-          elements = stack.pop
-          elements.push el
-          stack.push elements
+          in_name = false
         else
-          if is_fallthrough
-            c = c[1]
-            is_fallthrough = false if c == closing_symbol
-          elsif fallthroughs.any? { |f| f == c }
-            is_fallthrough = true
-            closing_symbol = c
-          end
           content = content + c
+          in_name = true if in_name.nil?
         end
-        previous = c
       end
+      value = content.strip
+      return name, value
+    end
 
-      unless content.empty?
-        el = Taipo::TypeElement.new name: content
-        elements = stack.pop
-        elements.push el
-        stack.push elements
+    # Process a collection
+    #
+    # This method either adds or updates a collection on +stack+ depending on
+    # +direction+. If +direction+ is +:open+, this adds a
+    # {Taipo::TypeElement} to +stack+ representing the class of the collection.
+    # If +direction+ is +:close+, this adds a {Taipo::TypeElement} to +stack+
+    # representing the class of the final component of the collection.
+    #
+    # @param direction [Symbol] Either +:open+ or +:close+ depending on whether
+    #   this has been called because the parser reached a +<+ character or a
+    #   +>+ character
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
+    #
+    # @return [Taipo::Parser::Stack] the updated stack
+    #
+    # @since 1.4.0
+    # @api private
+    def self.process_collection(direction, stack, name:)
+      case direction
+      when :open
+        stack = process_name stack, name: name
+        stack.add_children
+      when :close
+        stack = process_name stack, name: name unless name.empty?
+        children = stack.remove_children
+        stack.update_element :children=, children
       end
+    end
 
-      stack.pop
+    # Process a component
+    #
+    # This method adds a {Taipo::TypeElement} to +stack+ representing a
+    # component of a collection.
+    #
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
+    #
+    # @return [Taipo::Parser::Stack] the updated stack
+    #
+    # @since 1.4.0
+    # @api private
+    def self.process_component(stack, name:)
+      stack = process_name stack, name: name
+      stack.add_child
     end
-  
-    # Check whether the current element is 'attached' to anything
+
+    # Process a constraint
     #
-    # This check is performed by checking whether +char+ is the final character
-    # in a collection or constraint.
+    # This method adds a {Taipo::TypeElement::Constraint} to the last element in
+    # +stack+.
     #
-    # @param char [String] the character to use in the test
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param raw [String] the constraint expressed as a string
     #
-    # @return [Boolean] the result
+    # @return [Taipo::Parser::Stack] the updated stack
     #
-    # @since 1.2.0
+    # @since 1.4.0
     # @api private
-    def self.attached?(char)
-      char == '>' || char == ')'
+    def self.process_constraint(stack, raw:)
+      n, v = parse_constraint raw
+      stack.add_constraint Taipo::TypeElement::Constraint.new(name: n, value: v)
     end
 
-    # Check whether the current element is 'attached' to a collection
+    # Process a series of constraints
     #
-    # Like {self.attached?}, this check is performed by checking +char+. In
-    # this case, the check is whether +char+ is the final character in a
-    # collection.
+    # This method adds a {Taipo::TypeElement::Constraints} to the last element
+    # in +stack+. Because it parses +chars+, it also returns an updated +index+.
     #
-    # @param char [String] the character to use in the test
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param chars [Array<String>] a character array
+    # @param index [Integer] the index of +chars+ at which to begin parsing
     #
-    # @return [Boolean] the result
+    # @return [Taipo::Parser::Stack,Integer] the updated stack and the updated
+    #   index
     #
-    # @since 1.2.0
+    # @since 1.4.0
     # @api private
-    def self.attached_collection?(char)
-      char == '>'
+    def self.process_constraints(stack, chars:, index:)
+      stack.add_constraints
+
+      inside = { ss: false, ds: false, re: false, esc: false }
+      content = ''
+
+      while (index < chars.size)
+        skip, inside = escape?(chars[index], inside)
+        if skip
+          content = content + chars[index]
+          index += 1
+          next
+        end
+
+        case chars[index]
+        when ')'
+          stack = process_constraint stack, raw: content
+          break
+        when ','
+          stack = process_constraint stack, raw: content
+          content = ''
+        else
+          content = content + chars[index]
+        end
+
+        index += 1
+      end
+
+      constraints = stack.remove_constraints
+      stack.update_element :constraints=, constraints
+
+      return stack, index
     end
 
-    # Check if the parser is inside a collection
+    # Process the end of the type definition
     #
-    # @param stack [Array] the stack of parsed elements
+    # The design of {Taipo::Parser.parse} means that at the end of the loop, an
+    # element may remain to be added. This method add any remaining element to
+    # +stack+.
     #
-    # @return [Boolean] the result
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
     #
-    # @since 1.0.0
+    # @return [Taipo::Parser::Stack] the updated stack
+    #
+    # @since 1.4.0
     # @api private
-    def self.inside_collection?(stack)
-      stack[-2]&.class == Taipo::TypeElement::ChildType
+    def self.process_end(stack, name:)
+      return stack if name.empty?
+
+      process_name stack, name: name
+    end
+
+    # Process the name of a {Taipo::TypeElement}
+    #
+    # This method adds a {Taipo::TypeElement} to +stack+ with the name +name+.
+    #
+    # @note Taipo allows certain bare constraints to be written in type
+    #   definitions. If +name+ is a bare constraint (either an instance method
+    #   or a symbol), this method adds a {Taipo::TypeElement} representing the
+    #   Object class with the relevant constraint.
+    #
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
+    #
+    # @return [Taipo::Parser::Stack] the updated stack
+    #
+    # @since 1.4.0
+    # @api private
+    def self.process_name(stack, name:)
+      if name.bare_constraint?
+        chars = "(#{name})".chars
+        stack = process_subject stack, name: '', subject: :implied
+        stack, i = process_constraints stack, chars: chars, index: 1
+        stack
+      else
+        stack.add_element name: name
+      end
     end
 
-    # Check whether the current element is 'unattached' to anything
+    # Process the subject of a series of constraints
     #
-    # This check checks whether +char+ represents the beginning of a discrete
-    # type definition.
+    # Taipo allows for a type definition to specify a series of constraints
+    # that constrain the particular type (the subject). This method adds a
+    # {Taipo::TypeElement} to +stack+ depending on the value of +subject+.
     #
-    # @param char [String] the character to use in the test
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
+    # @param subject [Symbol] whether the subject is :made, :unmade or :implied
     #
-    # @return [Boolean] the result
+    # @return [Taipo::Parser::Stack] the updated stack
     #
-    # @since 1.2.0
+    # @since 1.4.0
     # @api private
-    def self.unattached?(char)
-      char.empty? || char == '|' || char == '<'
+    def self.process_subject(stack, name:, subject:)
+      case subject
+      when :made
+        stack
+      when :unmade
+        process_name stack, name: name
+      when :implied
+        process_name stack, name: 'Object'
+      end
+    end
+
+    # Process a sum of types
+    #
+    # This method adds a {Taipo::TypeElement} to +stack+ representing the former
+    # of the types in the sum.
+    #
+    # @param stack [Taipo::Parser::Stack] the stack
+    # @param name [String] the name of the class of the {Taipo::TypeElement} to
+    #   add to +stack+
+    #
+    # @return [Taipo::Parser::Stack] the updated stack
+    #
+    # @since 1.4.0
+    # @api private
+    def self.process_sum(stack, name:)
+      return stack if name.empty?
+
+      process_name stack, name: name
     end
   end
 end