modl 0.0.2 → 0.3.0

data/lib/modl/parser/evaluator.rb

@@ -0,0 +1,164 @@
+module Modl
+  module Parser
+    # Evaluate a conditional expression
+    class Evaluator
+      # Evaluate the given condition
+      def self.evaluate(global, condition)
+        return false if global.nil? || !global.is_a?(GlobalParseContext) || !condition.is_a?(Modl::Parser::Parsed::ParsedCondition)
+
+        start = 0
+        if condition.text
+          value1, success = value(global, condition.text)
+        else
+          start = 1
+          value1, success = value(global, condition.values[0].text)
+        end
+
+
+        # Handle single-value conditions of the form '{x?}'
+        if condition.values.length == start
+          return false if value1.nil?
+          return false if value1.is_a?(FalseClass)
+          return true if value1.is_a?(TrueClass)
+
+          return success ? value1 : false
+        end
+
+        # Handle the right-hand side, which might have many values and operators, e.g. '{x=a|b|c|d?}'
+        i = start
+        result = false
+        while i < condition.values.length
+          item = condition.values[i]
+          if item.primitive.constant
+            value2 = item.text
+          else
+            value2, success = value(global, item.text)
+          end
+          partial = false
+          case condition.operator
+          when '='
+            wild = value2.is_a?(String) && value2.include?('*') ? true : false
+            if wild
+              regex = '^'
+              value2.each_char do |c|
+                regex << (c == '*' ? '.*' : c)
+              end
+              partial |= !value1.match(regex).nil?
+            else
+              partial |= value1 == value2
+            end
+          when '>'
+            partial |= value1 > value2
+          when '<'
+            partial |= value1 < value2
+          when '>='
+            partial |= value1 >= value2
+          when '<='
+            partial |= value1 <= value2
+          end
+          i += 1
+          result |= partial
+        end
+        result
+      end
+
+      def self.value(global, k)
+        success = false
+        if k.is_a?(String) && k.include?('%')
+          value1, _ignore = Modl::Parser::RefProcessor.deref(k, global)
+          success = true
+        elsif k.is_a?(FalseClass)
+          value1 = false
+          success = true
+        elsif k.is_a?(TrueClass)
+          value1 = true
+          success = true
+        elsif k.is_a?(NilClass)
+          value1 = nil
+        else
+          key = k
+          ikey = key.to_i
+          if ikey.to_s == key
+            index_val = global.index[ikey]
+            value1 = index_val.respond_to?(:text) ? index_val.text : nil
+          else
+            pair = global.pair(key)
+            return k unless pair
+
+            value1 = pair.text
+          end
+          success = true
+        end
+        [value1, success]
+      end
+
+      def evaluate_old
+        result = false
+        if @key
+          if @key.include?('%')
+            value1, _ignore = Modl::Parser::RefProcessor.deref(@key, @global)
+          else
+            key = @key
+            ikey = key.to_i
+            if ikey.to_s == key
+              index_val = @global.index[ikey]
+              value1 = index_val.respond_to?(:text) ? index_val.text : nil
+            else
+              pair = @global.pair(key)
+              return false unless pair
+
+              value1 = pair.text
+            end
+          end
+
+          @values.each do |value|
+            value2 = value.text
+            value2, _ignore = Modl::Parser::RefProcessor.deref(value2, @global) if value2.is_a?(String) && value2.include?('%')
+            value2 = @global.pair(value.text).text if @global.pair(value.text)
+
+            case @operator
+            when '='
+              wild = value2.is_a?(String) && value2.include?('*') ? true : false
+              if wild
+                regex = '^'
+                value2.each_char do |c|
+                  regex << (c == '*' ? '.*' : c)
+                end
+                result |= !value1.match(regex).nil?
+              else
+                result |= value1 == value2
+              end
+            when '>'
+              result |= value1 > value2
+            when '<'
+              result |= value1 < value2
+            when '>='
+              result |= value1 >= value2
+            when '<='
+              result |= value1 <= value2
+            end
+            break if result # shortcut if we have a matching value
+          end
+        elsif @values.length == 1
+          key = @values[0].text
+          if key.is_a?(String)
+            key = key.start_with?('%') ? Sutil.tail(key) : key
+          end
+          the_pair = @global.pair(key)
+          if the_pair
+            result = the_pair.text
+          else
+            return true if @values[0].trueVal
+            return false if @values[0].falseVal
+            return false if @values[0].string
+
+            result = @values[0].evaluate
+          end
+        end
+        result
+      end
+
+    end
+  end
+end
+

data/lib/modl/parser/file_importer.rb

@@ -0,0 +1,64 @@
+require 'modl/parser/object_cache'
+require 'modl/parser/sutil'
+
+module Modl
+  module Parser
+
+    # This class handled file loading from local or remote file systems.
+    class FileImporter
+
+      def initialize
+        @cache = ObjectCache.new
+      end
+
+      # Supply a single file name as a string or an array of file names.
+      def import_files(files, global)
+        file_names = []
+        file_names += files if files.is_a? Array
+        file_names << files if files.is_a? String
+
+        file_names.each do |file_name|
+          force = file_name.end_with?('!')
+          if force
+            # Don't use the cache if we're forcing a reload.
+            @cache.evict(file_name)
+            file_name = Sutil.head(file_name)
+            parsed = nil
+          else
+            # Do we have a cached version?
+            parsed = @cache.get(file_name)
+          end
+
+          # Did we hit the cache?
+          unless parsed
+            # No.
+            file_name << '.modl' unless file_name.end_with?('.txt', '.modl')
+            file_name, new_val = RefProcessor.deref file_name, global if file_name.include?('%')
+
+            begin
+              uri = URI(file_name)
+              txt = Net::HTTP.get(uri)
+            rescue
+              begin
+                txt = File.readlines(file_name).join
+              rescue
+                raise InterpreterError, 'File not found: ' + file_name
+              end
+            end
+
+            global.loaded_file(file_name)
+
+            # Parse the downloaded file ands extract the classes
+            parsed = Modl::Parser::Parser.parse txt, global
+            # Save it for next time
+            @cache.put(file_name, parsed)
+          end
+          # Extract the JSON content and add the classes and pairs to the existing GlobalParseContext hashes.
+          parsed.extract_hash
+          global.merge_classes(parsed.global)
+          global.merge_pairs(parsed.global)
+        end
+      end
+    end
+  end
+end

data/lib/modl/parser/global_parse_context.rb

@@ -0,0 +1,249 @@
+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_reader :interpreter_syntax_version
+
+      def initialize
+        # 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 = []
+      end
+
+      def loaded_file(str)
+        @loaded_files << str unless str.nil?
+      end
+
+      def index_value(n, default)
+        return default if n > @index.length
+
+        @index[n]
+      end
+
+      def in_condition?
+        @conditional.positive?
+      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 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 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_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
+        @pairs
+      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
+
+        # 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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,38 @@
+require 'modl/parser/MODLParserListener'
+require 'modl/parser/MODLParserVisitor'
+require 'modl/parser/MODLLexer'
+require 'modl/parser/MODLParser'
+require 'modl/parser/class_processor'
+require 'modl/parser/parser'
+require 'json'
+
+module Modl
+  # Interpreter-specific errors
+  class InterpreterError < 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)
+      # Parse the MODL string into a Modl::Parser::Parsed object.
+      parsed = Modl::Parser::Parser.parse str
+
+      # 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.
+      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.
+      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
+end

data/lib/modl/parser/modl_class.rb

@@ -0,0 +1,102 @@
+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
+
+      def initialize
+        @content = {}
+      end
+
+      # Find a keylist of the right length from the *assign array of arrays.
+      def keylist_of_length(len)
+        return [] if @assign.nil?
+
+        @assign.each do |kl|
+          return kl if kl.length == len
+        end
+        raise InterpreterError,
+              '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
+        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
+          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

@@ -0,0 +1,30 @@
+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.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