taipo 1.0.0

data/lib/taipo/parser/syntax_state.rb

@@ -0,0 +1,234 @@
+module Taipo
+  module Parser
+
+    # A state machine
+    #
+    # @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 
+      #   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)
+      #
+      # @since 1.0.0
+      # @api private
+      #
+      # @example
+      #   status_array = [ :foo, :bar ]
+      #   counter_array = [ [ :angle ], { angle: '>' } ]
+      #   state = SyntaxState.new(status_array, counter_array)
+      def initialize(state_names, counter_names_and_closers = nil)
+        @status = Hash[state_names.map { |s| [s, :prohibited] }]
+        if counter_names_and_closers.nil?
+          @counter = Array.new
+          @closers = Array.new
+        else
+          @counter = Hash[counter_names_and_closers[0].map { |c| [c, 0] }]
+          @closers = counter_names_and_closers[1]
+        end
+      end
+
+      # Check if the counter for the given +key+ has been incremented
+      #
+      # @param key [Symbol] the counter to check
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.0.0
+      # @api private
+      def active?(key)
+        @counter[key] > 0
+      end
+
+      # Set the status for the given +key+ to be +:allowed+
+      #
+      # @param key [Symbol] the key to set
+      #
+      # @since 1.0.0
+      # @api private
+      def allow(key)
+        @status[key] = :allowed
+      end
+
+      # 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
+      #
+      # @param except [Array<Symbol>] keys not to update to +:allowed+ (will
+      #   instead be set to +:prohibited+)
+      #
+      # @since 1.0.0
+      # @api private
+      def allow_all(except: [])
+        set_all :allowed, except: { exceptions: except, status: :prohibited }
+      end
+
+      # Check if the given +key+ is allowed
+      #
+      # @param key [Symbol] the key to check
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.0.0
+      # @api private  
+      def allowed?(key)
+        @status[key] == :allowed
+      end
+
+      # Get the count for the given +key+
+      #
+      # @param key [Symbol] the key for the counter
+      #
+      # @return [Integer] the count
+      #
+      # @since 1.0.0
+      # @api private
+      def count(key)
+        @counter[key]
+      end
+
+      # 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)
+        msg = 'Trying to reduce count below zero.'
+        raise RangeError, msg if @counter[key] == 0
+        @counter[key] -= 1
+      end
+
+      # Disable the status of the given +key+ (by setting it to +:disabled+)
+      #
+      # @param key [Symbol] the +key+ to disable
+      #
+      # @since 1.0.0
+      # @api private
+      def disable(key)
+        @status[key] = :disabled
+      end
+
+      # Enable the status of the given +key+ (by setting it to +:prohibited+)
+      #
+      # @param key [Symbol] the +key+ to disable
+      #
+      # @since 1.0.0
+      # @api private
+      def enable(key)
+        @status[key] = :prohibited
+      end
+
+      # Increment the counter for the given +key+ by 1
+      #
+      # @param key [Symbol] the key for the counter
+      #
+      # @since 1.0.0
+      # @api private
+      def increment(key)
+        @counter[key] += 1
+      end
+
+      # Check if we are 'inside' a set of brackets (eg. a pair of parentheses)
+      # for a given +key+
+      #
+      # @param key [Symbol] the key for the counter
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.0.0
+      # @api private 
+      def inside?(key)
+        @counter[key] > 0
+      end
+
+      # Check if we are 'outside' a set of brackets (eg. a pair of parentheses)
+      # for a given +key+
+      #
+      # @param key [Symbol] the key for the counter
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.0.0
+      # @api private
+      def outside?(key)
+        @counter[key] == 0
+      end
+
+      # Set the status for the given +key+ to be +:prohibited+
+      #
+      # @param key [Symbol] the key to set
+      #
+      # @since 1.0.0
+      # @api private
+      def prohibit(key)
+        @status[key] = :prohibited
+      end
+
+      # 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
+      #
+      # @param except [Array<Symbol>] keys not to update to +:prohibited+ (will
+      #   instead be set to +:allowed+)
+      #
+      # @since 1.0.0
+      # @api private
+      def prohibit_all(except: [])
+        set_all :prohibited, except: { exceptions: except, status: :allowed }
+      end
+
+      # Check if the given +key+ is allowed
+      #
+      # @param key [Symbol] the key to check
+      #
+      # @since 1.0.0
+      # @api private
+      def prohibited?(key)
+        @status[key] == :prohibited
+      end
+
+      # 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
+      #
+      # @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 [Symbol] :status the value for exceptions
+      #
+      # @since 1.0.0
+      # @api private
+      def set_all(status, except: {})
+        @status.transform_values! { |v| v = status unless v == :disabled }
+        except[:exceptions].each do |k|
+          @status[k] = except[:status] unless @status[k] == :disabled
+        end
+      end
+
+      # Get the names of the unbalanced brackets
+      #
+      # @return [Array<Symbol>] an array of the names of the unbalanced
+      #   brackets
+      #
+      # @since 1.0.0
+      # @api 
+      def unbalanced()
+        @counter.reduce(Array.new) do |memo, c|
+          (c[1] == 0) ? memo : memo.push(@closers[c[0]])
+        end
+      end
+    end
+  end
+end

data/lib/taipo/parser/validater.rb

@@ -0,0 +1,226 @@
+require 'taipo/exceptions'
+require 'taipo/parser/syntax_state'
+
+module Taipo
+  module Parser
+    
+    # A validater of Taipo type definitions
+    # @since 1.0.0
+    module Validater
+
+      # Check +str+ is a valid type definition
+      #
+      # @param str [String] a type definition
+      #
+      # @raise [::TypeError] if +str+ is not a String
+      # @raise [Taipo::SyntaxError] if +str+ is not a valid type definition 
+      #
+      # @since 1.0.0
+      def self.validate(str)
+        msg = "The argument to this method must be of type String."
+        raise ::TypeError, msg unless str.is_a? String
+        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 '#" } ]
+        state = Taipo::Parser::SyntaxState.new(status_array, counter_array)
+
+        i = 0
+        chars = str.chars
+        str_length = chars.size
+
+        state.prohibit_all except: [ :hsh, :oth ]
+
+        while (i < str_length)
+          msg = "The string '#{str}' has an error here: #{str[0, i+1]}"
+          case chars[i]
+          when '|' # bar
+            conditions = [ state.allowed?(:bar) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.enable :lab
+            state.enable :lpr
+            state.prohibit_all except: [ :hsh, :oth ]
+          when '<' # lab
+            conditions = [ state.allowed?(:lab) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :hsh, :oth ]
+            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.decrement :angle
+          when '(' # lpr
+            conditions = [ state.allowed?(:lpr), state.outside?(:paren) ]
+            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
+          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 ]
+            else
+              state.prohibit_all except: [ :oth ]
+              state.decrement :const
+            end
+          when ':' # cln
+            conditions = [ state.allowed?(:cln), state.inside?(:paren) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :sls, :qut, :spc, :oth ]
+            state.decrement :const
+          when '/' #sls
+            conditions = [ state.allowed?(:sls), state.inside?(:paren),
+                           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) ]
+            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) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :spc, :oth ]
+            state.increment :const if state.inside?(:paren)
+          when ' ' # spc
+            conditions = [ state.allowed?(:spc) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            state.prohibit_all except: [ :hsh, :sls, :qut, :oth ]
+          else # oth
+            conditions = [ state.allowed?(:oth) ]
+            raise Taipo::SyntaxError, msg unless conditions.all?
+            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)
+
+        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 regular expression
+      #
+      # @param str [String] a regular expression delimited by '/'
+      # @param start [Integer] the index within the type definition where this
+      #   regex begins
+      #
+      # @return [Integer] the index within the type definition where this regex
+      #   ends
+      #
+      # @raise [Taipo::SyntaxError] if +str+ is not a valid regular expression
+      #
+      # @since 1.0.0
+      # @api private
+      def self.validate_regex(str, start: 0)
+        status_array = [ :bsl, :sls, :opt, :oth ]
+        counter_array = [ [ :backslash ], { backslash: '/' } ]
+
+        state = SyntaxState.new(status_array, counter_array)
+        state.prohibit_all except: [ :bsl, :oth ]
+        finish = start
+
+        str[start, str.length-start].each_char.with_index(start) do |c, i|
+          if state.active?(:backslash) # The preceding character was a backslash.
+            state.decrement(:backslash)
+            next # Any character after a backslash is allowed.
+          end
+
+          msg = "The string '#{str}' has an error here: #{str[0, i+1]}"
+
+          case c
+          when 'i', 'o', 'x', 'm', 'u', 'e', 's', 'n'
+            next # We're either in the regex or in the options that follow.
+          when '/'
+            raise Taipo::SyntaxError, msg unless state.allowed?(:sls)
+            state.prohibit_all except: [ :opt ]
+          when '\\'
+            raise Taipo::SyntaxError, msg unless state.allowed?(:bsl)
+            state.increment(:backslash)
+          when ',', ')'
+            next if state.allowed?(:oth)
+            finish = i
+            break # The string has ended.
+          else
+            raise Taipo::SyntaxError, msg unless state.allowed?(:oth)
+            state.allow_all
+          end
+        end
+
+        msg = "The string '#{str}' is missing a '/'."
+        raise Taipo::SyntaxError, msg if finish == start
+
+        finish - 1
+      end
+
+      # Check +str+ is a valid string
+      #
+      # @param str [String] a string delimited by '"'
+      # @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
+      # @api private
+      def self.validate_string(str, start: 0)
+        status_array = [ :bsl, :qut, :oth ]
+        counter_array = [ [ :backslash ], { backslash: '/' } ]
+
+        state = SyntaxState.new(status_array, counter_array)
+        state.prohibit_all except: [ :bsl, :oth ]
+        finish = start
+
+        str[start, str.length-start].each_char.with_index(start) do |c, i|
+          if state.active?(:backslash) # The preceding character was a backslash.
+            state.decrement :backslash
+            next # Any character after a backslash is allowed.
+          end
+
+          msg = "The string '#{str}' has an error here: #{str[0, i+1]}"
+
+          case c
+          when '"'
+            raise Taipo::SyntaxError, msg unless state.allowed?(:qut)
+            state.prohibit_all
+          when '\\'
+            raise Taipo::SyntaxError, msg unless state.allowed?(:bsl)
+            state.increment :backslash
+          when ',', ')'
+            next if state.allowed?(:oth)
+            finish = i
+            break # The string has ended.
+          else
+            raise Taipo::SyntaxError, msg unless state.allowed?(:oth)
+            state.allow_all
+          end
+        end
+
+        msg = "The string '#{str}' is missing a '\"'."
+        raise Taipo::SyntaxError, msg if finish == start
+
+        finish - 1
+      end
+    end
+  end
+end