flavour_saver 4.0.2 → 5.0.0

data/lib/flavour_saver/helpers.rb

@@ -1,4 +1,4 @@
-require 'delegate'
+require "delegate"
 
 module FlavourSaver
   module Helpers
@@ -11,19 +11,19 @@ module FlavourSaver
         r = []
         count = 0
         collection.each do |element|
-          locals ={
-            'index' => count,
-            'last' => count == collection.size - 1,
-            'first' => count == 0
+          locals = {
+            "index" => count,
+            "last" => count == collection.size - 1,
+            "first" => count == 0
           }
 
-          locals['key'], element = element if collection.is_a?(Hash)
+          locals["key"], element = element if collection.is_a?(Hash)
 
           r << yield.contents(element, locals)
           count += 1
         end
         yield.rendered!
-        r.join ''
+        r.join ""
       end
 
       def if(value)
@@ -44,7 +44,7 @@ module FlavourSaver
 
       def log(message)
         FS.logger.debug("FlavourSaver: #{message}")
-        ''
+        ""
       end
 
       private
@@ -59,11 +59,10 @@ module FlavourSaver
     end
 
     class Decorator < Defaults
-
       def initialize(locals, source)
         @source = source
         mixin = Module.new do
-          locals.each do |name,impl|
+          locals.each do |name, impl|
             define_method name, &impl
           end
         end
@@ -88,7 +87,9 @@ module FlavourSaver
         super || @source.respond_to?(name)
       end
 
-      def method_missing(name,*args,&b)
+      # Defining respond_to_missing? would change what #method returns, which
+      # Runtime#forbidden_method? relies on. See the SECURITY note below.
+      def method_missing(name, *args, &b) # standard:disable Style/MissingRespondToMissing
         # I would rather have it raise a NameError, but Moustache
         # compatibility requires that missing helpers return
         # nothing. A good place for bugs to hide.
@@ -116,7 +117,7 @@ module FlavourSaver
       @registered_helpers ||= {}
     end
 
-    def register_helper(method,&b)
+    def register_helper(method, &b)
       if !method.is_a?(Symbol) && method.respond_to?(:name)
         registered_helpers[method.name.to_sym] = method
       elsif b
@@ -134,13 +135,13 @@ module FlavourSaver
       @registered_helpers = {}
     end
 
-    def decorate_with(context, helper_names=[], locals={})
+    def decorate_with(context, helper_names = [], locals = {})
       helpers = if helper_names.any?
-                  helper_symbols = helper_names.map(&:to_sym)
-                  registered_helpers.select { |k,v| helper_symbols.member? k }
-                else
-                  registered_helpers
-                end
+        helper_symbols = helper_names.map(&:to_sym)
+        registered_helpers.select { |k, v| helper_symbols.member? k }
+      else
+        registered_helpers
+      end
       helpers = helpers.merge(locals)
       Decorator.new(helpers, context)
     end

data/lib/flavour_saver/lexer.rb

@@ -1,124 +1,168 @@
-require 'rltk'
+require "strscan"
+require "flavour_saver/error"
 
 module FlavourSaver
-  class Lexer < RLTK::Lexer
+  class Lexer
+    Token = Struct.new(:type, :value)
 
-     # seems to have problem with hash symbol in regex
-    rule /\{\{\{\{raw\}\}\}\}/, :default do
+    class LexingError < Error; end
+
+    # How much of the unmatched input a LexingError message quotes.
+    ERROR_EXCERPT_LENGTH = 50
+
+    Rule = Struct.new(:pattern, :action)
+
+    # Rules are grouped by lexer state. At each position every rule for the
+    # current state is tried and the longest match wins; on a tie the rule
+    # defined first wins. An action returns nil (no token), a token type, or
+    # a [type, value] pair.
+    def self.rules
+      @rules ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def self.rule(pattern, state = :default, &action)
+      rules[state] << Rule.new(pattern, action || proc {})
+    end
+
+    def self.lex(template)
+      new.lex(template)
+    end
+
+    def lex(template)
+      @states = [:default]
+      tokens = []
+      scanner = StringScanner.new(template)
+
+      until scanner.eos?
+        match, rule = longest_match(scanner)
+        unless rule
+          raise LexingError, "Unable to match string with any of the given rules: #{excerpt(scanner.rest)}"
+        end
+
+        scanner.pos += match.bytesize
+        type, value = instance_exec(match, &rule.action)
+        tokens << Token.new(type, value) if type
+      end
+
+      tokens << Token.new(:EOS)
+    end
+
+    # seems to have problem with hash symbol in regex
+    rule(/\{\{\{\{raw\}\}\}\}/, :default) do
       push_state :raw
       :RAWSTART
     end
 
-    rule /.*?(?=\{\{\{\{\/raw\}\}\}\})/m, :raw do |str|
-      [ :RAWSTRING, str ]
+    rule(/.*?(?=\{\{\{\{\/raw\}\}\}\})/m, :raw) do |str|
+      [:RAWSTRING, str]
     end
 
-    rule /\{\{\{\{\/raw\}\}\}\}/, :raw do
+    rule(/\{\{\{\{\/raw\}\}\}\}/, :raw) do
       pop_state
       :RAWEND
     end
 
-    rule /{{{/, :default do
+    rule(/{{{/, :default) do
       push_state :expression
       :TEXPRST
     end
 
-    rule /{{/, :default do
+    rule(/{{/, :default) do
       push_state :expression
       :EXPRST
     end
 
-    rule /#/, :expression do
+    rule(/#/, :expression) do
       :HASH
     end
 
-    rule /\//, :expression do
+    rule(/\//, :expression) do
       :FWSL
     end
 
-    rule /&/, :expression do
+    rule(/&/, :expression) do
       :AMP
     end
 
-    rule /\^/, :expression do
+    rule(/\^/, :expression) do
       :HAT
     end
 
-    rule /@/, :expression do
+    rule(/@/, :expression) do
       :AT
     end
 
-    rule />/, :expression do
+    rule(/>/, :expression) do
       :GT
     end
 
-    rule /([0-9]+(\.[0-9]+)?)/, :expression do |n|
-      [ :NUMBER, n ]
+    rule(/([0-9]+(\.[0-9]+)?)/, :expression) do |n|
+      [:NUMBER, n]
     end
 
-    rule /true/, :expression do |i|
-      [ :BOOL, true ]
+    rule(/true/, :expression) do |i|
+      [:BOOL, true]
     end
 
-    rule /false/, :expression do |i|
-      [ :BOOL, false ]
+    rule(/false/, :expression) do |i|
+      [:BOOL, false]
     end
 
-    rule /\!/, :expression do
+    rule(/!/, :expression) do
       push_state :comment
       :BANG
     end
 
-    rule /([^}}]*)/, :comment do |comment|
+    rule(/([^}]*)/, :comment) do |comment|
       pop_state
-      [ :COMMENT, comment ]
+      [:COMMENT, comment]
     end
 
-    rule /else/, :expression do
+    rule(/else/, :expression) do
       :ELSE
     end
 
-    rule /([A-Za-z_]\w*)/, :expression do |name|
-      [ :IDENT, name ]
+    rule(/([A-Za-z_]\w*)/, :expression) do |name|
+      [:IDENT, name]
     end
 
-    rule /\./, :expression do
+    rule(/\./, :expression) do
       :DOT
     end
 
-    rule /\(/, :expression do
+    rule(/\(/, :expression) do
       :OPAR
     end
 
-    rule /\)/, :expression do
+    rule(/\)/, :expression) do
       :CPAR
     end
 
-    rule /\=/, :expression do
+    rule(/=/, :expression) do
       :EQ
     end
 
-    rule /"/, :expression do
+    rule(/"/, :expression) do
       push_state :string
     end
 
-    rule /(\\"|[^"])*/, :string do |str|
-      [ :STRING, str ]
+    rule(/(\\"|[^"])*/, :string) do |str|
+      [:STRING, str]
     end
 
-    rule /"/, :string do
+    rule(/"/, :string) do
       pop_state
     end
 
-    rule /'/, :expression do
+    rule(/'/, :expression) do
       push_state :s_string
     end
 
-    rule /(\\'|[^'])*/, :s_string do |str|
-      [ :S_STRING, str ]
+    rule(/(\\'|[^'])*/, :s_string) do |str|
+      [:S_STRING, str]
     end
 
-    rule /'/, :s_string do
+    rule(/'/, :s_string) do
       pop_state
     end
 
@@ -130,38 +174,67 @@ module FlavourSaver
     #   Identifiers may be any unicode character except for the following:
     #   Whitespace ! " # % & ' ( ) * + , . / ; < = > @ [ \ ] ^ ` { | } ~
     #
-    rule /([^\s!-#%-,.\/;->@\[-^`{-~]+)/, :expression do |str|
-      [ :LITERAL, str ]
+    rule(/([^\s!-#%-,.\/;->@\[-^`{-~]+)/, :expression) do |str|
+      [:LITERAL, str]
     end
 
-    rule /\[/, :expression do
+    rule(/\[/, :expression) do
       push_state :segment_literal
     end
 
-    rule /([^\]]+)/, :segment_literal do |l|
-      [ :LITERAL, l ]
+    rule(/([^\]]+)/, :segment_literal) do |l|
+      [:LITERAL, l]
     end
 
-    rule /]/, :segment_literal do
+    rule(/]/, :segment_literal) do
       pop_state
     end
 
-    rule /\s+/, :expression do
+    rule(/\s+/, :expression) do
       :WHITE
     end
 
-    rule /}}}/, :expression do
+    rule(/}}}/, :expression) do
       pop_state
       :TEXPRE
     end
 
-    rule /}}/, :expression do
+    rule(/}}/, :expression) do
       pop_state
       :EXPRE
     end
 
-    rule /.*?(?={{|\z)/m, :default do |output|
-      [ :OUT, output ]
+    rule(/.*?(?={{|\z)/m, :default) do |output|
+      [:OUT, output]
+    end
+
+    private
+
+    def longest_match(scanner)
+      best = nil
+      self.class.rules[state].each do |rule|
+        text = scanner.check(rule.pattern)
+        best = [text, rule] if text && (best.nil? || best.first.length < text.length)
+      end
+      best
+    end
+
+    def excerpt(rest)
+      (rest.length > ERROR_EXCERPT_LENGTH) ? "#{rest[0, ERROR_EXCERPT_LENGTH]}..." : rest
+    end
+
+    def state
+      @states.last
+    end
+
+    def push_state(state)
+      @states.push(state)
+      nil
+    end
+
+    def pop_state
+      @states.pop
+      nil
     end
   end
 end

data/lib/flavour_saver/nodes.rb

@@ -1,12 +1,99 @@
-require 'rltk'
-require 'rltk/ast'
-require 'flavour_saver/nodes'
-
 module FlavourSaver
-  class Node < RLTK::ASTNode
+  class Node
+    class TypeMismatch < StandardError; end
+
+    # Fields are declared as either values (plain data) or children (nodes,
+    # or arrays of nodes, which get their #parent set). The constructor takes
+    # every value, then every child, positionally, inherited ones first.
+    # A field's type is a class (nil is also allowed) or a class in an array,
+    # such as [CallNode].
+    @value_names = []
+    @child_names = []
+
+    class << self
+      attr_reader :value_names, :child_names
+
+      # Copy the parent's fields now, not on first read, so they can't depend on read order.
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@value_names, value_names.dup)
+        subclass.instance_variable_set(:@child_names, child_names.dup)
+      end
+
+      def value(name, type)
+        if field_class(name, type) <= Node
+          raise ArgumentError, "#{self}##{name} is a value, so its type can't be a Node"
+        end
+        value_names << name
+        attr_reader name
+        ivar = :"@#{name}"
+        define_method(:"#{name}=") do |value|
+          check_field_type(name, type, value)
+          instance_variable_set(ivar, value)
+        end
+      end
+
+      def child(name, type)
+        unless field_class(name, type) <= Node
+          raise ArgumentError, "#{self}##{name} is a child, so its type must be a Node"
+        end
+        child_names << name
+        attr_reader name
+        ivar = :"@#{name}"
+        define_method(:"#{name}=") do |node|
+          check_field_type(name, type, node)
+          Array(node).each { |n| n.parent = self }
+          instance_variable_set(ivar, node)
+        end
+      end
+
+      private
+
+      def field_class(name, type)
+        klass = (type.is_a?(Array) && type.size == 1) ? type.first : type
+        return klass if klass.is_a?(Class)
+        raise ArgumentError, "#{self}##{name} must have a class, or a class in an array, as its type"
+      end
+    end
+
+    attr_accessor :parent
+
+    def initialize(*fields)
+      names = self.class.value_names + self.class.child_names
+      raise ArgumentError, "#{self.class} takes at most #{names.size} fields" if fields.size > names.size
+      names.each_with_index { |name, i| public_send(:"#{name}=", fields[i]) }
+    end
+
+    def values
+      self.class.value_names.map { |name| public_send(name) }
+    end
+
+    def children
+      self.class.child_names.map { |name| public_send(name) }
+    end
+
+    def ==(other)
+      other.class == self.class && other.values == values && other.children == children
+    end
+
     def inspect
       to_s.inspect
     end
+
+    private
+
+    def check_field_type(name, type, value)
+      valid =
+        if type.is_a?(Array)
+          value.is_a?(Array) && value.all? { |item| item.is_a?(type.first) }
+        else
+          value.nil? || value.is_a?(type)
+        end
+      return if valid
+
+      actual = (value.is_a?(Array) && value.any?) ? "an Array of #{value.map(&:class).uniq.join(", ")}" : value.class
+      raise TypeMismatch, "#{self.class}##{name} must be #{type.inspect}, not #{actual}"
+    end
   end
 
   class TemplateItemNode < Node; end
@@ -15,7 +102,7 @@ module FlavourSaver
     child :items, [TemplateItemNode]
 
     def to_s
-      items.map(&:to_s).join ''
+      items.join ""
     end
   end
 
@@ -60,14 +147,14 @@ module FlavourSaver
     value :name, String
     value :arguments, Array
 
-    def arguments_to_str(str='')
+    def arguments_to_str(str = "")
       str = str.dup # RLTK magic?
       arguments.each do |arg|
-        str << ' '
+        str << " "
         if arg.respond_to? :join
-          str << arg.join('.')
+          str << arg.join(".")
         elsif arg.respond_to? :keys
-          arg.each do |k,v|
+          arg.each do |k, v|
             str << "#{k}: #{v.inspect}"
           end
         else
@@ -98,34 +185,35 @@ module FlavourSaver
     value :depth, Integer
 
     def to_callnode
-      CallNode.new(name,arguments)
+      CallNode.new(name, arguments)
     end
+
     def to_s
-      "#{'../' * depth}#{super}"
+      "#{"../" * depth}#{super}"
     end
   end
 
   class ExpressionNode < TemplateItemNode
     child :method, [CallNode]
     def to_s
-      "{{#{method.map(&:to_s).join '.'}}}"
+      "{{#{method.join "."}}}"
     end
   end
 
   class BlockExpressionNode < ExpressionNode
     child :contents, TemplateNode
-    child :closer,   CallNode
+    child :closer, CallNode
 
     def name
       method.first.name
     end
 
     def to_s
-      "{{##{method.map(&:to_s).join ''}}}#{contents.to_s}{{/#{closer.name}}}"
+      "{{##{method.join ""}}}#{contents}{{/#{closer.name}}}"
     end
 
     def inspect
-      r = "{{##{method.map(&:to_s).join ''}}}\n"
+      r = "{{##{method.join ""}}}\n"
       r << "  "
       r << contents.inspect.split("\n").join("\n  ")
       r
@@ -136,11 +224,11 @@ module FlavourSaver
     child :alternate, TemplateNode
 
     def to_s
-      "{{##{method.map(&:to_s).join ''}}}#{contents.to_s}{{else}}#{alternate.to_s}{{/#{closer.name}}}"
+      "{{##{method.join ""}}}#{contents}{{else}}#{alternate}{{/#{closer.name}}}"
     end
 
     def inspect
-      r = "{{##{method.map(&:to_s).join ''}}}\n"
+      r = "{{##{method.join ""}}}\n"
       r << contents.inspect.split("\n").join("\n  ")
       r << "\n  {{else}}\n"
       r << alternate.inspect.split("\n").join("\n  ")
@@ -150,7 +238,7 @@ module FlavourSaver
 
   class SafeExpressionNode < ExpressionNode
     def to_s
-      "{{{#{method.map(&:to_s).join '.'}}}}"
+      "{{{#{method.join "."}}}}"
     end
   end