mustache 0.99.4 → 1.1.3

data/lib/mustache/parser.rb

@@ -44,44 +44,84 @@ EOF
       end
     end
 
+    # The sigil types which are valid after an opening `{{`
+    VALID_TYPES = [ '#', '^', '/', '=', '!', '<', '>', '&', '{' ].map(&:freeze)
+
+    def self.valid_types
+      @valid_types ||= Regexp.new(VALID_TYPES.map { |t| Regexp.escape(t) }.join('|') )
+    end
+
+    # Add a supported sigil type (with optional aliases) to the Parser.
+    #
+    # Requires a block, which will be sent the following parameters:
+    #
+    # * content - The raw content of the tag
+    # * fetch- A mustache context fetch expression for the content
+    # * padding - Indentation whitespace from the currently-parsed line
+    # * pre_match_position - Location of the scanner before a match was made
+    #
+    # The provided block will be evaluated against the current instance of
+    # Parser, and may append to the Parser's @result as needed.
+    def self.add_type(*types, &block)
+      types = types.map(&:to_s)
+      type, *aliases = types
+      method_name = "scan_tag_#{type}".to_sym
+      define_method(method_name, &block)
+      aliases.each { |a| alias_method "scan_tag_#{a}", method_name }
+      types.each { |t| VALID_TYPES << t unless VALID_TYPES.include?(t) }
+      @valid_types = nil
+    end
+
     # After these types of tags, all whitespace until the end of the line will
     # be skipped if they are the first (and only) non-whitespace content on
     # the line.
-    SKIP_WHITESPACE = [ '#', '^', '/', '<', '>', '=', '!' ]
+    SKIP_WHITESPACE = [ '#', '^', '/', '<', '>', '=', '!' ].map(&:freeze)
 
     # The content allowed in a tag name.
-    ALLOWED_CONTENT = /(\w|[?!\/.-])*/
+    ALLOWED_CONTENT = /(\w|[?!\/.@-])*/
 
     # These types of tags allow any content,
     # the rest only allow ALLOWED_CONTENT.
-    ANY_CONTENT = [ '!', '=' ]
+    ANY_CONTENT = [ '!', '=' ].map(&:freeze)
 
-    attr_reader :scanner, :result
-    attr_writer :otag, :ctag
+    attr_reader :otag, :ctag
 
     # Accepts an options hash which does nothing but may be used in
     # the future.
     def initialize(options = {})
-      @options = {}
+      @options = options
+      @option_inline_partials_at_compile_time = options[:inline_partials_at_compile_time]
+      if @option_inline_partials_at_compile_time
+        @partial_resolver = options[:partial_resolver]
+        raise ArgumentError.new "Missing or invalid partial_resolver" unless @partial_resolver.respond_to? :call
+      end
+
+      # Initialize default tags
+      self.otag ||= '{{'
+      self.ctag ||= '}}'
     end
 
     # The opening tag delimiter. This may be changed at runtime.
-    def otag
-      @otag ||= '{{'
+    def otag=(value)
+      regex = regexp value
+      @otag_regex     = /([ \t]*)?#{regex}/
+      @otag_not_regex = /(^[ \t]*)?#{regex}/
+      @otag = value
     end
 
     # The closing tag delimiter. This too may be changed at runtime.
-    def ctag
-      @ctag ||= '}}'
+    def ctag=(value)
+      @ctag_regex = regexp value
+      @ctag = value
     end
 
     # Given a string template, returns an array of tokens.
     def compile(template)
+      @encoding = nil
+
       if template.respond_to?(:encoding)
         @encoding = template.encoding
         template = template.dup.force_encoding("BINARY")
-      else
-        @encoding = nil
       end
 
       # Keeps information about opened sections.
@@ -94,15 +134,36 @@ EOF
         scan_tags || scan_text
       end
 
-      if !@sections.empty?
+      unless @sections.empty?
         # We have parsed the whole file, but there's still opened sections.
-        type, pos, result = @sections.pop
+        type, pos, _ = @sections.pop
         error "Unclosed section #{type.inspect}", pos
       end
 
       @result
     end
 
+
+    private
+
+
+    def content_tags type, current_ctag_regex
+      if ANY_CONTENT.include?(type)
+        r = /\s*#{regexp(type)}?#{current_ctag_regex}/
+        scan_until_exclusive(r)
+      else
+        @scanner.scan(ALLOWED_CONTENT)
+      end
+    end
+
+    def dispatch_based_on_type type, content, fetch, padding, pre_match_position
+      send("scan_tag_#{type}", content, fetch, padding, pre_match_position)
+    end
+
+    def find_closing_tag scanner, current_ctag_regex
+      error "Unclosed tag" unless scanner.scan(current_ctag_regex)
+    end
+
     # Find {{mustaches}} and add them to the @result array.
     def scan_tags
       # Scan until we hit an opening delimiter.
@@ -110,7 +171,7 @@ EOF
       pre_match_position = @scanner.pos
       last_index = @result.length
 
-      return unless x = @scanner.scan(/([ \t]*)?#{Regexp.escape(otag)}/)
+      return unless @scanner.scan @otag_regex
       padding = @scanner[1] || ''
 
       # Don't touch the preceding whitespace unless we're matching the start
@@ -123,18 +184,13 @@ EOF
 
       # Since {{= rewrites ctag, we store the ctag which should be used
       # when parsing this specific tag.
-      current_ctag = self.ctag
-      type = @scanner.scan(/#|\^|\/|=|!|<|>|&|\{/)
+      current_ctag_regex = @ctag_regex
+      type = @scanner.scan(self.class.valid_types)
       @scanner.skip(/\s*/)
 
       # ANY_CONTENT tags allow any character inside of them, while
       # other tags (such as variables) are more strict.
-      if ANY_CONTENT.include?(type)
-        r = /\s*#{regexp(type)}?#{regexp(current_ctag)}/
-        content = scan_until_exclusive(r)
-      else
-        content = @scanner.scan(ALLOWED_CONTENT)
-      end
+      content = content_tags(type, current_ctag_regex)
 
       # We found {{ but we can't figure out what's going on inside.
       error "Illegal content in tag" if content.empty?
@@ -142,52 +198,18 @@ EOF
       fetch = [:mustache, :fetch, content.split('.')]
       prev = @result
 
-      # Based on the sigil, do what needs to be done.
-      case type
-      when '#'
-        block = [:multi]
-        @result << [:mustache, :section, fetch, block]
-        @sections << [content, position, @result]
-        @result = block
-      when '^'
-        block = [:multi]
-        @result << [:mustache, :inverted_section, fetch, block]
-        @sections << [content, position, @result]
-        @result = block
-      when '/'
-        section, pos, result = @sections.pop
-        raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
-        (@result = result).last << raw << [self.otag, self.ctag]
-
-        if section.nil?
-          error "Closing unopened #{content.inspect}"
-        elsif section != content
-          error "Unclosed section #{section.inspect}", pos
-        end
-      when '!'
-        # ignore comments
-      when '='
-        self.otag, self.ctag = content.split(' ', 2)
-      when '>', '<'
-        @result << [:mustache, :partial, content, padding]
-      when '{', '&'
-        # The closing } in unescaped tags is just a hack for
-        # aesthetics.
-        type = "}" if type == "{"
-        @result << [:mustache, :utag, fetch]
-      else
-        @result << [:mustache, :etag, fetch]
-      end
+      dispatch_based_on_type(type, content, fetch, padding, pre_match_position)
+
+      # The closing } in unescaped tags is just a hack for
+      # aesthetics.
+      type = "}" if type == "{"
 
       # Skip whitespace and any balancing sigils after the content
       # inside this tag.
       @scanner.skip(/\s+/)
       @scanner.skip(regexp(type)) if type
 
-      # Try to find the closing tag.
-      unless close = @scanner.scan(regexp(current_ctag))
-        error "Unclosed tag"
-      end
+      find_closing_tag(@scanner, current_ctag_regex)
 
       # If this tag was the only non-whitespace content on this line, strip
       # the remaining whitespace.  If not, but we've been hanging on to padding
@@ -209,7 +231,7 @@ EOF
 
     # Try to find static text, e.g. raw HTML with no {{mustaches}}.
     def scan_text
-      text = scan_until_exclusive(/(^[ \t]*)?#{Regexp.escape(otag)}/)
+      text = scan_until_exclusive @otag_not_regex
 
       if text.nil?
         # Couldn't find any otag, which means the rest is just static text.
@@ -234,6 +256,10 @@ EOF
       end
     end
 
+    def offset
+      position[0, 2]
+    end
+
     # Returns [lineno, column, line]
     def position
       # The rest of the current line
@@ -250,7 +276,7 @@ EOF
     # Used to quickly convert a string into a regular expression
     # usable by the string scanner.
     def regexp(thing)
-      /#{Regexp.escape(thing)}/
+      Regexp.new Regexp.escape(thing) if thing
     end
 
     # Raises a SyntaxError. The message should be the name of the
@@ -259,5 +285,87 @@ EOF
     def error(message, pos = position)
       raise SyntaxError.new(message, pos)
     end
+
+
+    #
+    # Scan tags
+    #
+    # These methods are called in `scan_tags`. Because they contain nonstandard
+    # characters in their method names, they are aliased to
+    # better named methods.
+    #
+
+
+    # This function handles the cases where the scanned tag does not have
+    # a type.
+    def scan_tag_ content, fetch, padding, pre_match_position
+      @result << [:mustache, :etag, fetch, offset]
+    end
+
+
+    def scan_tag_block content, fetch, padding, pre_match_position
+      block = [:multi]
+      @result << [:mustache, :section, fetch, offset, block]
+      @sections << [content, position, @result]
+      @result = block
+    end
+    alias_method :'scan_tag_#', :scan_tag_block
+
+
+    def scan_tag_inverted content, fetch, padding, pre_match_position
+      block = [:multi]
+      @result << [:mustache, :inverted_section, fetch, offset, block]
+      @sections << [content, position, @result]
+      @result = block
+    end
+    alias_method :'scan_tag_^', :scan_tag_inverted
+
+
+    def scan_tag_close content, fetch, padding, pre_match_position
+      section, pos, result = @sections.pop
+      if section.nil?
+        error "Closing unopened #{content.inspect}"
+      end
+
+      raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
+      (@result = result).last << raw << [self.otag, self.ctag]
+
+      if section != content
+        error "Unclosed section #{section.inspect}", pos
+      end
+    end
+    alias_method :'scan_tag_/', :scan_tag_close
+
+
+    def scan_tag_comment content, fetch, padding, pre_match_position
+    end
+    alias_method :'scan_tag_!', :scan_tag_comment
+
+
+    def scan_tag_delimiter content, fetch, padding, pre_match_position
+      self.otag, self.ctag = content.split(' ', 2)
+    end
+    alias_method :'scan_tag_=', :scan_tag_delimiter
+
+
+    def scan_tag_open_partial content, fetch, padding, pre_match_position
+      @result << if @option_inline_partials_at_compile_time
+        partial = @partial_resolver.call content
+        partial.gsub!(/^/, padding) unless padding.empty?
+        self.class.new(@options).compile partial
+      else
+        [:mustache, :partial, content, offset, padding]
+      end
+    end
+    alias_method :'scan_tag_<', :scan_tag_open_partial
+    alias_method :'scan_tag_>', :scan_tag_open_partial
+
+
+    def scan_tag_unescaped content, fetch, padding, pre_match_position
+      @result << [:mustache, :utag, fetch, offset]
+    end
+    alias_method :'scan_tag_{', :'scan_tag_unescaped'
+    alias_method :'scan_tag_&', :'scan_tag_unescaped'
+
   end
 end

data/lib/mustache/settings.rb

@@ -2,22 +2,57 @@
 # view class, or a single Mustache instance.
 class Mustache
 
+  def initialize_settings
+    @template = nil
+    @template_path = nil
+    @template_extension = nil
+    @template_name = nil
+    @template_file = nil
+    @raise_on_context_miss = nil
+    @context_access_security_level = 2
+  end
+
+  def self.initialize_settings
+    @template = nil
+    @template_path = nil
+    @template_extension = nil
+    @template_name = nil
+    @template_file = nil
+    @raise_on_context_miss = nil
+    @context_access_security_level = 2
+  end
+
+  initialize_settings
+
+  def self.inherited(subclass)
+    subclass.initialize_settings
+  end
+
   #
   # Template Path
   #
 
   # The template path informs your Mustache view where to look for its
-  # corresponding template. By default it's the current directory (".")
+  # corresponding template. It is an array of paths, by default containing
+  # one entry:  the current directory (".")
+  # When setting up from a string, use path delimiters to create a search path
+  # When the template_file is requested, a search is done to find the file in the
+  # path, this is then stored as the name.
   #
   # A class named Stat with a template_path of "app/templates" will look
   # for "app/templates/stat.mustache"
 
+  def self.setup_path path
+    path = path.split(File::PATH_SEPARATOR) if path.is_a? String
+    path.map{|p| File.expand_path(p)}
+  end
+
   def self.template_path
-    @template_path ||= inheritable_config_for :template_path, '.'
+    @template_path ||= setup_path(inheritable_config_for(:template_path, '.'))
   end
 
   def self.template_path=(path)
-    @template_path = File.expand_path(path)
+    @template_path = setup_path(path)
     @template = nil
   end
 
@@ -25,22 +60,17 @@ class Mustache
     @template_path ||= self.class.template_path
   end
 
+  alias_method :path, :template_path
+
   def template_path=(path)
-    @template_path = File.expand_path(path)
+    @template_path = self.class.setup_path(path)
     @template = nil
   end
 
-  # Alias for `template_path`
-  def self.path
-    template_path
+  class << self
+    alias_method :path, :template_path
+    alias_method :path=, :template_path=
   end
-  alias_method :path, :template_path
-
-  # Alias for `template_path`
-  def self.path=(path)
-    self.template_path = path
-  end
-  alias_method :path=, :template_path=
 
 
   #
@@ -105,26 +135,25 @@ class Mustache
   # Template File
   #
 
-  # The template file is the absolute path of the file Mustache will
-  # use as its template. By default it's ./class_name.mustache
+  # The template file is the absolute path of the file Mustache will use as its template.
+  # By default it's ./class_name.mustache
+  #
 
   def self.template_file
-    @template_file || "#{path}/#{template_name}.#{template_extension}"
+    @template_file || path.map{|p| "#{p}/#{template_name}.#{template_extension}" }.find{|tf| File.readable? tf}
   end
 
-  def self.template_file=(template_file)
-    @template_file = template_file
+  def self.template_file=(tf)
+    @template_file = tf
     @template = nil
   end
 
-  # The template file is the absolute path of the file Mustache will
-  # use as its template. By default it's ./class_name.mustache
   def template_file
-    @template_file || "#{path}/#{template_name}.#{template_extension}"
+    @template_file || path.map{|p| "#{p}/#{template_name}.#{template_extension}" }.find{|tf| File.readable? tf}
   end
 
-  def template_file=(template_file)
-    @template_file = template_file
+  def template_file=(tf)
+    @template_file = tf
     @template = nil
   end
 
@@ -191,6 +220,37 @@ class Mustache
     @raise_on_context_miss = boolean
   end
 
+  #
+  # Context access security level
+  #
+
+  # What object methods could be accessed from the template?
+  # This level determines the security restrictions for method access to protect against unsafe reflection
+  # Possible values are integers from 1 to 5:
+  #
+  # 1 - All methods allowed (use only with trusted templates)
+  # 2 - Reflection-related methods are blacklisted (default)
+  # 3 - All inherited or reflection-related methods are prohibited
+  # 4 - Access allowed only for Hash elements
+  # 5 - Access allowed only for Hash elements, only numbers, strings, hashes and functions allowed
+
+  def self.context_access_security_level
+    @context_access_security_level
+  end
+
+  def self.context_access_security_level=(integer)
+    @context_access_security_level = integer
+  end
+
+  # Instance level version of `Mustache.context_access_security_level`
+  def context_access_security_level
+    self.class.context_access_security_level || @context_access_security_level
+  end
+
+  def context_access_security_level=(integer)
+    @context_access_security_level = integer
+  end
+
 
   #
   # View Namespace

data/lib/mustache/template.rb

@@ -18,9 +18,10 @@ class Mustache
     attr_reader :source
 
     # Expects a Mustache template as a string along with a template
-    # path, which it uses to find partials.
-    def initialize(source)
+    # path, which it uses to find partials. Options may be passed.
+    def initialize(source, options = {})
       @source = source
+      @options = options
     end
 
     # Renders the `@source` Mustache template using the given
@@ -46,13 +47,82 @@ class Mustache
     # Does the dirty work of transforming a Mustache template into an
     # interpolation-friendly Ruby string.
     def compile(src = @source)
-      Generator.new.compile(tokens(src))
+      Generator.new(@options).compile(tokens(src))
     end
     alias_method :to_s, :compile
 
     # Returns an array of tokens for a given template.
+    #
+    # @return [Array] Array of tokens.
+    #
     def tokens(src = @source)
-      Parser.new.compile(src)
+      Parser.new(@options).compile(src)
+    end
+
+    # Returns an array of tags.
+    #
+    # Tags that belong to sections will be of the form `section1.tag`.
+    #
+    # @return [Array] Returns an array of tags.
+    #
+    def tags
+      Template.recursor(tokens, []) do |token, section|
+        if [:etag, :utag].include?(token[1])
+          [ new_token=nil, new_section=nil, result=((section + [token[2][2][0]]).join('.')), stop=true ]
+        elsif [:section, :inverted_section].include?(token[1])
+          [ new_token=token[4], new_section=(section + [token[2][2][0]]), result=nil, stop=false ]
+        else
+          [ new_token=token, new_section=section, result=nil, stop=false ]
+        end
+      end.flatten.reject(&:nil?).uniq
+    end
+
+    # Returns an array of sections.
+    #
+    # Sections that belong to other sections will be of the form `section1.childsection`
+    #
+    # @return [Array] Returns an array of section.
+    #
+    def sections
+      Template.recursor(tokens, []) do |token, section|
+        if [:section, :inverted_section].include?(token[1])
+          new_section=(section + [token[2][2][0]])
+          [ new_token=token[4], new_section, result=new_section.join('.'), stop=false ]
+        else
+          [ new_token=token, new_section=section, result=nil, stop=false ]
+        end
+      end.flatten.reject(&:nil?).uniq
+    end
+
+    # Returns an array of partials.
+    #
+    # Partials that belong to sections are included, but the section name is not preserved
+    #
+    # @return [Array] Returns an array of partials.
+    #
+    def partials
+      Template.recursor(tokens, []) do |token, section|
+        if token[1] == :partial
+          [ new_token=token, new_section=section, result=token[2], stop=true ]
+        else
+          [ new_token=token, new_section=section, result=nil, stop=false ]
+        end
+      end.flatten.reject(&:nil?).uniq
+    end
+
+
+    # Simple recursive iterator for tokens
+    def self.recursor(toks, section, &block)
+      toks.map do |token|
+        next unless token.is_a? Array
+
+        if token.first == :mustache
+          new_token, new_section, result, stop = yield(token, section)
+          [ result ] + ( stop ? [] : recursor(new_token, new_section, &block))
+        else
+          recursor(token, section, &block)
+        end
+      end
     end
   end
 end

data/lib/mustache/utils.rb

@@ -0,0 +1,31 @@
+class Mustache
+  module Utils
+    class String
+      def initialize string
+        @string = string
+      end
+
+      def classify
+        @string.split('/').map do |namespace|
+          namespace.split(/[-_]/).map do |part|
+            part[0] = part.chars.first.upcase
+            part
+          end.join
+        end.join('::')
+      end
+
+      def underscore(view_namespace)
+        @string
+          .dup
+          .split("#{view_namespace}::")
+          .last
+          .split('::')
+          .map do |part|
+            part[0] = part[0].downcase
+            part.gsub(/[A-Z]/) { |s| '_'.dup << s.downcase }
+          end
+          .join('/')
+      end
+    end
+  end
+end

data/lib/mustache/version.rb

@@ -1,3 +1,3 @@
 class Mustache
-  Version = VERSION = '0.99.4'
+  VERSION = '1.1.3'
 end