mustache 0.99.4 → 1.1.3

metadata

@@ -1,62 +1,49 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mustache
-version: !ruby/object:Gem::Version 
-  hash: 411
-  prerelease: 
-  segments: 
-  - 0
-  - 99
-  - 4
-  version: 0.99.4
+version: !ruby/object:Gem::Version
+  version: 1.1.3
 platform: ruby
-authors: 
+authors:
 - Chris Wanstrath
 - Magnus Holm
 - Pieter van de Bruggen
-autorequire: 
+- Ricardo Mendes
 bindir: bin
 cert_chain: []
-
-date: 2011-05-26 00:00:00 -07:00
-default_executable: 
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies: []
-
 description: |
   Inspired by ctemplate, Mustache is a framework-agnostic way to render
   logic-free views.
-  
+
   As ctemplates says, "It emphasizes separating logic from presentation:
   it is impossible to embed application logic in this template
   language.
-  
+
   Think of Mustache as a replacement for your views. Instead of views
   consisting of ERB or HAML with random helpers and arbitrary logic,
   your views are broken into two parts: a Ruby class and an HTML
   template.
-
-email: chris@ozmm.org
-executables: 
+email: rokusu@gmail.com
+executables:
 - mustache
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- LICENSE
 - README.md
 - Rakefile
-- LICENSE
+- bin/mustache
+- lib/mustache.rb
 - lib/mustache/context.rb
+- lib/mustache/context_miss.rb
+- lib/mustache/enumerable.rb
 - lib/mustache/generator.rb
 - lib/mustache/parser.rb
 - lib/mustache/settings.rb
-- lib/mustache/sinatra.rb
 - lib/mustache/template.rb
+- lib/mustache/utils.rb
 - lib/mustache/version.rb
-- lib/mustache.rb
-- lib/rack/bug/panels/mustache_panel/mustache_extension.rb
-- lib/rack/bug/panels/mustache_panel/view.mustache
-- lib/rack/bug/panels/mustache_panel.rb
-- bin/mustache
 - man/mustache.1
 - man/mustache.1.html
 - man/mustache.1.ron
@@ -84,12 +71,15 @@ files:
 - test/fixtures/inverted_section.rb
 - test/fixtures/lambda.mustache
 - test/fixtures/lambda.rb
+- test/fixtures/liberal.mustache
+- test/fixtures/liberal.rb
 - test/fixtures/method_missing.rb
 - test/fixtures/namespaced.mustache
 - test/fixtures/namespaced.rb
 - test/fixtures/nested_objects.mustache
 - test/fixtures/nested_objects.rb
 - test/fixtures/node.mustache
+- test/fixtures/override/passenger.conf
 - test/fixtures/partial_with_module.mustache
 - test/fixtures/partial_with_module.rb
 - test/fixtures/passenger.conf
@@ -98,6 +88,7 @@ files:
 - test/fixtures/recursive.rb
 - test/fixtures/simple.mustache
 - test/fixtures/simple.rb
+- test/fixtures/simply_complicated.mustache
 - test/fixtures/template_partial.mustache
 - test/fixtures/template_partial.rb
 - test/fixtures/template_partial.txt
@@ -109,41 +100,28 @@ files:
 - test/mustache_test.rb
 - test/parser_test.rb
 - test/partial_test.rb
+- test/path_test.rb
 - test/spec_test.rb
 - test/template_test.rb
-has_rdoc: true
-homepage: http://github.com/defunkt/mustache
-licenses: []
-
-post_install_message: 
+homepage: https://github.com/mustache/mustache
+licenses:
+- MIT
+metadata: {}
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.5.2
-signing_key: 
-specification_version: 3
+rubygems_version: 3.6.9
+specification_version: 4
 summary: Mustache is a framework-agnostic way to render logic-free views.
 test_files: []
-

data/lib/mustache/sinatra.rb

@@ -1,186 +0,0 @@
-require 'sinatra/base'
-require 'mustache'
-
-class Mustache
-  # Support for Mustache in your Sinatra app.
-  #
-  #   require 'mustache/sinatra'
-  #
-  #   class Hurl < Sinatra::Base
-  #     register Mustache::Sinatra
-  #
-  #     set :mustache, {
-  #       # Should be the path to your .mustache template files.
-  #       :templates => "path/to/mustache/templates",
-  #
-  #       # Should be the path to your .rb Mustache view files.
-  #       :views => "path/to/mustache/views",
-  #
-  #       # This tells Mustache where to look for the Views module,
-  #       # under which your View classes should live. By default it's
-  #       # the class of your app - in this case `Hurl`. That is, for an :index
-  #       # view Mustache will expect Hurl::Views::Index by default.
-  #       # If our Sinatra::Base subclass was instead Hurl::App,
-  #       # we'd want to do `set :namespace, Hurl::App`
-  #       :namespace => Hurl
-  #     }
-  #
-  #     get '/stats' do
-  #       mustache :stats
-  #     end
-  #   end
-  #
-  # As noted above, Mustache will look for `Hurl::Views::Index` when
-  # `mustache :index` is called.
-  #
-  # If no `Views::Stats` class exists Mustache will render the template
-  # file directly.
-  #
-  # You can indeed use layouts with this library. Where you'd normally
-  # <%= yield %> you instead {{{yield}}} - the body of the subview is
-  # set to the `yield` variable and made available to you.
-  module Sinatra
-    module Helpers
-      # Call this in your Sinatra routes.
-      def mustache(template, options={}, locals={})
-        # Locals can be passed as options under the :locals key.
-        locals.update(options.delete(:locals) || {})
-
-        # Grab any user-defined settings.
-        if settings.respond_to?(:mustache)
-          options = settings.send(:mustache).merge(options)
-        end
-
-        # If they aren't explicitly disabling layouts, try to find
-        # one.
-        if options[:layout] != false
-          # Let the user pass in a layout name.
-          layout_name = options[:layout]
-
-          # If all they said was `true` (or nothing), default to :layout.
-          layout_name = :layout if layout_name == true || !layout_name
-
-          # If they passed a layout name use that.
-          layout = mustache_class(layout_name, options)
-
-          # If it's just an anonymous subclass then don't bother, otherwise
-          # give us a layout instance.
-          if layout.name && layout.name.empty?
-            layout = nil
-          else
-            layout = layout.new
-          end
-        end
-
-        # Find and cache the view class we want. This ensures the
-        # compiled template is cached, too - no looking up and
-        # compiling templates on each page load.
-        klass = mustache_class(template, options)
-
-        # Does the view subclass the layout? If so we'll use the
-        # view to render the layout so you can override layout
-        # methods in your view - tricky.
-        view_subclasses_layout = klass < layout.class if layout
-
-        # Create a new instance for playing with.
-        instance = klass.new
-
-        # Copy instance variables set in Sinatra to the view
-        instance_variables.each do |name|
-          instance.instance_variable_set(name, instance_variable_get(name))
-        end
-
-        # Render with locals.
-        rendered = instance.render(instance.template, locals)
-
-        # Now render the layout with the view we just rendered, if we
-        # need to.
-        if layout && view_subclasses_layout
-          rendered = instance.render(layout.template, :yield => rendered)
-        elsif layout
-          rendered = layout.render(layout.template, :yield => rendered)
-        end
-
-        # That's it.
-        rendered
-      end
-
-      # Returns a View class for a given template name.
-      def mustache_class(template, options = {})
-        @template_cache.fetch(:mustache, template) do
-          compile_mustache(template, options)
-        end
-      end
-
-      # Given a view name and settings, finds and prepares an
-      # appropriate view class for this view.
-      def compile_mustache(view, options = {})
-        options[:templates] ||= settings.views if settings.respond_to?(:views)
-        options[:namespace] ||= self.class
-
-        unless options[:namespace].to_s.include? 'Views'
-          options[:namespace] = options[:namespace].const_get(:Views)
-        end
-
-        factory = Class.new(Mustache) do
-          self.view_namespace = options[:namespace]
-          self.view_path      = options[:views]
-        end
-
-        # If we were handed :"positions.atom" or some such as the
-        # template name, we need to remember the extension.
-        if view.to_s.include?('.')
-          view, ext = view.to_s.split('.')
-        end
-
-        # Try to find the view class for a given view, e.g.
-        # :view => Hurl::Views::Index.
-        klass = factory.view_class(view)
-        klass.view_namespace = options[:namespace]
-        klass.view_path      = options[:views]
-
-        # If there is no view class, issue a warning and use the one
-        # we just generated to cache the compiled template.
-        if klass == Mustache
-          warn "No view class found for #{view} in #{factory.view_path}"
-          klass = factory
-
-          # If this is a generic view class make sure we set the
-          # template name as it was given. That is, an anonymous
-          # subclass of Mustache won't know how to find the
-          # "index.mustache" template unless we tell it to.
-          klass.template_name = view.to_s
-        elsif ext
-          # We got an ext (like "atom"), so look for an "Atom" class
-          # under the current View's namespace.
-          #
-          # So if our template was "positions.atom", try to find
-          # Positions::Atom.
-          if klass.const_defined?(ext_class = ext.capitalize)
-            # Found Positions::Atom - set it
-            klass = klass.const_get(ext_class)
-          else
-            # Didn't find Positions::Atom - create it by creating an
-            # anonymous subclass of Positions and setting that to
-            # Positions::Atom.
-            new_class = Class.new(klass)
-            new_class.template_name = "#{view}.#{ext}"
-            klass.const_set(ext_class, new_class)
-            klass = new_class
-          end
-        end
-
-        # Set the template path and return our class.
-        klass.template_path = options[:templates] if options[:templates]
-        klass
-      end
-    end
-
-    # Called when you `register Mustache::Sinatra` in your Sinatra app.
-    def self.registered(app)
-      app.helpers Mustache::Sinatra::Helpers
-    end
-  end
-end
-
-Sinatra.register Mustache::Sinatra

data/lib/rack/bug/panels/mustache_panel/mustache_extension.rb

@@ -1,27 +0,0 @@
-if defined? Mustache
-  require 'benchmark'
-
-  Mustache.class_eval do
-    alias_method :real_render, :render
-
-    def render(*args, &block)
-      out = ''
-      Rack::Bug::MustachePanel.times[self.class.name] = Benchmark.realtime do
-        out = real_render(*args, &block)
-      end
-      out
-    end
-
-    alias_method :to_html, :render
-    alias_method :to_text, :render
-  end
-
-  Mustache::Context.class_eval do
-    alias_method :real_get, :[]
-
-    def [](name)
-      return real_get(name) if name == :yield || !@mustache.respond_to?(name)
-      Rack::Bug::MustachePanel.variables[name] = real_get(name)
-    end
-  end
-end

data/lib/rack/bug/panels/mustache_panel/view.mustache

@@ -1,46 +0,0 @@
-<script type="text/javascript">
-$(function() {
-  $('#mustache_variables .variable').each(function() {
-    var el = $(this)
-    if (el.text().length > 500) {
-      var txt = el.text()
-      el.click(function() {
-        $(this).text(txt)
-      }).text( el.text().slice(0, 500) + '...' )
-    }
-  })
-});
-</script>
-
-<h3>Render Times</h3>
-
-<table>
-  <tr>
-    <th>View</th>
-    <th>Render Time</th>
-  </tr>
-
-  {{# times }}
-    <tr>
-      <td>{{ key }}</td>
-      <td>{{ value }}</td>
-    </tr>
-  {{/ times }}
-</table>
-
-<h3>Variables</h3>
-
-<table id="mustache_variables">
-  <tr>
-    <th>Name</th>
-    <th>Value</th>
-  </tr>
-
-  {{# variables }}
-    <tr>
-      <td>{{ key }}</td>
-      <td class="variable">{{ value }}</td>
-    </tr>
-  {{/ variables }}
-</table>
-

data/lib/rack/bug/panels/mustache_panel.rb

@@ -1,81 +0,0 @@
-module Rack
-  module Bug
-    # MustachePanel is a Rack::Bug panel which tracks the time spent rendering
-    # Mustache views as well as all the variables accessed during view
-    # rendering.
-    #
-    # It can be used to track down slow partials and ensure you're only
-    # generating data you need.
-    #
-    # Also, it's fun.
-    class MustachePanel < Panel
-      require "rack/bug/panels/mustache_panel/mustache_extension"
-
-      # The view is responsible for rendering our panel. While Rack::Bug
-      # takes care of the nav, the content rendered by View is used for
-      # the panel itself.
-      class View < Mustache
-        self.path = ::File.dirname(__FILE__) + '/mustache_panel'
-
-        # We track the render times of all the Mustache views on this
-        # page load.
-        def times
-          MustachePanel.times.map do |key, value|
-            { :key => key, :value => value }
-          end
-        end
-
-        # Any variables used in this page load are collected and displayed.
-        def variables
-          vars = MustachePanel.variables.sort_by { |key, _| key.to_s }
-          vars.map do |key, value|
-            # Arrays can get too huge. Just show the first 10 to give you
-            # some idea.
-            if value.is_a?(Array) && value.size > 10
-              size = value.size
-              value = value.first(10)
-              value << "...and #{size - 10} more"
-            end
-
-            { :key => key, :value => value.inspect }
-          end
-        end
-      end
-
-      # Clear out our page load-specific variables.
-      def self.reset
-        Thread.current["rack.bug.mustache.times"] = {}
-        Thread.current["rack.bug.mustache.vars"] = {}
-      end
-
-      # The view render times for this page load
-      def self.times
-        Thread.current["rack.bug.mustache.times"] ||= {}
-      end
-
-      # The variables used on this page load
-      def self.variables
-        Thread.current["rack.bug.mustache.vars"] ||= {}
-      end
-
-      # The name of this Rack::Bug panel
-      def name
-        "mustache"
-      end
-
-      # The string used for our tab in Rack::Bug's navigation bar
-      def heading
-        "{{%.2fms}}" % self.class.times.values.inject(0.0) do |sum, obj|
-          sum + obj
-        end
-      end
-
-      # The content of our Rack::Bug panel
-      def content
-        View.render
-      ensure
-        self.class.reset
-      end
-    end
-  end
-end