angry_mob_common_targets 0.1.0

data/vendor/mustache/lib/mustache/sinatra.rb

@@ -0,0 +1,180 @@
+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
+
+        # 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)
+
+        # 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
+
+          # 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
+        end
+
+        # 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
+
+        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)
+
+        # 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/vendor/mustache/lib/mustache/template.rb

@@ -0,0 +1,59 @@
+require 'cgi'
+
+require 'mustache/parser'
+require 'mustache/generator'
+
+class Mustache
+  # A Template represents a Mustache template. It compiles and caches
+  # a raw string template into something usable.
+  #
+  # The idea is this: when handed a Mustache template, convert it into
+  # a Ruby string by transforming Mustache tags into interpolated
+  # Ruby.
+  #
+  # You shouldn't use this class directly, instead:
+  #
+  # >> Mustache.render(template, hash)
+  class Template
+    attr_reader :source
+
+    # Expects a Mustache template as a string along with a template
+    # path, which it uses to find partials.
+    def initialize(source)
+      @source = source
+      @tmpid = 0
+    end
+
+    # Renders the `@source` Mustache template using the given
+    # `context`, which should be a simple hash keyed with symbols.
+    #
+    # The first time a template is rendered, this method is overriden
+    # and from then on it is "compiled". Subsequent calls will skip
+    # the compilation step and run the Ruby version of the template
+    # directly.
+    def render(context)
+      # Compile our Mustache template into a Ruby string
+      compiled = "def render(ctx) #{compile} end"
+
+      # Here we rewrite ourself with the interpolated Ruby version of
+      # our Mustache template so subsequent calls are very fast and
+      # can skip the compilation stage.
+      instance_eval(compiled, __FILE__, __LINE__ - 1)
+
+      # Call the newly rewritten version of #render
+      render(context)
+    end
+
+    # Does the dirty work of transforming a Mustache template into an
+    # interpolation-friendly Ruby string.
+    def compile(src = @source)
+      Generator.new.compile(tokens)
+    end
+    alias_method :to_s, :compile
+
+    # Returns an array of tokens for a given template.
+    def tokens(src = @source)
+      Parser.new.compile(src)
+    end
+  end
+end

data/vendor/mustache/lib/mustache/version.rb

@@ -0,0 +1,3 @@
+class Mustache
+  Version = VERSION = '0.11.2'
+end

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

@@ -0,0 +1,81 @@
+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

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

@@ -0,0 +1,27 @@
+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/vendor/mustache/lib/rack/bug/panels/mustache_panel/view.mustache

@@ -0,0 +1,46 @@
+<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/vendor/mustache/man/mustache.1

@@ -0,0 +1,180 @@
+.\" generated with Ronn/v0.5
+.\" http://github.com/rtomayko/ronn/
+.
+.TH "MUSTACHE" "1" "May 2010" "DEFUNKT" "Mustache Manual"
+.
+.SH "NAME"
+\fBmustache\fR \-\- Mustache processor
+.
+.SH "SYNOPSIS"
+.
+.nf
+
+mustache <YAML> <FILE>
+mustache \-\-compile <FILE>
+mustache \-\-tokens <FILE>
+.
+.fi
+.
+.SH "DESCRIPTION"
+Mustache is a logic\-less templating system for HTML, config files,
+anything.
+.
+.P
+The \fBmustache\fR command processes a Mustache template preceded by YAML
+frontmatter from standard input and prints one or more documents to
+standard output.
+.
+.P
+YAML frontmatter beings with \fB\-\-\-\fR on a single line, followed by YAML,
+ending with another \fB\-\-\-\fR on a single line, e.g.
+.
+.IP "" 4
+.
+.nf
+
+\-\-\-
+names: [ {name: chris}, {name: mark}, {name: scott} ]
+\-\-\-
+.
+.fi
+.
+.IP "" 0
+.
+.P
+If you are unfamiliar with YAML, it is a superset of JSON. Valid JSON
+should work fine.
+.
+.P
+After the frontmatter should come any valid Mustache template. See
+mustache(5) for an overview of Mustache templates.
+.
+.P
+For example:
+.
+.IP "" 4
+.
+.nf
+
+{{#names}}
+  Hi {{name}}!
+{{/names}}
+.
+.fi
+.
+.IP "" 0
+.
+.P
+Now let's combine them.
+.
+.IP "" 4
+.
+.nf
+
+$ cat data.yml
+\-\-\-
+names: [ {name: chris}, {name: mark}, {name: scott} ]
+\-\-\-
+
+$ cat template.mustache
+{{#names}}
+  Hi {{name}}!
+{{/names}}
+
+$ cat data.yml template.mustache | mustache
+Hi chris!
+Hi mark!
+Hi scott!
+.
+.fi
+.
+.IP "" 0
+.
+.P
+If you provide multiple YAML documents (as delimited by \fB\-\-\-\fR), your
+template will be rendered multiple times. Like a mail merge.
+.
+.P
+For example:
+.
+.IP "" 4
+.
+.nf
+
+$ cat data.yml
+\-\-\-
+name: chris
+\-\-\-
+name: mark
+\-\-\-
+name: scott
+\-\-\-
+
+$ cat template.mustache
+Hi {{name}}!
+
+$ cat data.yml template.mustache | mustache
+Hi chris!
+Hi mark!
+Hi scott!
+.
+.fi
+.
+.IP "" 0
+.
+.SH "OPTIONS"
+By default \fBmustache\fR will try to render a Mustache template using the
+YAML frontmatter you provide. It can do a few other things, however.
+.
+.TP
+\fB\-c\fR, \fB\-\-compile\fR
+Print the compiled Ruby version of a given template. This is the
+code that is actually used when rendering a template into a
+string. Useful for debugging but only if you are familiar with
+Mustache's internals.
+.
+.TP
+\fB\-t\fR, \fB\-\-tokens\fR
+Print the tokenized form of a given Mustache template. This can be
+used to understand how Mustache parses a template. The tokens are
+handed to a generator which compiles them into a Ruby
+string. Syntax errors and confused tags, therefor, can probably be
+identified by examining the tokens produced.
+.
+.SH "INSTALLATION"
+If you have RubyGems installed:
+.
+.IP "" 4
+.
+.nf
+
+gem install mustache
+.
+.fi
+.
+.IP "" 0
+.
+.SH "EXAMPLES"
+.
+.nf
+
+$ mustache data.yml template.mustache
+$ cat data.yml | mustache \- template.mustache
+$ mustache \-c template.mustache
+$ cat <<data | ruby mustache \- template.mustache
+\-\-\-
+name: Bob
+age: 30
+\-\-\-
+data
+.
+.fi
+.
+.SH "COPYRIGHT"
+Mustache is Copyright (C) 2009 Chris Wanstrath
+.
+.P
+Original CTemplate by Google
+.
+.SH "SEE ALSO"
+mustache(5), mustache(7), gem(1), \fIhttp://mustache.github.com/\fR