taipo 1.3.0 → 1.4.0

data/lib/taipo/refinements.rb

@@ -0,0 +1,30 @@
+module Taipo
+
+  # Refinements on core classes used in Taipo
+  #
+  # @since 1.4.0
+  # @api private
+  module Refinements
+
+    # Refinements to String
+    #
+    # @since 1.4.0
+    # @api private
+    refine String do
+
+      # Check if the string represents a bare constraint
+      #
+      # Taipo allows certain bare constraints to be written in type
+      # definitions. A bare constraint can be either an instance method
+      # or a symbol.
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.4.0
+      # @api private
+      def bare_constraint?
+        (self[0] == ':' && self[1] != ':') || self[0] == '#'
+      end
+    end
+  end
+end

data/lib/taipo/type_element.rb

@@ -1,5 +1,7 @@
 require 'taipo/exceptions'
-require 'taipo/type_element/child_type'
+require 'taipo/type_elements'
+require 'taipo/type_element/children'
+require 'taipo/type_element/constraints'
 require 'taipo/type_element/constraint'
 
 module Taipo
@@ -16,13 +18,13 @@ module Taipo
     # @api private
     attr_accessor :name
 
-    # The child type collection for this element
+    # The children for this element
     #
-    # @since 1.0.0
+    # @since 1.4.0
     # @api private
-    attr_accessor :child_type
+    attr_accessor :children
 
-    # The constraint collection for this element
+    # The constraints for this element
     #
     # @since 1.0.0
     # @api private
@@ -31,53 +33,38 @@ module Taipo
     # Initialize a new type element
     #
     # @param name [String] the name of this type
-    # @param child_type [Taipo::TypeElement::ChildType|NilClass] the child type
-    #   collection for this element
-    # @param constraints [Array<Taipo::TypeElement::Constraints>|NilClass] an
-    #   array of constraints for this element
+    # @param children [Taipo::TypeElement::Children|NilClass] the children for
+    #   this type
+    # @param constraints [Array<Taipo::TypeElement::Constraints>|NilClass] the
+    #   constraints for this type
     #
-    # @raise [::TypeError] if +name+, +child_type+ or +constraints+ was of the
+    # @raise [::TypeError] if +name+, +children+ or +constraints+ was of the
     #   wrong type
-    # @raise [::ArgumentError] if +name+, +child_type+ or +constraints+ was
-    #   blank or empty, or +child_type+ or +constraints+ was non-nil and this
-    #   is a duck type (ie. a method the type responds to) or a symbol
+    # @raise [::ArgumentError] if +name+, +children+ or +constraints+ was
+    #   blank/empty
     #
     # @since 1.0.0
     # @api private
-    def initialize(name:, child_type: nil, constraints: nil)
+    def initialize(name:, children: nil, constraints: nil)
       msg = 'Argument name was not a String.'
       raise ::TypeError, msg unless name.is_a? String
       msg = 'Argument name was an empty string.'
-      raise ::ArgumentError, msg if name.empty?
-      msg = 'Argument child_type was not Taipo::TypeElement::ChildType.'
-      raise ::TypeError, msg unless (
-                             child_type.nil? ||
-                             child_type.is_a?(Taipo::TypeElement::ChildType)
-                           )
-      msg = 'Argument child_type was empty.'
-      raise ::ArgumentError, msg if child_type&.empty?
-      msg = 'Argument constraints was not an Array.'
-      raise ::TypeError, msg unless (constraints.nil? || constraints.is_a?(Array))
+      raise ::ArgumentError if name.empty?
+
+      msg = 'Argument children was not a Taipo::TypeElement::Children.'
+      raise ::TypeError unless children.nil? ||
+        children.is_a?(Taipo::TypeElement::Children)
+      msg = 'Argument children was empty.'
+      raise ::ArgumentError if !children.nil? && children.empty?
+
+      msg = 'Argument constraints was not a Taipo::TypeElement::Constraints.'
+      raise ::TypeError unless constraints.nil? ||
+        constraints.is_a?(Taipo::TypeElement::Constraints)
       msg = 'Argument constraints was empty.'
-      raise ::ArgumentError, msg if constraints&.empty?
-
-      if Taipo.instance_method?(name) || Taipo.symbol?(name)
-        msg = 'Argument child_type should have been nil.'
-        raise ::ArgumentError, msg unless child_type.nil?
-        msg = 'Argument constraints should have been nil.'
-        raise ::ArgumentError, msg unless constraints.nil?
-
-        constraints = if Taipo.instance_method? name
-                        [Taipo::TypeElement::Constraint.new(name: nil, 
-                                                            value: name[1..-1])]  
-                      elsif Taipo.symbol? name
-                        [Taipo::TypeElement::Constraint.new(name: 'val',
-                                                            value: name)]
-                      end
-        name = 'Object'
-      end
+      raise ::ArgumentError if !constraints.nil? && constraints.empty?
+
       @name = name
-      @child_type = child_type
+      @children = children
       @constraints = constraints
     end
 
@@ -95,21 +82,21 @@ module Taipo
       msg = 'Object to be compared must be of type Taipo::TypeElement.'
       raise ::TypeError, msg unless comp.is_a? Taipo::TypeElement
 
-      @name == comp.name && @child_type == comp.child_type
+      @name == comp.name && @children == comp.children
     end
 
     # Set the element's constraints to +csts+
     #
-    # @param csts [Array<Taipo::TypeElement::Constraint] the constraints
+    # @param csts [Taipo::TypeElement::Constraints] the constraints
     #
-    # @raise [::TypeError] if +csts+ was not an Array
+    # @raise [::TypeError] if +csts+ was not a Taipo::TypeElement::Constraints
     # @raise [Taipo::SyntaxError] if there are constraints with the same name
     #
     # @since 1.0.0
     # @api private
     def constraints=(csts)
-      msg = 'Argument csts was not an Array.'
-      raise ::TypeError, msg unless csts.is_a? Array
+      msg = 'Argument csts was not a Taipo::TypeElement::Constraints.'
+      raise ::TypeError, msg unless csts.is_a? Taipo::TypeElement::Constraints
 
       names = Hash.new
       csts.each do |c|
@@ -137,7 +124,8 @@ module Taipo
     # @api private
     def match?(arg)
       return true if optional? && arg.nil?
-      match_class?(arg) && match_constraints?(arg) && match_child_type?(arg)
+
+      match_class?(arg) && match_constraints?(arg) && match_children?(arg)
     end
 
     # Check if the class of the argument itself matches this element
@@ -161,16 +149,16 @@ module Taipo
       end
     end
 
-    # Check if the class of the argument's child type matches
+    # Check if the class of the argument's children match
     #
     # @param arg [Object] the argument to compare
     #
     # @return [Boolean] the result
     #
-    # @since 1.0.0
+    # @since 1.4.0
     # @api private
-    def match_child_type?(arg)
-      self_childless = @child_type.nil?
+    def match_children?(arg)
+      self_childless = @children.nil?
       arg_childless = !arg.is_a?(Enumerable) || arg.count == 0
       return true if self_childless
       return false if !self_childless && arg_childless
@@ -178,11 +166,11 @@ module Taipo
       arg.all? do |a|
         if !arg.is_a?(Array) && a.is_a?(Array)
           a.each.with_index.reduce(nil) do |memo,(component,index)|
-            result = @child_type[index].any? { |c| c.match? component }
+            result = @children[index].any? { |c| c.match? component }
             (memo.nil?) ? result : memo && result
           end
         else # The elements of this collection have no components
-          @child_type.first.any? { |c| c.match? a }
+          @children.first.any? { |c| c.match? a }
         end
       end
     end
@@ -198,9 +186,7 @@ module Taipo
     def match_constraints?(arg)
       return true if @constraints.nil?
 
-      @constraints.all? do |c|
-        c.constrain?(arg)
-      end
+      @constraints.all? { |c| c.constrain?(arg) }
     end
 
     # Check whether this element is an optional
@@ -209,7 +195,8 @@ module Taipo
     # Taipo borrows the syntax used in some other languages of denoting
     # optional types by appending a question mark to the end of the class name.
     #
-    # @note This merely checks whether +@name+ ends in a question mark.
+    # @note This merely checks whether {Taipo::TypeElement#name} ends in a
+    #   question mark.
     #
     # @return [Boolean] the result
     #
@@ -221,20 +208,15 @@ module Taipo
 
     # Return the String representation of this TypeElement
     #
+    # @return [String] the representation as a String
+    #
     # @since 1.1.0
     # @api private
     def to_s
       name_str = @name
-      child_type_str = (@child_type.nil?) ? '' : @child_type.to_s
-      constraints_str = if @constraints.nil?
-                          ''
-                        else
-                          inner = @constraints.reduce('') do |memo,c|
-                                    (memo == '') ? c.to_s : memo + ',' + c.to_s
-                                  end
-                          '(' + inner + ')'
-                        end
-      name_str + child_type_str + constraints_str
+      children_str = (@children.nil?) ? '' : @children.to_s
+      constraints_str = (@constraints.nil?) ? '' : @constraints.to_s
+      name_str + children_str + constraints_str
     end
   end
 end

data/lib/taipo/type_element/children.rb

@@ -0,0 +1,47 @@
+require 'taipo/type_elements'
+
+module Taipo
+  class TypeElement
+
+    # A set of {Taipo::TypeElements} representing the types of the children of
+    # a collection type
+    #
+    # @since 1.4.0
+    # @api private
+    class Children < Array
+
+      # Initialize a new set of children
+      #
+      # @note The +children+ argument is an array of {Taipo::TypeElements}
+      #   because the element returned by an enumerator for a collection can
+      #   consist of multiple components (eg. in a Hash, where it consists of
+      #   two elements).
+      #
+      # @param children [Array<Taipo::TypeElements>] the components that make
+      #   up the children of the collection
+      #
+      # @since 1.4.0
+      # @api private
+      def initialize(children = nil)
+        children&.each { |c| self.push c }
+      end
+
+      # Return the String representation of this object
+      #
+      # @return [String] the representation as a String
+      #
+      # @since 1.4.0
+      # @api private
+      def to_s
+        inner = self.reduce(nil) do |memo_e,component|
+                  el = component.reduce(nil) do |memo_c,c|
+                         (memo_c.nil?) ? c.to_s : memo_c + '|' + c.to_s
+                       end
+                  (memo_e.nil?) ? el : memo_e + ',' + el
+                end
+        '<' + inner + '>'
+      end
+    end
+  end
+end
+

data/lib/taipo/type_element/constraint.rb

@@ -6,7 +6,7 @@ module Taipo
     # @since 1.0.0
     # @api private
     class Constraint
-    
+
       # The identifier for an instance method
       #
       # @since 1.0.0
@@ -27,30 +27,24 @@ module Taipo
 
       # Initialize a new constraint
       #
-      # @param name [String|NilClass] the name of the constraint (if nil, this 
+      # @param name [String|NilClass] the name of the constraint (if nil, this
       #   is an instance method)
       # @param value [String|NilClass] the value of the constraint (sometimes a
       #   Constraint is initialized before the value is known)
       #
-      # @raise [::TypeError] if +name+ or +value+ were of the wrong type, or 
-      #   +value+ was not of the correct type for the type of constraint 
+      # @raise [::TypeError] if +name+ was the wrong type, or
+      #   +value+ was not of the correct type for the type of constraint
       # @raise [::ArgumentError] if +name+ was blank
       #
       # @since 1.0.0
-      # @api private 
+      # @api private
       def initialize(name: nil, value: nil)
         msg = 'Argument name was not nil or a String.'
         raise ::TypeError, msg unless name.nil? || name.is_a?(String)
         msg = 'Argument name was an empty string.'
-        raise ::ArgumentError, msg if name&.empty?
+        raise ::ArgumentError, msg if !name.nil? && name.empty?
 
-        @name = if name.nil?
-                  Constraint::METHOD
-                elsif name == ':'
-                  'val'
-                else
-                  name
-                end
+        @name = name
         @value = self.parse_value value
       end
 
@@ -97,6 +91,8 @@ module Taipo
       #
       # @param v [Object] the value
       #
+      # @return [Object] the parsed value
+      #
       # @raise [::TypeError] if the value is not appropriate for this type of
       #   constraint
       #
@@ -125,7 +121,7 @@ module Taipo
 
       # Return the String representation of this constraint
       #
-      # @return [String] the String representation
+      # @return [String] the representation as a String
       #
       # @since 1.0.0
       # @api private
@@ -144,7 +140,7 @@ module Taipo
 
       # Set +v+ to be the value for this constraint
       #
-      # @param v [Object] the value to set (this will be parsed using 
+      # @param v [Object] the value to set (this will be parsed using
       #   {#parse_value})
       #
       # @raise [::TypeError] if the value is not appropriate for this type of

data/lib/taipo/type_element/constraints.rb

@@ -0,0 +1,36 @@
+require 'taipo/type_element/constraint'
+
+module Taipo
+  class TypeElement
+
+    # A set of {Taipo::TypeElement::Constraint} objects
+    #
+    # @since 1.4.0
+    # @api private
+    class Constraints < Array
+
+      # Initialize a new set of {Taipo::TypeElement::Constraint}
+      #
+      # @param els [Array<Taipo::TypeElement::Constraint>] the constraints
+      #
+      # @since 1.4.0
+      # @api private
+      def initialize(constraints = nil)
+        constraints&.each { |c| self.push c }
+      end
+
+      # Return the String representation of this object
+      #
+      # @return [String] the representation as a String
+      #
+      # @since 1.4.0
+      # @api private
+      def to_s
+        inner = self.reduce('') do |memo,c|
+                  (memo == '') ? c.to_s : memo + ',' + c.to_s
+                end
+        '(' + inner + ')'
+      end
+    end
+  end
+end

data/lib/taipo/type_elements.rb

@@ -0,0 +1,33 @@
+require 'taipo/type_element'
+
+module Taipo
+
+  # A set of {Taipo::TypeElement} objects
+  #
+  # @since 1.4.0
+  # @api private
+  class TypeElements < Array
+
+    # Initialize a new set of {Taipo::TypeElement}
+    #
+    # @param els [Array<Taipo::TypeElement>] the elements
+    #
+    # @since 1.4.0
+    # @api private
+    def initialize(els = nil)
+      els&.each { |el| self.push el }
+    end
+
+    # Return the String representation of this object
+    #
+    # @return [String] the representation as a String
+    #
+    # @since 1.4.0
+    # @api private
+    def to_s
+      self.reduce('') do |memo,el|
+        (memo == '') ? el.to_s : memo + '|' + el.to_s
+      end
+    end
+  end
+end

data/lib/taipo/utilities.rb

@@ -0,0 +1,81 @@
+module Taipo
+
+  # Utility methods for Taipo
+  #
+  # @since 1.4.0
+  # @api private
+  module Utilities
+
+    # 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.4.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.4.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.4.0
+    # @api private
+    def self.symbol?(str)
+      str[0] == ':'
+    end
+  end
+end