modl 0.3.26 → 0.3.27

data/lib/modl/parser/ref_processor.rb

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'punycode'
-require 'modl/parser/sutil'
-
-module MODL
-  module Parser
-    # Convert MODL reference to the replacement value
-    class RefProcessor
-
-      NESTED_SEPARATOR = '.'
-      MATCHER = Regexp.new('((%\w+)(\.\w*<`?\w*`?,`\w*`>)+|(%` ?[\w-]+`[\w.<>,]*%?)|(%\*?[\w]+(\.%?\w*<?[\w,]*>?)*%?))')
-      MAX_RECURSE_DEPTH = 10
-
-      def self.trivial_reject(str)
-        # do a fast check to see if we need to deref - save processing the regex if we don't have to.
-        !(str.is_a?(String) && !str.start_with?('%*') && (str.nil? || str.include?('%') || str.include?('`')))
-      end
-
-      # Check str for references and process them.
-      # Return the processed string and a new_value if there is one.
-      def self.deref(str, global)
-        obj = str
-        obj, new_value = split_by_ref_tokens str, global unless trivial_reject(str)
-        [obj, new_value]
-      end
-
-      # Process the next %ref token
-      def self.split_by_ref_tokens(str, global)
-        new_value = nil
-
-        text = str
-        original = str
-
-        new_value, str = process_tokens(global, original, str, text) if new_value.nil?
-
-        [str, new_value]
-      end
-
-      private
-
-      def self.process_tokens(global, original, str, text)
-        new_value = nil
-        loop do
-          text_s = text.to_s
-          match = MATCHER.match(text_s)
-          break if match.nil?
-
-          match_index = text_s.index(match[0])
-          if match_index > 0
-            if text_s[match_index - 1] == '~' || text_s[match_index - 1] == '\\'
-              break
-            end
-            if text_s[match_index + match.length] == '~' || text_s[match_index + match.length] == '\\'
-              break
-            end
-          end
-
-
-          ref = match[0]
-          text = Sutil.after(text, ref)
-
-          new_value, remainder = expand(0, global, ref)
-          ref = Sutil.until(ref, remainder)
-          if new_value.is_a?(String)
-            str = str.sub(ref, new_value)
-          elsif new_value.is_a?(Parsed::ParsedArrayItem)
-            nv_text = new_value.arrayValueItem.text
-            str = if ref == str
-                    nv_text
-                  else
-                    str.sub(ref, nv_text.to_s)
-                  end
-            new_value = nil
-          elsif new_value.is_a?(Parsed::ParsedMapItem)
-            raise InterpreterError, 'Found a map when expecting an array'
-          elsif new_value.is_a?(MODL::Parser::MODLParserBaseListener)
-            if new_value.text
-              str = if ref == str
-                      new_value.text
-                    else
-                      str.sub(ref, Sutil.unquote(new_value.text.to_s))
-                    end
-              new_value = nil
-            else
-              str = nil
-            end
-          else
-            new_value = nil
-            raise InterpreterError, 'Invalid object reference: "' + str + '"' if str == original
-          end
-        end
-        return new_value, str
-      end
-
-      def self.expand(depth, global, ref)
-        if depth > MAX_RECURSE_DEPTH
-          raise InterpreterError, 'Recursing too deep to resolve: "' + ref + '"'
-        end
-        result = nil
-        prev = nil
-
-        degraved = Sutil.replace(ref, '`', '')
-
-        parts = Sutil.tail(degraved).split('.') if degraved[0] == '%'
-        parts = degraved.split('.') unless degraved[0] == '%'
-        parts[-1] = Sutil.head(parts[-1]) if parts[-1].end_with?('%')
-
-        if degraved.include?('%')
-          resolved = 0
-          parts.each do |p|
-            if p.include?('%')
-              p, _ignore = expand(depth + 1, global, p)
-              if p.is_a?(MODL::Parser::MODLParserBaseListener)
-                p = p.text
-              end
-            end
-            n = p.to_i
-            result = if n.to_s == p
-                       # Numeric ref
-                       if !result.nil? && !result.respond_to?(:find_property)
-                         if !result.is_a?(Parsed::ParsedArrayValueItem)
-                           t = result.class
-                           t = 'map' if result.is_a? Parsed::ParsedMapItem
-                           raise InterpreterError, 'Found a ' + t + ' when expecting an array'
-                         end
-                         raise InterpreterError, 'Invalid object reference: "' + degraved + '"'
-                       end
-                       result.nil? ? global.index_value(n, degraved) : result.find_property(n)
-                     else
-                       # String ref
-                       if result.is_a? String
-                         if StandardMethods.valid_method?(p)
-                           StandardMethods.run_method(p, result)
-                         else
-                           mthd = global.user_method(p)
-                           if !mthd.nil?
-                             mthd.run(result)
-                           else
-                             mthd
-                           end
-                         end
-                       elsif result.is_a? Parsed::ParsedPair
-                         prop = result.find_property(p)
-                         if result.text && !prop
-                           if StandardMethods.valid_method?(p)
-                             StandardMethods.run_method(p, Sutil.unquote(result.text))
-                           else
-                             mthd = global.user_method(p)
-                             if !mthd.nil?
-                               mthd.run(result.text)
-                             else
-                               mthd
-                             end
-                           end
-                         else
-                           prop
-                         end
-                       elsif result.is_a? Parsed::ParsedArrayValueItem
-                         prop = result.find_property(p)
-                         if result.text && !prop
-                           if StandardMethods.valid_method?(p)
-                             result_text = result.text
-                             if result_text.start_with?('`') && result_text.end_with?('`')
-                               result_text = Sutil.toptail(result_text)
-                             end
-                             StandardMethods.run_method(p, result_text)
-                           else
-                             mthd = global.user_method(p)
-                             if !mthd.nil?
-                               mthd.run(result.text)
-                             else
-                               mthd
-                             end
-                           end
-                         else
-                           prop
-                         end
-                       elsif result.is_a? Array
-                         nil
-                       else
-                         if !result.nil? && !result.respond_to?(:find_property)
-                           raise InterpreterError, 'Invalid object reference: "' + degraved + '"'
-                         end
-                         if result.nil?
-                           unless ref.start_with?('%`')
-                             a_pair = global.pair(p)
-                           end
-                           if a_pair.nil?
-                             p
-                           else
-                             a_pair
-                           end
-                         else
-                           result.find_property(p)
-                         end
-                       end
-                     end
-            break if result.nil?
-
-            prev = result
-            resolved += 1
-          end
-          if prev.nil?
-            remainder = ''
-            prev = degraved
-          else
-            remainder = resolved < parts.length ? '.' + parts[resolved..parts.length].join('.') : ''
-          end
-          if (prev == Sutil.between(ref, '%', '%')) || (ref.start_with?('%') && prev == Sutil.tail(ref))
-            prev = ref
-          end
-          [prev, remainder]
-        else
-          # Remove the graves if there are any.
-          result = parts[0]
-          i = 1
-          stalled = false
-          while i < parts.length
-            stalled |= StandardMethods.valid_method?(parts[i]) ? false : true
-
-            if stalled
-              result << '.'
-              result << parts[i]
-            else
-              result = StandardMethods.run_method(parts[i], result)
-            end
-            i += 1
-          end
-          [result, '']
-        end
-      end
-
-    end
-  end
-end

data/lib/modl/parser/substitutions.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'modl/parser/unicode_escape_replacer'
-
-module MODL
-  module Parser
-    # Escape-sequence replacements for MODL files.
-    class Substitutions
-
-      @@subs = [
-          %w(~% %),
-          %w(\\% %),
-          %w(~\\ \\),
-          %w(\\\\ \\),
-          %w(~~ ~),
-          %w(\\~ ~),
-          %w{~( (},
-          %w{\\( (},
-          %w{~) )},
-          %w{\\) )},
-          %w(~[ [),
-          %w(\\[ [),
-          %w(~] ]),
-          %w(\\] ]),
-          %w(~{ {),
-          %w(\\{ {),
-          %w(~} }),
-          %w(\\} }),
-          %w(~; ;),
-          %w(\\; ;),
-          %w(~: :),
-          %w(\\: :),
-          %w(~` `),
-          %w(\\` `),
-          %w(~" "),
-          %w(\\" "),
-          %w(~= =),
-          %w(\\= =),
-          %w(~/ /),
-          %w(\\/ /),
-          %w(< <),
-          %w(\\< <),
-          %w(~> >),
-          %w(\\> >),
-          %w(~& &),
-          %w(\\& &),
-          %w(! !),
-          %w(\\! !),
-          %w(~| |),
-          %w(\\| |),
-          ['\\t', "\t"],
-          ['\\n', "\n"],
-          ['\\b', "\b"],
-          ['\\f', "\f"],
-          ['\\r', "\r"]
-      ]
-
-      # Replace all escape sequences in the supplied string and return the new value.
-      def self.process(str)
-        return str unless str.is_a? String
-
-        # Remove unescaped graves and double quotes
-        new_str = Sutil.unquote(str)
-
-        new_str = UnicodeEscapeReplacer.convert_unicode_sequences new_str
-
-        # Handle escape sequences
-        @@subs.each do |s|
-          loop do
-            prev = new_str
-            new_str = new_str.sub(s[0], s[1])
-            break unless new_str && new_str != prev
-          end
-        end
-        new_str
-      end
-    end
-  end
-end

data/lib/modl/parser/sutil.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-module Sutil
-  # Remove the first n characters from a string
-  def self.tail(str, n = 1)
-    return if n.negative?
-
-    str&.slice(n, str.length)
-  end
-
-  # Keep the first n characters of a string
-  def self.head(str, n = nil)
-    return if str.nil?
-
-    n = str.length - 1 if n.nil? # Strip last char by default
-
-    str&.slice(0, n)
-  end
-
-  # Keep everything until char c
-  def self.until(str, c)
-    return str if c.nil? || c.empty?
-
-    i = str.index(c)
-    i ? str&.slice(0, i) : str
-  end
-
-  # Get everything after char c
-  def self.after(str, c)
-    return if str.nil?
-    return str if c.nil?
-
-    i = str.index(c)
-    return '' if i.nil?
-
-    str.slice(i + c.length, str.length)
-  end
-
-  # Get everything between ch1 and ch2
-  # ch1 and ch2 must be different and ch1 must be before ch2 in the string
-  # e.g. Sutil.between('func(p1,p2)', '(', ')') returns 'p1,p2'
-  def self.between(str, ch1, ch2)
-    return if str.nil?
-    return str if ch1.nil? || ch2.nil? || ch1 == '' || ch2 == ''
-    return str if str.length < 3
-
-    first = str.index(ch1)
-    second = str.rindex(ch2)
-    if first > second
-      tmp = first
-      first = second
-      second = tmp
-    end
-    return str if first == second
-
-    str.slice(first + 1, second - first - 1)
-  end
-
-  # Remove the first and last chars from a string.
-  def self.toptail(str)
-    return str if str.nil?
-    return '' if str.length < 3
-
-    str&.slice(1, str.length - 2)
-  end
-
-  def self.replace(str, old, new)
-    return str if old.nil? || new.nil? || old.empty? || old == new
-
-    result = str
-    loop do
-      break unless result.include?(old)
-
-      result = result.sub(old, new)
-    end
-    result
-  end
-
-  def self.unquote(str)
-    new_str = str
-    if (str.start_with?('`') && str.end_with?('`')) || (str.start_with?('"') && str.end_with?('"'))
-      new_str = Sutil.toptail(str)
-    end
-    new_str
-  end
-end

data/lib/modl/parser/throwing_error_listener.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'antlr4/runtime/parse_cancellation_exception'
-
-module MODL::Parser
-  class ThrowingErrorListener
-    include Singleton
-
-    def syntax_error(_recognizer, _offending_symbol, _line, _char_position_in_line, _msg, _e)
-      raise Antlr4::Runtime::ParseCancellationException, 'line ' + _line.to_s + ':' + _char_position_in_line.to_s + ' ' + _msg.to_s
-    end
-
-    def report_ambiguity(_recognizer, _dfa, _start_index, _stop_index, _exact, _ambig_ilts, _configs)
-    end
-
-    def report_attempting_full_context(_recognizer, _dfa, _start_index, _stop_index, _conflicting_alts, _configs)
-    end
-
-    def report_context_sensitivity(_recognizer, _dfa, _start_index, _stop_index, _prediction, _configs)
-    end
-  end
-end

data/lib/modl/parser/unicode_escape_replacer.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-module MODL
-  module Parser
-    # Unicode replacements for MODL files.
-    class UnicodeEscapeReplacer
-      BACKSLASH_U = "\\u"
-      TILDE_U = "~u"
-      TILDE = '~'
-      BACKSLASH = '\\'
-      HEX = 16
-
-      def self.convert_unicode_sequences(str)
-        start = 0
-        result = str
-
-        until result.nil?
-          # We could have a backslash-u escape sequence or a ~u escape sequence
-          back_slash_u_index = result.index(BACKSLASH_U, start)
-          tilde_u_index = result.index(TILDE_U, start)
-
-          # Filter out cases with no escape sequences.
-          unicode_str_idx = 0
-          if tilde_u_index.nil? && back_slash_u_index.nil?
-            break
-          elsif tilde_u_index.nil?
-            unicode_str_idx = back_slash_u_index # No ~? Must be backslash
-          elsif back_slash_u_index.nil?
-            unicode_str_idx = tilde_u_index # No backslash? Must be ~
-          else
-            # Pick the first escaped character and proceed with that one.
-            unicode_str_idx = [back_slash_u_index, tilde_u_index].min
-          end
-
-          try_parse_result = try_parse(result, unicode_str_idx + 2)
-
-          # Next time round the loop we start searching after the current escape sequence.
-          start = unicode_str_idx + 1
-
-          # If the escape sequence is itself escaped then don't replace it
-          if unicode_str_idx > 0 && (result[unicode_str_idx - 1] == TILDE || result[unicode_str_idx - 1] == BACKSLASH)
-            next
-          end
-
-          # Get the codepoint value and replace the escape sequence
-          if try_parse_result.code_point > 0
-            chars = try_parse_result.code_point.chr(Encoding::UTF_8)
-            result = replace(result, chars, unicode_str_idx, try_parse_result.length + 2)
-          end
-        end
-        result
-      end
-
-      private
-
-      #
-      # Replace a unicode value in a String
-      #
-      def self.replace(s, value, unicode_str_index, length)
-        left = s.slice(0, unicode_str_index)
-        ends = [s.length, unicode_str_index + length].min
-        right = s.slice(ends, s.length)
-        left + value.to_s + right
-      end
-
-      #
-      # Check whether the value is a valid unicode codepoint
-      #
-      def self.valid_range?(value)
-        (value >= 0x100000 && value <= 0x10ffff) || (value >= 0x10000 && value <= 0xfffff) || (value >= 0 && value <= 0xd7ff) || (value >= 0xe000 && value <= 0xffff)
-      end
-
-      #
-      # Can we get `n` hex digits from the string at the `idx` location?
-      #
-      def self.has_enough_digits?(s, idx, n)
-        i = 0
-        chars = s.chars
-
-        while i < n && (idx + i) < s.length
-          c = chars[idx + i]
-          unless c =~ /[0-9a-fA-F]/
-            return false
-          end
-          i += 1
-        end
-        i == n
-      end
-
-      #
-      # Attempt to parse a unicode character starting at `idx` in `str`
-      #
-      def self.try_parse(str, idx)
-        # Check for a 6-digit unicode value
-        if has_enough_digits? str, idx, 6
-          value = str.slice(idx, 6).to_i(HEX)
-          return TryParse.new(value, 6) if valid_range? value
-        end
-
-        # Check for a 5-digit unicode value
-        if has_enough_digits? str, idx, 5
-          value = str.slice(idx, 5).to_i(HEX)
-          return TryParse.new(value, 5) if valid_range? value
-        end
-
-        # Check for a 4-digit unicode value
-        if has_enough_digits? str, idx, 4
-          value = str.slice(idx, 4).to_i(HEX)
-          return TryParse.new(value, 4) if valid_range? value
-        end
-        return TryParse.new(0, 4)
-      end
-    end
-
-    # Class to hold the result of the tryParse method
-    class TryParse
-      attr_accessor :code_point
-      attr_accessor :length
-
-      def initialize(code, len)
-        @code_point = code
-        @length = len
-      end
-    end
-  end
-end