taipo 1.3.0 → 1.4.0

data/lib/taipo/parser/stack.rb

@@ -0,0 +1,143 @@
+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
+  module Parser
+
+    # A stack of parsed or partially parsed elements
+    #
+    # @since 1.4.0
+    # @api private
+    class Stack < Array
+
+      # Initialize the stack
+      #
+      # @since 1.4.0
+      # @api private
+      def initialize
+        self.push Taipo::TypeElements.new
+      end
+
+      # Return the resulting {Taipo::TypeElements} object
+      #
+      # @note This should not be called until parsing is complete.
+      #
+      # @return [Taipo::TypeElements] the parsed object representing the
+      #   relevant type definition
+      #
+      # @raise [RuntimeError] if there is more than one element in the stack
+      #
+      # @since 1.4.0
+      # @api private
+      def result
+        msg = "Something went wrong. There should only be one element left."
+        raise RuntimeError, msg if self.size != 1
+        self.first
+      end
+
+      # Add a {Taipo::TypeElement::Children} object to the top of the stack
+      #
+      # @note Due to the way {Taipo::Parser} is implemented, this method will
+      #   also add an empty {Taipo::TypeElements} object to the stack. This
+      #   represents the first (and possibly only) component of the collection.
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def add_children
+        self.push Taipo::TypeElement::Children.new
+        self.push Taipo::TypeElements.new
+      end
+
+      # Remove a {Taipo::TypeElement::Children} object from the top of the stack
+      #
+      # @note Due to the way {Taipo::Parser} is implemented, this method first
+      #   removes the child that is at the top of the stack, adds that to the
+      #   set of children and then returns the children.
+      #
+      # @return [Taipo::TypeElement::Children] the children
+      #
+      # @since 1.4.0
+      # @api private
+      def remove_children
+        child = self.pop
+        self.last.push child
+        self.pop
+      end
+
+      # Add a {Taipo::TypeElements} object to the top of the stack
+      #
+      # @note Due to the way {Taipo::Parser} is implemented, this method first
+      #   removes the child that is at the top of the stack, adds that to the
+      #   set of children and then add a new child.
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def add_child
+        child = self.pop
+        self.last.push child
+        self.push Taipo::TypeElements.new
+      end
+
+      # Add a {Taipo::TypeElement::Constraints} object to the top of the stack
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def add_constraints
+        self.push Taipo::TypeElement::Constraints.new
+      end
+
+      # Remove a {Taipo::TypeElement::Constraints} object from the top of the
+      # stack
+      #
+      # @return [Taipo::TypeElement::Constraints] the constraints
+      #
+      # @since 1.4.0
+      # @api private
+      def remove_constraints
+        self.pop
+      end
+
+      # Add a {Taipo::TypeElement::Constraint} object to the top of the stack
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def add_constraint(constraint)
+        self.last.push constraint
+        self
+      end
+
+      # Add a {Taipo::TypeElement} object to the top of the stack
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def add_element(name:)
+        self.last.push Taipo::TypeElement.new(name: name)
+        self
+      end
+
+      # Update the {Taipo::TypeElement} object at the top of the stack
+      #
+      # @return [Taipo::Parser::Stack] the updated stack
+      #
+      # @since 1.4.0
+      # @api private
+      def update_element(method, arg)
+        self.last.last.send method, arg
+        self
+      end
+    end
+  end
+end

data/lib/taipo/parser/syntax_state.rb

@@ -6,14 +6,14 @@ module Taipo
     # @since 1.0.0
     # @api private
     class SyntaxState
- 
+
       # Initialize a new state machine
       #
       # @param state_names [Array<Symbol>] an array of symbols designating the
       #   particular states to be used
       # @param counter_names_and_closers [Array<Array<Symbol>,Hash<Symbol,
       #   String>>] an array of two collections: an array of symbols
-      #   designating the names the state machine will use for counting 
+      #   designating the names the state machine will use for counting
       #   brackets and a hash of closing characters used for each bracket (the
       #   key for each closing character should have the same name as the name
       #   used for the counter)
@@ -58,10 +58,10 @@ module Taipo
         @status[key] = :allowed
       end
 
-      # Set all statuses to be +:allowed+ except those specified in the 
+      # Set all statuses to be +:allowed+ except those specified in the
       # +except+ array
       #
-      # @note Statuses which have been set to +:disabled+ will not be updated
+      # @note Statuses which have been set to +:disabled+ will not be updated.
       #
       # @param except [Array<Symbol>] keys not to update to +:allowed+ (will
       #   instead be set to +:prohibited+)
@@ -79,7 +79,7 @@ module Taipo
       # @return [Boolean] the result
       #
       # @since 1.0.0
-      # @api private  
+      # @api private
       def allowed?(key)
         @status[key] == :allowed
       end
@@ -99,7 +99,7 @@ module Taipo
       # Decrement the count for the given +key+ by 1
       #
       # @param key [Symbol] the key for the counter
-      # 
+      #
       # @since 1.0.0
       # @api private
       def decrement(key)
@@ -146,7 +146,7 @@ module Taipo
       # @return [Boolean] the result
       #
       # @since 1.0.0
-      # @api private 
+      # @api private
       def inside?(key)
         @counter[key] > 0
       end
@@ -177,7 +177,7 @@ module Taipo
       # Set all statuses to be +:prohibited+ except those specified in the
       # +except+ array
       #
-      # @note Statuses which have been set to +:disabled+ will not be updated
+      # @note Statuses which have been set to +:disabled+ will not be updated.
       #
       # @param except [Array<Symbol>] keys not to update to +:prohibited+ (will
       #   instead be set to +:allowed+)
@@ -201,11 +201,12 @@ module Taipo
       # Set all statuses to be +status+ except those specified in the +except+
       # array
       #
-      # @note Statuses which have been set to +:disabled+ will not be updated
+      # @note Statuses which have been set to +:disabled+ will not be updated.
       #
       # @param status [Symbol] the value for all statuses
       # @param except [Hash<Array<Symbol>, Symbol>] the exceptions
-      # @option except [Array<Symbol>] :exceptions keys not to update to +status+
+      # @option except [Array<Symbol>] :exceptions keys not to update to
+      #   +status+
       # @option except [Symbol] :status the value for exceptions
       #
       # @since 1.0.0
@@ -223,7 +224,7 @@ module Taipo
       #   brackets
       #
       # @since 1.0.0
-      # @api 
+      # @api
       def unbalanced()
         @counter.reduce(Array.new) do |memo, c|
           (c[1] == 0) ? memo : memo.push(@closers[c[0]])

data/lib/taipo/parser/validater.rb

@@ -11,9 +11,10 @@ module Taipo
     #
     # === Names
     #
-    #   'String', 'Numeric'
+    #   'String', 'Numeric', 'Foo::Bar'
     #
-    # A name should be the name of a class or a module.
+    # A name should be the name of a class or a module. A name can include a
+    # namespace.
     #
     # The validater does not check whether the name represents a valid name in
     # the current context nor does it check whether the name complies with
@@ -120,8 +121,8 @@ module Taipo
     #   ':foo|:bar', ':one|:two|:three'
     #
     # It's possible to approximate the enum idiom available in many languages
-    # by creating a sum type consisting of Symbols. As a convenience, Taipo 
-    # parses these values as constraints on the Object class. In other words, 
+    # by creating a sum type consisting of Symbols. As a convenience, Taipo
+    # parses these values as constraints on the Object class. In other words,
     # +':foo|:bar'+ is really +'Object(val: :foo)|Object(val: :bar)'+.
     #
     # @since 1.0.0
@@ -143,92 +144,159 @@ module Taipo
         msg = "The string to be checked was empty."
         raise Taipo::SyntaxError, msg if str.empty?
 
-        status_array = [ :bar, :lab, :rab, :lpr, :rpr, :hsh, :cln, :sls, :qut,
-                         :cma, :spc, :oth, :end ]
-        counter_array = [ [ :angle, :paren, :const ],
-                          { angle: '>', paren: ')', const: ":' or '#" } ]
+        status_array = [ :bar, :lab, :rab, :lpr, :hsh, :cln, :cma, :spc_bar,
+                         :spc_rab, :spc_rpr, :spc_cma, :spc_oth, :mth, :sym,
+                         :nme, :end ]
+        counter_array = [ [ :angle ], { angle: '>' } ]
+
         state = Taipo::Parser::SyntaxState.new(status_array, counter_array)
+        state.prohibit_all except: [ :lpr, :hsh, :cln, :nme ]
 
         i = 0
         chars = str.chars
-        str_length = chars.size
-
-        state.prohibit_all except: [ :lpr, :hsh, :cln, :oth ]
 
-        while (i < str_length)
+        while (i < chars.size)
           msg = "The string '#{str}' has an error here: #{str[0, i+1]}"
           case chars[i]
+          when ')', '/', '"'
+            raise Taipo::SyntaxError, msg
           when '|' # bar
             conditions = [ state.allowed?(:bar) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            state.enable :lab
-            state.enable :lpr
-            state.prohibit_all except: [ :lpr, :hsh, :cln, :oth ]
+            state.prohibit_all except: [ :lpr, :hsh, :cln, :spc_bar, :nme ]
           when '<' # lab
             conditions = [ state.allowed?(:lab) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            state.prohibit_all except: [ :lpr, :hsh, :cln, :oth ]
+            state.prohibit_all except: [ :lpr, :hsh, :cln, :nme ]
             state.increment :angle
           when '>' # rab
             conditions = [ state.allowed?(:rab), state.inside?(:angle) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            state.prohibit_all except: [ :bar, :rab, :lpr, :end ]
+            state.prohibit_all except: [ :bar, :rab, :lpr, :spc_rab, :end ]
             state.decrement :angle
           when '(' # lpr
-            conditions = [ state.allowed?(:lpr), state.outside?(:paren) ]
+            conditions = [ state.allowed?(:lpr) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            state.prohibit_all except: [ :hsh, :oth ]
-            state.increment :paren
-            state.increment :const
-          when ')' # rpr
-            conditions = [ state.allowed?(:rpr), state.inside?(:paren) ]
-            raise Taipo::SyntaxError, msg unless conditions.all?
-            state.prohibit_all except: [ :bar, :rab, :end ]
-            state.decrement :paren
+            i = Taipo::Parser::Validater.validate_constraints(str, start: i+1)
+            state.prohibit_all except: [ :bar, :rab, :spc_rpr, :end ]
           when '#' # hsh
             conditions = [ state.allowed?(:hsh) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            if state.outside? :paren
-              state.disable :lab
-              state.disable :lpr
-              state.prohibit_all except: [ :oth ]
+            state.prohibit_all except: [ :mth ]
+          when ':' # cln
+            if chars[i+1] == ':' && chars[i+2] != ':'
+              conditions = [ state.allowed?(:nme) ]
+              raise Taipo::SyntaxError, msg unless conditions.all?
+              state.prohibit_all except: [ :nme ]
+              i = i + 1
             else
-              state.prohibit_all except: [ :oth ]
-              state.decrement :const
+              conditions = [ state.allowed?(:cln) ]
+              raise Taipo::SyntaxError, msg unless conditions.all?
+              state.prohibit_all except: [ :sym ]
+            end
+          when ',' # cma
+            conditions = [ state.allowed?(:cma), state.inside?(:angle)]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :hsh, :cln, :spc_cma, :nme ]
+          when ' ' # spc
+            conditions = [ state.allowed?(:spc_bar), state.allowed?(:spc_cma),
+                           state.allowed?(:spc_oth) ]
+            raise Taipo::SyntaxError, msg unless conditions.any?
+            if state.allowed?(:spc_bar) || state.allowed?(:spc_cma)
+              state.prohibit_all except: [ :hsh, :cln, :nme ]
+            elsif state.allowed?(:spc_rab) || state.allowed?(:spc_rpr)
+              state.prohibit_all except: [ :bar, :hsh, :cln, :nme ]
+            elsif state.allowed?(:spc_oth)
+              state.prohibit_all except: [ :bar ]
+            end
+          else # oth
+            conditions = [ state.allowed?(:mth), state.allowed?(:sym),
+                           state.allowed?(:nme) ]
+            raise Taipo::SyntaxError, msg unless conditions.any?
+            if state.allowed?(:mth)
+              state.prohibit_all except: [ :bar, :rab, :cma, :spc_oth, :mth,
+                                           :end ]
+            elsif state.allowed?(:sym)
+              state.prohibit_all except: [ :bar, :rab, :cma, :spc_oth, :sym,
+                                           :end ]
+            elsif state.allowed?(:nme)
+              state.prohibit_all except: [ :bar, :lab, :rab, :lpr, :cma,
+                                           :spc_oth, :nme, :end ]
             end
+          end
+          i += 1
+        end
+
+        msg_end = "The string '#{str}' ends with an illegal character."
+        raise Taipo::SyntaxError, msg_end unless state.allowed?(:end)
+
+        missing = state.unbalanced
+        msg_bal = "The string '#{str}' is missing a '#{missing.first}'."
+        raise Taipo::SyntaxError, msg_bal unless missing.size == 0
+      end
+
+      # Check +str+ is a valid set of constraints
+      #
+      # @param str [String] the type definition
+      # @param start [Integer] the index within the type definition where this
+      #   set of constraints begins
+      #
+      # @return [Integer] the index within the type definition where this set of
+      #   set of constraints end
+      #
+      # @raise [Taipo::SyntaxError] if +str+ is not a valid set of constraints
+      #
+      # @since 1.4.0
+      # @api private
+      def self.validate_constraints(str, start: 0)
+        status_array = [ :rpr, :hsh, :cln, :sls, :qut, :cma, :spc, :oth ]
+        counter_array = [ [ :const ], { const: ":' or '#" } ]
+
+        state = SyntaxState.new(status_array, counter_array)
+        state.prohibit_all except: [ :hsh, :oth ]
+        state.increment(:const)
+
+        i = start
+        chars = str.chars
+
+        while (i < chars.size)
+          msg = "The string '#{str}' has an error here: #{str[0, i+1]}"
+          case chars[i]
+          when '|', '<', '>', '('
+            raise Taipo::SyntaxError, msg
+          when ')' # rpr
+            conditions = [ state.allowed?(:rpr) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            break # The constraints have ended.
+          when '#' # hsh
+            conditions = [ state.allowed?(:hsh) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :oth ]
+            state.decrement :const
           when ':' # cln
             conditions = [ state.allowed?(:cln) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            if state.outside? :paren
-              state.disable :lab
-              state.disable :lpr
-              state.prohibit_all except: [ :oth ]
+            if state.count(:const) == 0 # This is a symbol.
+              state.prohibit_all except: [ :qut, :oth ]
             else
-              if state.count(:const) == 0 # This is a symbol.
-                state.prohibit_all except: [ :qut, :oth ]
-              else
-                state.prohibit_all except: [ :cln, :sls, :qut, :spc, :oth ]
-                state.decrement :const
-              end
+              state.prohibit_all except: [ :cln, :sls, :qut, :spc, :oth ]
+              state.decrement :const
             end
           when '/' #sls
-            conditions = [ state.allowed?(:sls), state.inside?(:paren),
-                           state.outside?(:const) ]
+            conditions = [ state.allowed?(:sls), state.outside?(:const) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
             i = Taipo::Parser::Validater.validate_regex(str, start: i+1)
             state.prohibit_all except: [ :rpr, :cma ]
           when '"' #qut
-            conditions = [ state.allowed?(:qut), state.inside?(:paren),
-                           state.outside?(:const) ]
+            conditions = [ state.allowed?(:qut), state.outside?(:const) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
             i = Taipo::Parser::Validater.validate_string(str, start: i+1)
             state.prohibit_all except: [ :rpr, :cma ]
           when ',' # cma
-            conditions = [ state.allowed?(:cma),
-                           state.inside?(:angle) || state.inside?(:paren) ]
+            conditions = [ state.allowed?(:cma) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
             state.prohibit_all except: [ :spc, :oth ]
-            state.increment :const if state.inside?(:paren)
+            state.increment :const
           when ' ' # spc
             conditions = [ state.allowed?(:spc) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
@@ -236,25 +304,24 @@ module Taipo
           else # oth
             conditions = [ state.allowed?(:oth) ]
             raise Taipo::SyntaxError, msg unless conditions.all?
-            if state.inside? :paren
-              state.allow_all except: [ :hsh, :spc ]
-            else
-              state.allow_all except: [ :hsh, :cln, :spc ]
-            end
+            state.allow_all except: [ :hsh, :spc ]
           end
           i += 1
         end
-        msg_end = "The string '#{str}' ends with an illegal character."
-        raise Taipo::SyntaxError, msg_end unless state.allowed?(:end)
+
+        msg = "The string '#{str}' is missing a ')'."
+        raise Taipo::SyntaxError, msg if i == chars.size
 
         missing = state.unbalanced
         msg_bal = "The string '#{str}' is missing a '#{missing.first}'."
         raise Taipo::SyntaxError, msg_bal unless missing.size == 0
+
+        i
       end
 
       # Check +str+ is a valid regular expression
       #
-      # @param str [String] a regular expression delimited by '/'
+      # @param str [String] the type definition
       # @param start [Integer] the index within the type definition where this
       #   regex begins
       #
@@ -308,12 +375,13 @@ module Taipo
 
       # Check +str+ is a valid string
       #
-      # @param str [String] a string delimited by '"'
+      # @param str [String] the type definition
       # @param start [Integer] the index within the type definition where this
       #   string begins
       #
       # @return [Integer] the index within the type definition where this
       #   string ends
+      #
       # @raise [Taipo::SyntaxError] if +str+ is not a valid string
       #
       # @since 1.0.0