angry_mob_common_targets 0.1.0

data/vendor/mustache/Rakefile

@@ -0,0 +1,103 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+#
+# Helpers
+#
+
+def command?(command)
+  system("type #{command} > /dev/null")
+end
+
+
+#
+# Tests
+#
+
+task :default => :test
+
+if command? :turn
+  desc "Run tests"
+  task :test do
+    suffix = "-n #{ENV['TEST']}" if ENV['TEST']
+    sh "turn test/*.rb #{suffix}"
+  end
+else
+  Rake::TestTask.new do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = false
+  end
+end
+
+if command? :kicker
+  desc "Launch Kicker (like autotest)"
+  task :kicker do
+    puts "Kicking... (ctrl+c to cancel)"
+    exec "kicker -e rake test lib examples"
+  end
+end
+
+
+#
+# Ron
+#
+
+if command? :ronn
+  desc "Show the manual"
+  task :man => "man:build" do
+    exec "man man/mustache.1"
+  end
+
+  desc "Build the manual"
+  task "man:build" do
+    sh "ronn -br5 --organization=DEFUNKT --manual='Mustache Manual' man/*.ron"
+  end
+end
+
+
+#
+# Gems
+#
+
+desc "Push a new version to Gemcutter and publish docs."
+task :publish do
+  require File.dirname(__FILE__) + '/lib/mustache/version'
+
+  system "git tag v#{Mustache::Version}"
+  sh "gem build mustache.gemspec"
+  sh "gem push mustache-#{Mustache::Version}.gem"
+  sh "git push origin master --tags"
+  sh "git clean -fd"
+  exec "rake pages"
+end
+
+#
+# Documentation
+#
+
+begin
+  require 'sdoc_helpers'
+rescue LoadError
+  warn "sdoc support not enabled. Please gem install sdoc-helpers."
+end
+
+desc "Publish to GitHub Pages"
+task :pages => [ "man:build" ] do
+  Dir['man/*.html'].each do |f|
+    cp f, File.basename(f).sub('.html', '.newhtml')
+  end
+
+  `git commit -am 'generated manual'`
+  `git checkout site`
+
+  Dir['*.newhtml'].each do |f|
+    mv f, f.sub('.newhtml', '.html')
+  end
+
+  `git add .`
+  `git commit -m updated`
+  `git push site site:master`
+  `git checkout master`
+  puts :done
+end

data/vendor/mustache/benchmarks/complex.erb

@@ -0,0 +1,15 @@
+<h1><%= header %></h1>
+<% if not item.empty? %>
+  <ul>
+  <% for i in item %>
+    <% if i[:current] %>
+      <li><strong><%= i[:name] %></strong></li>
+    <% else %>
+      <li><a href="<%= i[:url] %>"><%= i[:name] %></a></li>
+    <% end %>
+  <% end %>
+  </ul>
+<% end %>
+<% if item.empty? %>
+  <p>The list is empty.</p>
+<% end %>

data/vendor/mustache/benchmarks/complex.haml

@@ -0,0 +1,12 @@
+%h1= header
+- if not item.empty?
+  %ul
+    - for i in item
+      - if i[:current]
+        %li
+          %strong= i[:name]
+      - else
+        %li
+          %a{:href => i[:url]}= i[:name]
+- if item.empty?
+  %p The list is empty.

data/vendor/mustache/benchmarks/helper.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+
+count = (ENV['COUNT'] || 5000).to_i
+
+$benches = []
+def bench(name, &block)
+  $benches.push([name, block])
+end
+
+at_exit do
+  Benchmark.bmbm do |x|
+    $benches.each do |name, block|
+      x.report name.to_s do
+        count.times do
+          block.call
+        end
+      end
+    end
+  end
+end

data/vendor/mustache/benchmarks/simple.erb

@@ -0,0 +1,5 @@
+Hello <%= name %>
+You have just won $<%= value %>!
+<% if in_ca %>
+Well, $<%= taxed_value %>, after taxes.
+<% end %>

data/vendor/mustache/benchmarks/speed.rb

@@ -0,0 +1,78 @@
+require 'erb'
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'helper'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../test/fixtures'
+require 'complex_view'
+
+## erb
+unless ENV['NOERB']
+  template = File.read(File.dirname(__FILE__) + '/complex.erb')
+
+  erb =  ERB.new(template)
+  erb_scope = ComplexView.new
+  erb_scope.instance_eval("def render_erb; #{erb.src}; end")
+  bench 'ERB  w/ caching' do
+    erb_scope.render_erb
+  end
+
+  unless ENV['CACHED']
+    erb_nocache_scope = ComplexView.new.send(:binding)
+    bench 'ERB  w/o caching' do
+      ERB.new(template).result(erb_nocache_scope)
+    end
+  end
+end
+
+
+## haml
+unless ENV['NOHAML']
+  require 'haml'
+  template = File.read(File.dirname(__FILE__) + '/complex.haml')
+
+  haml = Haml::Engine.new(template, :ugly => true)
+  haml_scope = ComplexView.new
+  haml.def_method(haml_scope, :render_haml)
+  bench 'HAML w/ caching' do
+    haml_scope.render_haml
+  end
+
+  unless ENV['CACHED']
+    haml_nocache_scope = ComplexView.new.send(:binding)
+    bench 'HAML w/o caching' do
+      Haml::Engine.new(template).render(haml_nocache_scope)
+    end
+  end
+end
+
+
+## mustache
+tpl = ComplexView.new
+tpl.template
+
+tpl[:header] = 'Chris'
+tpl[:empty] = false
+tpl[:list] = true
+
+items = []
+items << { :name => 'red', :current => true, :url => '#Red' }
+items << { :name => 'green', :current => false, :url => '#Green' }
+items << { :name => 'blue', :current => false, :url => '#Blue' }
+
+tpl[:item] = items
+
+bench '{{   w/ caching' do
+  tpl.to_html
+end
+
+content = File.read(ComplexView.template_file)
+
+unless ENV['CACHED']
+  bench '{{   w/o caching' do
+    ctpl = ComplexView.new
+    ctpl.template = content
+    ctpl[:item] = items
+    ctpl.to_html
+  end
+end

data/vendor/mustache/bin/mustache

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'optparse'
+
+require 'mustache'
+require 'mustache/version'
+
+class Mustache
+  class CLI
+    # Return a structure describing the options.
+    def self.parse_options(args)
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: mustache [-c] [-t] FILE ..."
+
+        opts.separator " "
+
+        opts.separator "Examples:"
+        opts.separator "  $ mustache data.yml template.mustache"
+        opts.separator "  $ cat data.yml | mustache - template.mustache"
+        opts.separator "  $ mustache -c template.mustache"
+
+        opts.separator " "
+
+        opts.separator "  See mustache(1) or " +
+          "http://mustache.github.com/mustache.1.html"
+        opts.separator "  for more details."
+
+        opts.separator " "
+        opts.separator "Options:"
+
+        opts.on("-c", "--compile FILE",
+          "Print the compiled Ruby for a given template.") do |file|
+          puts Mustache::Template.new(File.read(file)).compile
+          exit
+        end
+
+        opts.on("-t", "--tokens FILE",
+          "Print the tokenized form of a given template.") do |file|
+          require 'pp'
+          pp Mustache::Template.new(File.read(file)).tokens
+          exit
+        end
+
+        opts.separator "Common Options:"
+
+        opts.on("-v", "--version", "Print the version") do |v|
+          puts "Mustache v#{Mustache::Version}"
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      opts.separator ""
+
+      opts.parse!(args)
+    end
+
+    # Does the dirty work of reading files from STDIN and the command
+    # line then processing them. The meat of this script, if you will.
+    def self.process_files(input_stream)
+      doc = input_stream.read
+
+      if doc =~ /^(\s*---(.+)---\s*)/m
+        yaml = $2.strip
+        template = doc.sub($1, '')
+
+        YAML.each_document(yaml) do |data|
+          puts Mustache.render(template, data)
+        end
+      else
+        puts Mustache.render(doc)
+      end
+    end
+  end
+end
+
+# Help is the default.
+ARGV << '-h' if ARGV.empty? && $stdin.tty?
+
+# Process options
+Mustache::CLI.parse_options(ARGV) if $stdin.tty?
+
+# Still here - process ARGF
+Mustache::CLI.process_files(ARGF)
+

data/vendor/mustache/contrib/mustache-mode.el

@@ -0,0 +1,278 @@
+;;; tpl-mode.el -- a major mode for editing Google CTemplate files.
+;;; By Tony Gentilcore, July 2006
+;;;
+;;; Very minor, backwards compatible changes added for Mustache compatibility
+;;; by Chris Wanstrath, October 2009
+;;;
+;;; TO USE:
+;;; 1) Copy this file somewhere you in emacs load-path.  To see what
+;;;    your load-path is, run inside emacs: C-h v load-path<RET>
+;;; 2) Add the following two lines to your .emacs file:
+;;;    (setq auto-mode-alist (cons '("\\.tpl$" . tpl-mode) auto-mode-alist))
+;;;    (autoload 'tpl-mode "tpl-mode" "Major mode for editing CTemplate files." t)
+;;; 3) Optionally (but recommended), add this third line as well:
+;;;    (add-hook 'tpl-mode-hook '(lambda () (font-lock-mode 1)))
+;;; ---
+;;;
+;;; While the Mustache language can be used for any types of text,
+;;; this mode is intended for using Mustache to write HTML.
+;;;
+;;; The indentation still has minor bugs due to the fact that
+;;; templates do not require valid HTML.
+;;;
+;;; It would be nice to be able to highlight attributes of HTML tags,
+;;; however this is difficult due to the presence of CTemplate symbols
+;;; embedded within attributes.
+
+(eval-when-compile
+  (require 'font-lock))
+
+(defgroup tpl-mode nil
+  "Major mode for editing Google CTemplate and Mustache files"
+  :group 'languages)
+
+(defvar tpl-mode-version "1.1"
+  "Version of `tpl-mode.el'.")
+
+(defvar tpl-mode-abbrev-table nil
+  "Abbrev table for use in tpl-mode buffers.")
+
+(define-abbrev-table 'tpl-mode-abbrev-table ())
+
+(defcustom tpl-mode-hook nil
+  "*Hook that runs upon entering tpl-mode."
+  :type 'hook)
+
+(defvar tpl-mode-map nil
+  "Keymap for tpl-mode major mode")
+
+(if tpl-mode-map
+    nil
+  (setq tpl-mode-map (make-sparse-keymap)))
+
+(define-key tpl-mode-map "\t" 'tpl-indent-command)
+(define-key tpl-mode-map "\C-m" 'reindent-then-newline-and-indent)
+(define-key tpl-mode-map "\C-ct" 'tpl-insert-tag)
+(define-key tpl-mode-map "\C-cv" 'tpl-insert-variable)
+(define-key tpl-mode-map "\C-cs" 'tpl-insert-section)
+
+
+(defvar tpl-mode-syntax-table nil
+  "Syntax table in use in tpl-mode buffers.")
+
+;; Syntax table.
+(if tpl-mode-syntax-table
+    nil
+  (setq tpl-mode-syntax-table (make-syntax-table text-mode-syntax-table))
+  (modify-syntax-entry ?<  "(>  " tpl-mode-syntax-table)
+  (modify-syntax-entry ?>  ")<  " tpl-mode-syntax-table)
+  (modify-syntax-entry ?\" ".   " tpl-mode-syntax-table)
+  (modify-syntax-entry ?\\ ".   " tpl-mode-syntax-table)
+  (modify-syntax-entry ?'  "w   " tpl-mode-syntax-table))
+
+(defvar tpl-basic-offset 2
+  "The basic indentation offset.")
+
+;; Constant regular expressions to identify template elements.
+(defconst tpl-mode-tpl-token "[a-zA-Z_][a-zA-Z0-9_:=\?!-]*?")
+(defconst tpl-mode-section (concat "\\({{[#^/]\s*"
+                                   tpl-mode-tpl-token
+                                   "\s*}}\\)"))
+(defconst tpl-mode-open-section (concat "\\({{#\s*"
+                                        tpl-mode-tpl-token
+                                        "\s*}}\\)"))
+(defconst tpl-mode-close-section (concat "{{/\\(\s*"
+                                         tpl-mode-tpl-token
+                                         "\s*\\)}}"))
+;; TODO(tonyg) Figure out a way to support multiline comments.
+(defconst tpl-mode-comment "\\({{!.*?}}\\)")
+(defconst tpl-mode-include (concat "\\({{[><]\s*"
+                                   tpl-mode-tpl-token
+                                   "\s*}}\\)"))
+(defconst tpl-mode-variable (concat "\\({{\s*"
+                                    tpl-mode-tpl-token
+                                    "\s*}}\\)"))
+(defconst tpl-mode-builtins
+  (concat
+   "\\({{\\<\s*"
+   (regexp-opt
+    '("BI_NEWLINE" "BI_SPACE")
+    t)
+   "\s*\\>}}\\)"))
+(defconst tpl-mode-close-section-at-start (concat "^[ \t]*?"
+                                                  tpl-mode-close-section))
+
+;; Constant regular expressions to identify html tags.
+;; Taken from HTML 4.01 / XHTML 1.0 Reference found at:
+;; http://www.w3schools.com/tags/default.asp.
+(defconst tpl-mode-html-constant "\\(&#?[a-z0-9]\\{2,5\\};\\)")
+(defconst tpl-mode-pair-tag
+  (concat
+   "\\<"
+   (regexp-opt
+    '("a" "abbr" "acronym" "address" "applet" "area" "b" "bdo"
+      "big" "blockquote" "body" "button" "caption" "center" "cite"
+      "code" "col" "colgroup" "dd" "del" "dfn" "dif" "div" "dl"
+      "dt" "em" "fieldset" "font" "form" "frame" "frameset" "h1"
+      "h2" "h3" "h4" "h5" "h6" "head" "html" "i" "iframe" "ins"
+      "kbd" "label" "legend" "li" "link" "map" "menu" "noframes"
+      "noscript" "object" "ol" "optgroup" "option" "p" "pre" "q"
+      "s" "samp" "script" "select" "small" "span" "strike"
+      "strong" "style" "sub" "sup" "table" "tbody" "td" "textarea"
+      "tfoot" "th" "thead" "title" "tr" "tt" "u" "ul" "var")
+    t)
+   "\\>"))
+(defconst tpl-mode-standalone-tag
+  (concat
+   "\\<"
+   (regexp-opt
+    '("base" "br" "hr" "img" "input" "meta" "param")
+    t)
+   "\\>"))
+(defconst tpl-mode-open-tag (concat "<\\("
+                                    tpl-mode-pair-tag
+                                    "\\)"))
+(defconst tpl-mode-close-tag (concat "</\\("
+                                     tpl-mode-pair-tag
+                                     "\\)>"))
+(defconst tpl-mode-close-tag-at-start (concat "^[ \t]*?"
+                                              tpl-mode-close-tag))
+
+(defconst tpl-mode-blank-line "^[ \t]*?$")
+(defconst tpl-mode-dangling-open (concat "\\("
+                                         tpl-mode-open-section
+                                         "\\)\\|\\("
+                                         tpl-mode-open-tag
+                                         "\\)[^/]*$"))
+
+(defun tpl-indent-command ()
+  "Command for indenting text. Just calls tpl-indent."
+  (interactive)
+  (tpl-indent))
+
+(defun tpl-insert-tag (tag)
+  "Inserts an HTML tag."
+  (interactive "sTag: ")
+  (tpl-indent)
+  (insert (concat "<" tag ">"))
+  (insert "\n\n")
+  (insert (concat "</" tag ">"))
+  (tpl-indent)
+  (forward-line -1)
+  (tpl-indent))
+
+(defun tpl-insert-variable (variable)
+  "Inserts a tpl variable."
+  (interactive "sVariable: ")
+  (insert (concat "{{" variable "}}")))
+
+(defun tpl-insert-section (section)
+  "Inserts a tpl section."
+  (interactive "sSection: ")
+  (tpl-indent)
+  (insert (concat "{{#" section "}}\n"))
+  (insert "\n")
+  (insert (concat "{{/" section "}}"))
+  (tpl-indent)
+  (forward-line -1)
+  (tpl-indent))
+
+;; Function to control indenting.
+(defun tpl-indent ()
+  "Indent current line"
+  ;; Set the point to beginning of line.
+  (beginning-of-line)
+  ;; If we are at the beginning of the file, indent to 0.
+  (if (bobp)
+      (indent-line-to 0)
+    (let ((tag-stack 1) (close-tag "") (cur-indent 0) (old-pnt (point-marker))
+          (close-at-start) (open-token) (dangling-open))
+      (progn
+        ;; Determine if this is a template line or an html line.
+        (if (looking-at "^[ \t]*?{{")
+            (setq close-at-start tpl-mode-close-section-at-start
+                  open-token "{{#")
+          (setq close-at-start tpl-mode-close-tag-at-start
+                open-token "<"))
+        ;; If there is a closing tag at the start of the line, search back
+        ;; for its opener and indent to that level.
+        (if (looking-at close-at-start)
+            (progn
+              (save-excursion
+                (setq close-tag (match-string 1))
+                ;; Keep searching for a match for the close tag until
+                ;; the tag-stack is 0.
+                (while (and (not (bobp))
+                            (> tag-stack 0)
+                            (re-search-backward (concat open-token
+                                                        "\\(/?\\)"
+                                                        close-tag) nil t))
+                  (if (string-equal (match-string 1) "/")
+                      ;; We found another close tag, so increment tag-stack.
+                      (setq tag-stack (+ tag-stack 1))
+                    ;; We found an open tag, so decrement tag-stack.
+                    (setq tag-stack (- tag-stack 1)))
+                  (setq cur-indent (current-indentation))))
+              (if (> tag-stack 0)
+                  (save-excursion
+                    (forward-line -1)
+                    (setq cur-indent (current-indentation)))))
+          ;; This was not a closing tag, so we check if the previous line
+          ;; was an opening tag.
+          (save-excursion
+            ;; Keep moving back until we find a line that is not blank
+            (while (progn
+                     (forward-line -1)
+                     (and (not (bobp)) (looking-at tpl-mode-blank-line))))
+            (setq cur-indent (current-indentation))
+            (if (re-search-forward tpl-mode-dangling-open old-pnt t)
+                (setq cur-indent (+ cur-indent tpl-basic-offset)))))
+        ;; Finally, we execute the actual indentation.
+        (if (> cur-indent 0)
+            (indent-line-to cur-indent)
+          (indent-line-to 0))))))
+
+;; controls highlighting
+(defconst tpl-mode-font-lock-keywords
+  (list
+   (list tpl-mode-section
+         '(1 font-lock-keyword-face))
+   (list tpl-mode-comment
+         '(1 font-lock-comment-face))
+   (list tpl-mode-include
+         '(1 font-lock-function-name-face))
+   (list tpl-mode-builtins
+         '(1 font-lock-variable-name-face))
+   (list tpl-mode-variable
+         '(1 font-lock-reference-face))
+   (list (concat "</?\\(" tpl-mode-pair-tag "\\)")
+         '(1 font-lock-function-name-face))
+   (list (concat "<\\(" tpl-mode-standalone-tag "\\)")
+         '(1 font-lock-function-name-face))
+   (list tpl-mode-html-constant
+         '(1 font-lock-variable-name-face))))
+
+(put 'tpl-mode 'font-lock-defaults '(tpl-font-lock-keywords nil t))
+
+(defun tpl-mode ()
+  "Major mode for editing Google CTemplate file."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map tpl-mode-map)
+  (setq major-mode 'tpl-mode)
+  (setq mode-name "tpl-mode")
+  (setq local-abbrev-table tpl-mode-abbrev-table)
+  (setq indent-tabs-mode nil)
+  (set-syntax-table tpl-mode-syntax-table)
+  ;; show trailing whitespace, but only when the user can fix it
+  (setq show-trailing-whitespace (not buffer-read-only))
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'tpl-indent)
+  (setq font-lock-defaults '(tpl-mode-font-lock-keywords))
+  (run-hooks 'tpl-mode-hook))
+
+;; Automatically load tpl-mode for .mustache files.
+(add-to-list 'auto-mode-alist '("\\.mustache$" . tpl-mode))
+(add-hook 'tpl-mode-hook '(lambda () (font-lock-mode 1)))
+
+(provide 'mustache-mode)