mustache 0.99.8 → 1.0.0

data/lib/mustache/context.rb

@@ -1,18 +1,16 @@
+require 'mustache/context_miss'
+
 class Mustache
-  # A ContextMiss is raised whenever a tag's target can not be found
-  # in the current context if `Mustache#raise_on_context_miss?` is
-  # set to true.
-  #
-  # For example, if your View class does not respond to `music` but
-  # your template contains a `{{music}}` tag this exception will be raised.
-  #
-  # By default it is not raised. See Mustache.raise_on_context_miss.
-  class ContextMiss < RuntimeError;  end
 
   # A Context represents the context which a Mustache template is
   # executed within. All Mustache tags reference keys in the Context.
+  #
   class Context
-    # Expect to be passed an instance of `Mustache`.
+
+    # Initializes a Mustache::Context.
+    #
+    # @param [Mustache] mustache A Mustache instance.
+    #
     def initialize(mustache)
       @stack = [mustache]
     end
@@ -23,6 +21,7 @@ class Mustache
     # If the Mustache view handling the rendering (e.g. the view
     # representing your profile page or some other template) responds
     # to `partial`, we call it and render the result.
+    #
     def partial(name, indentation = '')
       # Look for the first Mustache in the stack.
       mustache = mustache_in_stack
@@ -34,32 +33,43 @@ class Mustache
       mustache.render(part, self)
     end
 
-    # Find the first Mustache in the stack. If we're being rendered
-    # inside a Mustache object as a context, we'll use that one.
+    # Find the first Mustache in the stack.
+    #
+    # If we're being rendered inside a Mustache object as a context,
+    # we'll use that one.
+    #
+    # @return [Mustache] First Mustache in the stack.
+    #
     def mustache_in_stack
-      @stack.detect { |frame| frame.is_a?(Mustache) }
+      @stack.find { |frame| frame.is_a?(Mustache) }
     end
 
     # Allows customization of how Mustache escapes things.
     #
-    # Returns a String.
+    # @param [String] str String to escape.
+    #
+    # @return [String] Escaped HTML string.
+    #
     def escapeHTML(str)
       mustache_in_stack.escapeHTML(str)
     end
 
     # Adds a new object to the context's internal stack.
     #
-    # Returns the Context.
-    def push(new)
-      @stack.unshift(new)
+    # @param [Object] new_obj Object to be added to the internal stack.
+    #
+    # @return [Context] Returns the Context.
+    #
+    def push(new_obj)
+      @stack.unshift(new_obj)
       self
     end
-    alias_method :update, :push
 
     # Removes the most recently added object from the context's
     # internal stack.
     #
-    # Returns the Context.
+    # @return [Context] Returns the Context.
+    #
     def pop
       @stack.shift
       self
@@ -112,37 +122,36 @@ class Mustache
     # If it's an object that responds to the key as a method call,
     # invokes that method. You get the idea.
     #
-    #     obj - The object to perform the lookup on.
-    #     key - The key whose value you want.
-    # default - An optional default value, to return if the
-    #           key is not found.
+    # @param [Object] obj The object to perform the lookup on.
+    # @param [String,Symbol] key The key whose value you want
+    # @param [Object] default An optional default value, to return if the key is not found.
+    #
+    # @return [Object] The value of key in object if it is found, and default otherwise.
     #
-    # Returns the value of key in obj if it is found and default otherwise.
     def find(obj, key, default = nil)
-      if !obj.respond_to?(:to_hash)
-        # If a class, we need to find tags (methods) per Parser::ALLOWED_CONTENT.
-        key = key.to_s.tr('-', '_') if key.to_s.include?('-')
-
-        if obj.respond_to?(key)
-          meth = obj.method(key) rescue proc { obj.send(key) }
-
-          meth.arity == 1 ? meth.to_proc : meth[]
-        else
-          default
-        end
-      elsif obj.has_key?(key)
-        obj[key]
-      elsif obj.has_key?(key.to_s)
-        obj[key.to_s]
-      else
-        obj[key] || default
-      end
+      return find_in_hash(obj, key, default) if obj.respond_to?(:to_hash)
+
+      key = to_tag(key)
+      return default unless obj.respond_to?(key)
+
+      meth = obj.method(key) rescue proc { obj.send(key) }
+      meth.arity == 1 ? meth.to_proc : meth.call
     end
-  end
-end
 
-class Hash
-  def to_hash
-    self
-  end unless method_defined?(:to_hash)
+
+    private
+
+
+    # If a class, we need to find tags (methods) per Parser::ALLOWED_CONTENT.
+    def to_tag key
+      key.to_s.include?('-') ? key.to_s.tr('-', '_') : key
+    end
+
+    def find_in_hash obj, key, default
+      return obj[key]      if obj.has_key?(key)
+      return obj[key.to_s] if obj.has_key?(key.to_s)
+
+      obj.fetch(key, default)
+    end
+  end
 end

data/lib/mustache/context_miss.rb

@@ -0,0 +1,14 @@
+class Mustache
+
+  # A ContextMiss is raised whenever a tag's target can not be found
+  # in the current context if `Mustache#raise_on_context_miss?` is
+  # set to true.
+  #
+  # For example, if your View class does not respond to `music` but
+  # your template contains a `{{music}}` tag this exception will be raised.
+  #
+  # By default it is not raised. See Mustache.raise_on_context_miss.
+  #
+  class ContextMiss < RuntimeError;  end
+
+end

data/lib/mustache/generator.rb

@@ -37,6 +37,10 @@ class Mustache
       "\"#{compile!(exp)}\""
     end
 
+
+    private
+
+
     # Given an array of tokens, converts them into Ruby code. In
     # particular there are three types of expressions we are concerned
     # with:
@@ -83,7 +87,7 @@ class Mustache
     def compile!(exp)
       case exp.first
       when :multi
-        exp[1..-1].map { |e| compile!(e) }.join
+        exp[1..-1].reduce("") { |sum, e| sum << compile!(e) }
       when :static
         str(exp[1])
       when :mustache

data/lib/mustache/parser.rb

@@ -75,14 +75,14 @@ EOF
     # 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 = [ '#', '^', '/', '<', '>', '=', '!' ].map &:freeze
+    SKIP_WHITESPACE = [ '#', '^', '/', '<', '>', '=', '!' ].map(&:freeze)
 
     # The content allowed in a tag name.
     ALLOWED_CONTENT = /(\w|[?!\/.-])*/
 
     # These types of tags allow any content,
     # the rest only allow ALLOWED_CONTENT.
-    ANY_CONTENT = [ '!', '=' ].map &:freeze
+    ANY_CONTENT = [ '!', '=' ].map(&:freeze)
 
     attr_reader :scanner, :result
     attr_writer :otag, :ctag
@@ -105,11 +105,11 @@ EOF
 
     # 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.
@@ -131,6 +131,10 @@ EOF
       @result
     end
 
+
+    private
+
+
     # Find {{mustaches}} and add them to the @result array.
     def scan_tags
       # Scan until we hit an opening delimiter.
@@ -178,6 +182,7 @@ EOF
       else
         @result << [:mustache, :etag, fetch, offset]
       end
+
       # The closing } in unescaped tags is just a hack for
       # aesthetics.
       type = "}" if type == "{"
@@ -267,24 +272,35 @@ EOF
       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 defined using define_method.
+    # characters in their method names, they are aliased to
+    # better named methods.
+    #
+
 
-    define_method 'scan_tag_#' do |content, fetch, padding, pre_match_position|
+    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
 
-    define_method 'scan_tag_^' do |content, fetch, padding, pre_match_position|
+
+    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
+
 
-    define_method 'scan_tag_/' do |content, fetch, padding, pre_match_position|
+    def scan_tag_close content, fetch, padding, pre_match_position
       section, pos, result = @sections.pop
       raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
       (@result = result).last << raw << [self.otag, self.ctag]
@@ -295,23 +311,32 @@ EOF
         error "Unclosed section #{section.inspect}", pos
       end
     end
+    alias_method :'scan_tag_/', :scan_tag_close
 
-    define_method 'scan_tag_!' do |content, fetch, padding, pre_match_position|
+
+    def scan_tag_comment content, fetch, padding, pre_match_position
     end
+    alias_method :'scan_tag_!', :scan_tag_comment
+
 
-    define_method 'scan_tag_=' do |content, fetch, padding, pre_match_position|
+    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
 
-    define_method 'scan_tag_>' do |content, fetch, padding, pre_match_position|
+
+    def scan_tag_open_partial content, fetch, padding, pre_match_position
       @result << [:mustache, :partial, content, offset, padding]
     end
-    alias_method :'scan_tag_<', :'scan_tag_>'
+    alias_method :'scan_tag_<', :scan_tag_open_partial
+    alias_method :'scan_tag_>', :scan_tag_open_partial
+
 
-    define_method 'scan_tag_{' do |content, fetch, padding, pre_match_position|
+    def scan_tag_unescaped content, fetch, padding, pre_match_position
       @result << [:mustache, :utag, fetch, offset]
     end
-    alias_method :'scan_tag_&', :'scan_tag_{'
+    alias_method :'scan_tag_{', :'scan_tag_unescaped'
+    alias_method :'scan_tag_&', :'scan_tag_unescaped'
 
   end
 end

data/lib/mustache/settings.rb

@@ -24,6 +24,7 @@ class Mustache
   def template_path
     @template_path ||= self.class.template_path
   end
+  alias_method :path, :template_path
 
   def template_path=(path)
     @template_path = File.expand_path(path)
@@ -34,13 +35,11 @@ class Mustache
   def self.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=
 
 
   #

data/lib/mustache/template.rb

@@ -51,26 +51,19 @@ class Mustache
     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)
     end
 
-    # Simple recursive iterator for tokens
-    def self.recursor(toks, section, &block)
-      toks.map do |token|
-        next unless token.is_a? Array
-
-        if token[0] == :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
-
-    # Returns an array of tags
-    # Tags that belong to sections will be of the form `section1.tag`
+    # 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])
@@ -83,8 +76,12 @@ class Mustache
       end.flatten.reject(&:nil?).uniq
     end
 
-    # Returns an array of sections
+    # 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])
@@ -96,8 +93,12 @@ class Mustache
       end.flatten.reject(&:nil?).uniq
     end
 
-    # Returns an array of partials
+    # 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
@@ -107,5 +108,23 @@ class Mustache
         end
       end.flatten.reject(&:nil?).uniq
     end
+
+
+    private
+
+
+    # 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/version.rb

@@ -1,3 +1,3 @@
 class Mustache
-  Version = VERSION = '0.99.8'
+  VERSION = '1.0.0'
 end

data/test/autoloading_test.rb

@@ -1,9 +1,8 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require 'helper'
+require_relative 'helper'
 
 module TestViews; end
 
-class AutoloadingTest < Test::Unit::TestCase
+class AutoloadingTest < Minitest::Test
   def setup
     Mustache.view_path = File.dirname(__FILE__) + '/fixtures'
   end

data/test/fixtures/comments.rb

@@ -1,4 +1,3 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'mustache'
 
 class Comments < Mustache

data/test/fixtures/complex_view.rb

@@ -1,4 +1,3 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'mustache'
 
 class ComplexView < Mustache