modl 0.0.2 → 0.3.0

data/lib/modl/parser/modl_keylist.rb

@@ -0,0 +1,43 @@
+module Modl
+  module Parser
+    # Extracts an index definition from a ParsedPair
+    class KeylistExtractor
+      def self.extract(pair, item)
+        # the item must be an array of arrays
+        pair.key_lists = []
+        last_keylist_len = 0
+        if item.is_a?(Parsed::ParsedValueItem) && item.value.is_a?(Parsed::ParsedValue) && item.value.array
+          item.value.array.abstractArrayItems.each do |avi|
+            key_list = []
+            avi.arrayValueItem.array.abstractArrayItems.each do |key|
+              key_list << key.arrayValueItem.primitive.string.string if key.arrayValueItem.primitive.string
+              key_list << key.arrayValueItem.primitive.number.num if key.arrayValueItem.primitive.number
+            end
+            if key_list.length > last_keylist_len
+              last_keylist_len = key_list.length
+            else
+              raise InterpreterError, 'Error: Key lists in *assign are not in ascending order of list length: ' + key_list.to_s
+            end
+            pair.key_lists << key_list
+          end
+        elsif item.is_a?(Parsed::ParsedArray)
+          item.abstractArrayItems.each do |avi|
+            key_list = []
+            avi.arrayValueItem.array.abstractArrayItems.each do |key|
+              key_list << key.arrayValueItem.primitive.string.string if key.arrayValueItem.primitive.string
+              key_list << key.arrayValueItem.primitive.number.num if key.arrayValueItem.primitive.number
+            end
+            if key_list.length > last_keylist_len
+              last_keylist_len = key_list.length
+            else
+              raise InterpreterError, 'Error: Key lists in *assign are not in ascending order of list length.'
+            end
+            pair.key_lists << key_list
+          end
+        else
+          raise InterpreterError, 'Array of arrays expected for: ' + pair.key
+        end
+      end
+    end
+  end
+end

data/lib/modl/parser/modl_method.rb

@@ -0,0 +1,132 @@
+module Modl
+  module Parser
+    # Represents a *method defined by a MODL document.
+    class MODLMethod
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :transform
+
+      def name_or_id
+        @name.nil? ? @id : @name
+      end
+
+      # There is a user-defined method transform to run on the str
+      def run(str)
+        # Consume the elements of the transform spec until there are none left.
+        transform = @transform
+        while transform && transform.length > 0
+          if transform.start_with? 'replace'
+            close_bracket = transform.index(')')
+            m = Sutil.head(transform, close_bracket + 1).sub!('replace', 'r')
+            str = StandardMethods.run_method(m, str)
+            # Consume the subst clause
+            close_bracket = transform.index(')')
+            transform = Sutil.tail(transform, close_bracket + 2)
+          elsif transform.start_with? 'trim'
+            close_bracket = transform.index(')')
+            m = Sutil.head(transform, close_bracket + 1).sub!('trim', 't')
+            str = StandardMethods.run_method(m, str)
+            # Consume the trunc clause
+            close_bracket = transform.index(')')
+            transform = Sutil.tail(transform, close_bracket + 2)
+          elsif transform.start_with? 'initcap'
+            str = str.split.map(&:capitalize) * ' '
+            transform = Sutil.tail(transform, 8)
+          elsif transform.start_with? 'upcase'
+            raise InterpreterError, 'NOT IMPLEMENTED'
+          elsif transform.start_with? 'downcase'
+            raise InterpreterError, 'NOT IMPLEMENTED'
+          elsif transform.start_with? 'sentence'
+            raise InterpreterError, 'NOT IMPLEMENTED'
+          elsif transform.start_with? 'urlencode'
+            raise InterpreterError, 'NOT IMPLEMENTED'
+          else
+            raise InterpreterError, 'NOT IMPLEMENTED'
+          end
+        end
+        str
+      end
+
+    end
+
+    # Extracts a method definition from a ParsedPair
+    class MethodExtractor
+      def self.extract(pair, global)
+        return unless pair.type == 'method'
+
+        mthd = MODLMethod.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'
+            mthd.id = item.pair.valueItem.value.primitive.string.string
+          when 'transform'
+            mthd.transform = item.pair.valueItem.value.primitive.string.string
+          when 'name'
+            mthd.name = item.pair.valueItem.value.primitive.string.string
+          else
+            raise InterpreterError, 'Invalid *method - only *id, *name, and *transform fields expected'
+          end
+        end
+
+        raise InterpreterError, 'Missing id for method' if mthd.id.nil?
+        raise InterpreterError, 'Missing name for method' if mthd.name.nil?
+        raise InterpreterError, 'Duplicate method name: ' + mthd.name if global.has_user_method?(mthd.name)
+        raise InterpreterError, 'Duplicate method id: ' + mthd.id if global.has_user_method?(mthd.id)
+
+        # store the methods by id and name to make them easier to find later
+        global.user_method_id(mthd.id, mthd)
+        global.user_method(mthd.name, mthd)
+      end
+    end
+
+    class StandardMethods
+      def self.run_method(m, str)
+        case m[0]
+        when 'u'
+          str.upcase
+        when 'd'
+          str.downcase
+        when 'i'
+          str.split.map(&:capitalize) * ' '
+        when 's'
+          split = str.split
+          split[0].capitalize!
+          split.join(' ')
+        when 'e'
+          CGI.escape(str)
+        when 'r'
+          s1, s2 = get_subst_parts m
+          str.sub(s1, s2)
+        when 't'
+          s1 = extract_params m
+          i = str.index(s1)
+          Sutil.head(str, i)
+        when 'p'
+          Punycode.decode(str)
+        else
+          str + '.' + m
+        end
+      end
+
+      # Extract the method parameters
+      def self.get_subst_parts(s)
+        # should be of the form .r(s1,s2)
+        result = extract_params(s).split(',')
+        result[0] = '' if result.length.zero? || result[0].nil?
+        result[1] = '' if result.length == 1 || result[1].nil?
+        result
+      end
+
+      # Extract the method parameter
+      def self.extract_params(str)
+        # should be of the form .r(s1,s2)
+        Sutil.between(str, '(', ')')
+      end
+    end
+  end
+end

data/lib/modl/parser/object_cache.rb

@@ -0,0 +1,54 @@
+
+module Modl
+  module Parser
+    # Store any files for up to 1 hour by default.
+    class ObjectCache
+      # A cache record to keep track of the time since an object was last cached.
+      class CacheEntry
+        TTL_ONE_HOUR = 3_600 # seconds
+
+        attr_reader :object
+
+        # Initialiase the CacheEntry with an object and an optional ttl in seconds (default 1 hour)
+        def initialize(object, ttl = nil)
+          ttl = TTL_ONE_HOUR if ttl.nil?
+          @object = object
+          @expiry_time = Time.now + ttl
+        end
+
+        # Check whether the CacheEntry is live
+        def expired?
+          @expiry_time < Time.now
+        end
+      end
+
+      # Set up and empty cache.
+      def initialize
+        @cache = {}
+      end
+
+      # Cache an object with the given key and optional ttl in seconds (default 1 hour)
+      def put(key, object, ttl = nil)
+        @cache[key] = CacheEntry.new(object, ttl) unless key.nil? || object.nil?
+      end
+
+      # Evict a cache entry
+      def evict(key)
+        @cache.delete(key) unless key.nil?
+      end
+
+      # Return the object with the given key if one exists and has not expired.
+      def get(key)
+        # Return nothing if not in the cache or it has expired.
+        return if key.nil?
+
+        entry = @cache[key]
+        return unless entry
+        return if entry.expired?
+
+        # Otherwise return the cached object.
+        entry.object
+      end
+    end
+  end
+end