modl 0.3.26 → 0.3.27

data/lib/modl/parser/global_parse_context.rb

@@ -1,318 +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
-    # Each time we run the parser on a MODL file we need to keep track of a few things so they can be made available
-    # to other areas of the code. This class is the container for that contextual information, which is gathered
-    # as the MODL::Parser:Parsed object processes the parse tree.
-    class GlobalParseContext
-
-      attr_accessor :syntax_version
-      attr_accessor :max_files_allowed
-      attr_accessor :structures
-      attr_reader :interpreter_syntax_version
-      attr_reader :loaded_files
-
-      def initialize
-        # This keeps track of all loaded structures from parsed files.
-        @structures = []
-        # This is set to true if we encounter a *L[OAD] instruction
-        @max_files_allowed = 2147483647
-        # Holds the index array from a MODL file, e.g. '?=a:b:c:d'
-        @index = []
-        # Contains all pairs as they are encountered in the parsing process.
-        @pairs = {}
-        # Contains all defined and loaded classes for the current MODL document.
-        @classes_by_id = {}
-        @classes_by_name = {}
-        # Hold the user-defined methods.
-        @methods_hash = {}
-        @methods_by_id = {}
-        # Tracks the nesting depth for conditional clauses.
-        @conditional = 0
-        # Defaults to 1 and can be overridden by the *version command.
-        @syntax_version = 1
-        @interpreter_syntax_version = 1
-        @loaded_files = []
-        # Arrays
-        @arrays_by_id = {}
-        @arrays_by_name = {}
-      end
-
-      def loaded_file(str)
-        @loaded_files << str unless str.nil?
-        raise InterpreterError, 'Cannot load multiple files after *LOAD instruction' if @loaded_files.length > @max_files_allowed
-
-      end
-
-      def index_value(n, default)
-        return default if n > @index.length
-
-        @index[n]
-      end
-
-      def in_condition?
-        @conditional.positive?
-      end
-
-      def freeze_max_files(plus)
-        @max_files_allowed = @loaded_files.length + plus
-      end
-
-      def enter_condition
-        @conditional += 1
-      end
-
-      def exit_condition
-        @conditional -= 1
-      end
-
-      def pair(key, val = nil)
-        return @pairs[key] unless val
-
-        @pairs[key] = val
-      end
-
-      def classs(key)
-        if key.is_a? String
-          result = @classes_by_id[key]
-          result = @classes_by_name[key] if result.nil?
-          result
-        elsif key.is_a? MODLClass
-          @classes_by_id[key.id] = key if key.id
-          @classes_by_name[key.name] = key if key.name
-        end
-      end
-
-      def arrays(key)
-        if key.is_a? String
-          result = @arrays_by_id[key]
-          result = @arrays_by_name[key] if result.nil?
-          result
-        elsif key.is_a? MODLArray
-          @arrays_by_id[key.id] = key if key.id
-          @arrays_by_name[key.name] = key if key.name
-        end
-      end
-
-      def merge_pairs(other)
-        @pairs.merge!(other.all_pairs)
-      end
-
-      def merge_classes(other)
-        @classes_by_id.merge!(other.all_classes_by_id)
-        @classes_by_name.merge!(other.all_classes_by_name)
-      end
-
-      def merge_loaded_files(other)
-        @loaded_files.concat(other.loaded_files)
-        raise InterpreterError, 'Cannot load multiple files after *LOAD instruction' if @loaded_files.length > @max_files_allowed
-      end
-
-      def has_pairs?
-        @pairs.length.positive?
-      end
-
-      def has_class?(key)
-        @classes_by_id.keys.include?(key) || @classes_by_name.keys.include?(key)
-      end
-
-      def has_array?(key)
-        @arrays_by_id.keys.include?(key) || @arrays_by_name.keys.include?(key)
-      end
-
-      def has_user_method?(key)
-        @methods_hash.keys.include?(key)
-      end
-
-      def add_to_index(item)
-        @index << item
-      end
-
-      def user_method(key, val = nil)
-        return @methods_hash[key] unless val
-
-        @methods_hash[key] = val
-      end
-
-      def user_method_id(key, val)
-        @methods_hash[key] = val
-        @methods_by_id[key] = val
-      end
-
-      def class_list
-        result = []
-        @classes_by_id.values.each do |clazz|
-          new_item = {}
-          new_item[clazz.id] = class_to_hash(clazz)
-          result << new_item
-        end
-        result
-      end
-
-      def method_list
-        result = []
-        @methods_by_id.values.each do |m|
-          new_item = {}
-          new_item[m.id] = method_to_hash(m)
-          result << new_item
-        end
-        result
-      end
-
-      def file_list
-        @loaded_files.dup
-      end
-
-      def id_list
-        ids = {}
-        ids['methods'] = @methods_by_id.keys.dup.sort!
-        ids['classes'] = @classes_by_id.keys.dup.sort!
-        ids
-      end
-
-      def name_list
-        names = {}
-        names['methods'] = @methods_hash.keys.dup.sort!
-        names['classes'] = @classes_by_name.keys.dup.sort!
-        names
-      end
-
-      def superclass_list
-        result = {}
-        @classes_by_id.each do |c|
-          result[c[0]] = c[1].superclass
-        end
-        result
-      end
-
-      def assign_list
-        result = {}
-        @classes_by_id.each do |c|
-          result[c[0]] = c[1].assign
-        end
-        result
-      end
-
-      def transform_list
-        result = {}
-        @methods_by_id.each do |c|
-          result[c[0]] = c[1].transform
-        end
-        result
-      end
-
-      def allow_list
-        result = {}
-        @classes_by_id.each do |c|
-          result[c[0]] = c[1].allow.nil? ? nil : c[1].allow.extract_hash
-        end
-        result
-      end
-
-      protected
-
-      def all_classes_by_id
-        @classes_by_id
-      end
-
-      def all_classes_by_name
-        @classes_by_name
-      end
-
-      def all_pairs
-        result = {}
-        @pairs.keys.each do |k|
-          result[k] = @pairs[k] unless k.start_with?('*')
-        end
-        result
-      end
-
-      private
-
-      def class_to_hash(clazz)
-        map = {}
-        # name
-        map['name'] = clazz.name
-
-        # superclass
-        map['superclass'] = clazz.superclass
-
-        # assign
-        if clazz.assign
-          map['assign'] = clazz.assign
-        end
-
-        # allow
-        if clazz.allow
-          map['allow'] = clazz.allow.extract_hash
-        end
-
-        # expect
-        if clazz.expect
-          map['expect'] = clazz.expect.extract_hash
-        end
-
-        # content
-        if clazz.content.length.positive?
-          clazz.content.each do |item|
-            map[item[0]] = item[1].extract_hash
-          end
-        end
-
-        map
-      end
-
-      def method_to_hash(mthd)
-        map = {}
-        # name
-        map['name'] = mthd.name
-
-        # superclass
-        map['transform'] = mthd.transform
-
-        map
-      end
-
-      def new_map_item(key, value)
-        map_item = Parsed::ParsedMapItem.new(self)
-        map_item.pair = Parsed::ParsedPair.new(self)
-        map_item.pair.key = key
-        map_item.pair.valueItem = Parsed::ParsedValueItem.new(self)
-        if value.is_a? Parsed::ParsedValue
-          map_item.pair.valueItem.value = value
-        else
-          map_item.pair.valueItem.value = Parsed::ParsedValue.new(self)
-          map_item.pair.valueItem.value.primitive = Parsed::ParsedPrimitive.new(self)
-          map_item.pair.valueItem.value.primitive = Parsed::ParsedPrimitive.new(self)
-          map_item.pair.valueItem.value.primitive.string = Parsed::ParsedString.new(value)
-          map_item.pair.valueItem.value.primitive.text = value
-          map_item.pair.valueItem.value.text = value
-        end
-        map_item
-      end
-    end
-  end
-end

data/lib/modl/parser/instruction_processor.rb

@@ -1,82 +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
-    # This class handles the conversion of objects that refer to classes into instances of those classes.
-    # It works recursively since class usage can be nested.
-    class InstructionProcessor
-      def self.process(global, obj)
-        if obj.is_a? Hash
-          nvals = {}
-          obj.keys.each do |k|
-            o = obj[k]
-            if o.is_a? String
-              nv = process_instruction(global, o)
-              nvals[k] = nv unless nv.nil?
-            else
-              process(global, o)
-            end
-          end
-          obj.merge!(nvals)
-        elsif obj.is_a? Array
-          i = 0
-          while i < obj.length
-            o = obj[i]
-            if o.is_a? String
-              nv = process_instruction(global, o)
-              obj[i] = nv unless nv.nil?
-            else
-              process(global, o)
-            end
-            i += 1
-          end
-        end
-      end
-
-      def self.process_instruction(global, str)
-        case str
-        when '%*class'
-          return global.class_list
-        when '%*method'
-          return global.method_list
-        when '%*load'
-          return global.file_list
-        when '%*id'
-          return global.id_list
-        when '%*name'
-          return global.name_list
-        when '%*superclass'
-          return global.superclass_list
-        when '%*assign'
-          return global.assign_list
-        when '%*transform'
-          return global.transform_list
-        when '%*allow'
-          return global.allow_list
-        end
-      end
-    end
-  end
-end

data/lib/modl/parser/interpreter.rb

@@ -1,75 +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/MODLParserListener'
-require 'modl/parser/MODLParserVisitor'
-require 'modl/parser/MODLLexer'
-require 'modl/parser/MODLParser'
-require 'modl/parser/class_processor'
-require 'modl/parser/orphan_handler'
-require 'modl/parser/parser'
-require 'json'
-
-module MODL
-  # Interpreter-specific errors
-  class InterpreterError < StandardError
-  end
-
-  class ParserError < StandardError
-  end
-
-  # This is the main Ruby Interpreter entry point. Supply a String containing MODL text and it will return a String
-  # containing the JSON equivalent. The JSON isn't pretty-printed unless pretty is true
-  class Interpreter
-    def self.interpret(str, pretty = false)
-      interpreted = MODL.parse(str)
-      return interpreted if interpreted.is_a? String
-
-      # Otherwise generate a JSON string.
-      if pretty
-        JSON.pretty_generate interpreted
-      else
-        JSON.generate interpreted
-      end
-    end
-  end
-
-  # Parse a MODL string and return a hash, array, or String depending on how the MODL is structured.
-  def self.parse(string)
-    # Parse the MODL string into a MODL::Parser::Parsed object.
-    parsed = MODL::Parser::Parser.parse(string)
-
-    # Check for orphan pairs and adopt them.
-    parsed.structures = MODL::Parser::OrphanHandler.adopt(parsed.global, parsed.structures)
-
-    # Convert the Parsed object into a simpler structure of and Array or Hash
-    interpreted = parsed.extract_hash
-
-    # Process any class definitions used by the MODL file.
-    interpreted = MODL::Parser::ClassProcessor.process(parsed.global, interpreted)
-    MODL::Parser::InstructionProcessor.process(parsed.global, interpreted)
-    # If the result is a simple string then just return it.
-    interpreted
-  end
-end

data/lib/modl/parser/modl_class.rb

@@ -1,138 +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
-    # Represents a *class defined, or loaded by, a MODL document.
-    class MODLClass
-      attr_accessor :id
-      attr_accessor :name
-      attr_accessor :superclass
-      attr_accessor :assign
-      attr_accessor :content
-      attr_accessor :allow
-      attr_accessor :expect
-
-      def initialize
-        @content = {}
-      end
-
-      # Find a keylist of the right length from the *assign array of arrays.
-      def keylist_of_length(len)
-        return nil if @assign.nil?
-
-        # *assign can support iteration, e.g. *assign=[[person*]]
-        # so return a list of the right length in this case
-        if @assign.length == 1 && @assign[0].length == 1 && @assign[0][0].end_with?('*')
-          key = Sutil.head @assign[0][0]
-          return Array.new(len, key)
-        end
-
-        @assign.each do |kl|
-          return kl if kl.length == len
-        end
-
-        raise InterpreterError,
-              'Interpreter Error: No key list of the correct length in class ' + @id + ' - looking for one of length ' + len.to_s
-      end
-
-      def merge_content(new_value)
-        @content.each do |k, v|
-          new_value[k] = v.extract_hash unless new_value[k]
-        end
-        new_value
-      end
-
-      def name_or_id
-        @name.nil? ? @id : @name
-      end
-    end
-
-    # Extract a class from a ParsedPair object
-    class ClassExtractor
-      def self.extract(pair, global)
-        return unless pair.type == 'class'
-
-        clazz = MODLClass.new
-        map = pair.map if pair.map
-        map = pair.valueItem&.value&.map if pair.valueItem&.value&.map
-
-        map.mapItems.each do |item|
-          next unless item&.pair&.type
-
-          case item&.pair&.type
-          when 'id'
-            str_value = item.pair.valueItem.value.primitive.string.string
-            raise InterpreterError, 'Reserved class id - cannot redefine: ' + str_value if reserved?(str_value)
-
-            clazz.id = str_value
-          when 'name'
-            str_value = item.pair.valueItem.value.primitive.string.string
-            raise InterpreterError, 'Reserved class name - cannot redefine: ' + str_value if reserved?(str_value)
-
-            clazz.name = str_value
-          when 'superclass'
-            str_value = item.pair.valueItem.value.primitive.string.string
-            clazz.superclass = str_value
-          when 'keylist'
-            clazz.assign = item.pair.key_lists
-          when 'allow'
-            clazz.allow = item.pair.array if item.pair.array
-            clazz.allow = item.pair.valueItem.value.array if item.pair.valueItem.value.array
-          when 'expect'
-            clazz.expect = item.pair.array if item.pair.array
-            clazz.expect = item.pair.valueItem.value.array if item.pair.valueItem.value.array
-          else
-            clazz.content[item.pair.key] = item.pair.array if item.pair.array
-            clazz.content[item.pair.key] = item.pair.map if item.pair.map
-            clazz.content[item.pair.key] = item.pair.valueItem.value if item.pair.valueItem.value
-          end
-        end
-
-        superclass = clazz.superclass
-
-        if superclass && !reserved?(superclass) && !global.has_class?(superclass)
-          raise InterpreterError, 'Invalid superclass: ' + superclass.to_s
-        end
-        raise InterpreterError, 'Missing id for class' if clazz.id.nil?
-
-        # Make sure the class name isn't redefining an existing class
-        if !global.has_class?(clazz.id) && !global.has_class?(clazz.name)
-
-          # store the classes by id and name to make them easier to find later
-          global.classs(clazz)
-        else
-          id = clazz.id.nil? ? 'undefined' : clazz.id
-          name = clazz.name.nil? ? 'undefined' : clazz.name
-          raise InterpreterError, 'Class name or id already defined - cannot redefine: ' + id + ', ' + name
-        end
-      end
-
-      # Check for a reserved class name
-      def self.reserved?(str)
-        %w[map str arr num].include?(str)
-      end
-    end
-  end
-end

data/lib/modl/parser/modl_index.rb

@@ -1,54 +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
-    # Extracts an index definition from a ParsedPair
-    class IndexExtractor
-      def self.extract(pair, global)
-        item = pair.valueItem if pair.valueItem
-        item = pair.array if pair.array
-
-        # collect all values from the object
-        if item.is_a? Parsed::ParsedValueItem
-          if item&.value&.text
-            global.add_to_index(item.value.text)
-          elsif item&.value&.array
-            item.value.array.abstractArrayItems.each do |avi|
-              global.add_to_index(avi.arrayValueItem)
-            end
-          elsif item&.value&.nbArray
-            item.value.nbArray.arrayItems.each do |avi|
-              global.add_to_index(avi.arrayValueItem)
-            end
-          end
-        elsif item.is_a? Parsed::ParsedArray
-          item.abstractArrayItems.each do |avi|
-            global.add_to_index(avi.arrayValueItem)
-          end
-        end
-      end
-    end
-  end
-end