angry_mob_common_targets 0.1.0

data/vendor/mustache/lib/mustache/context.rb

@@ -0,0 +1,108 @@
+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`.
+    def initialize(mustache)
+      @stack = [mustache]
+    end
+
+    # A {{>partial}} tag translates into a call to the context's
+    # `partial` method, which would be this sucker right here.
+    #
+    # 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)
+      # Look for the first Mustache in the stack.
+      mustache = mustache_in_stack
+
+      # Call its `partial` method and render the result.
+      mustache.render(mustache.partial(name), 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.
+    def mustache_in_stack
+      @stack.detect { |frame| frame.is_a?(Mustache) }
+    end
+
+    # Adds a new object to the context's internal stack.
+    #
+    # Returns the Context.
+    def push(new)
+      @stack.unshift(new)
+      self
+    end
+    alias_method :update, :push
+
+    # Removes the most recently added object from the context's
+    # internal stack.
+    #
+    # Returns the Context.
+    def pop
+      @stack.shift
+      self
+    end
+
+    # Can be used to add a value to the context in a hash-like way.
+    #
+    # context[:name] = "Chris"
+    def []=(name, value)
+      push(name => value)
+    end
+
+    # Alias for `fetch`.
+    def [](name)
+      fetch(name, nil)
+    end
+
+    # Do we know about a particular key? In other words, will calling
+    # `context[key]` give us a result that was set. Basically.
+    def has_key?(key)
+      !!fetch(key)
+    rescue ContextMiss
+      false
+    end
+
+    # Similar to Hash#fetch, finds a value by `name` in the context's
+    # stack. You may specify the default return value by passing a
+    # second parameter.
+    #
+    # If no second parameter is passed (or raise_on_context_miss is
+    # set to true), will raise a ContextMiss exception on miss.
+    def fetch(name, default = :__raise)
+      @stack.each do |frame|
+        # Prevent infinite recursion.
+        next if frame == self
+
+        # Is this frame a hash?
+        hash = frame.respond_to?(:has_key?)
+
+        if hash && frame.has_key?(name)
+          return frame[name]
+        elsif hash && frame.has_key?(name.to_s)
+          return frame[name.to_s]
+        elsif !hash && frame.respond_to?(name)
+          return frame.__send__(name)
+        end
+      end
+
+      if default == :__raise || mustache_in_stack.raise_on_context_miss?
+        raise ContextMiss.new("Can't find #{name} in #{@stack.inspect}")
+      else
+        default
+      end
+    end
+  end
+end

data/vendor/mustache/lib/mustache/generator.rb

@@ -0,0 +1,160 @@
+class Mustache
+  # The Generator is in charge of taking an array of Mustache tokens,
+  # usually assembled by the Parser, and generating an interpolatable
+  # Ruby string. This string is considered the "compiled" template
+  # because at that point we're relying on Ruby to do the parsing and
+  # run our code.
+  #
+  # For example, let's take this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # If we run this through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # Now let's hand that to the Generator:
+  #
+  # >> puts Mustache::Generator.new.compile(tokens)
+  # "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  #
+  # You can see the generated Ruby string for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --compile test.mustache
+  #   "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  class Generator
+    # Options are unused for now but may become useful in the future.
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Given an array of tokens, returns an interpolatable Ruby string.
+    def compile(exp)
+      "\"#{compile!(exp)}\""
+    end
+
+    # Given an array of tokens, converts them into Ruby code. In
+    # particular there are three types of expressions we are concerned
+    # with:
+    #
+    #   :multi
+    #     Mixed bag of :static, :mustache, and whatever.
+    #
+    #   :static
+    #     Normal HTML, the stuff outside of {{mustaches}}.
+    #
+    #   :mustache
+    #     Any Mustache tag, from sections to partials.
+    #
+    # To give you an idea of what you'll be dealing with take this
+    # template:
+    #
+    #   Hello {{name}}
+    #   You have just won ${{value}}!
+    #   {{#in_ca}}
+    #   Well, ${{taxed_value}}, after taxes.
+    #   {{/in_ca}}
+    #
+    # If we run this through the Parser, we'll get back this array of
+    # tokens:
+    #
+    #   [:multi,
+    #    [:static, "Hello "],
+    #    [:mustache, :etag, "name"],
+    #    [:static, "\nYou have just won $"],
+    #    [:mustache, :etag, "value"],
+    #    [:static, "!\n"],
+    #    [:mustache,
+    #     :section,
+    #     "in_ca",
+    #     [:multi,
+    #      [:static, "Well, $"],
+    #      [:mustache, :etag, "taxed_value"],
+    #      [:static, ", after taxes.\n"]]]]
+    def compile!(exp)
+      case exp.first
+      when :multi
+        exp[1..-1].map { |e| compile!(e) }.join
+      when :static
+        str(exp[1])
+      when :mustache
+        send("on_#{exp[1]}", *exp[2..-1])
+      else
+        raise "Unhandled exp: #{exp.first}"
+      end
+    end
+
+    # Callback fired when the compiler finds a section token. We're
+    # passed the section name and the array of tokens.
+    def on_section(name, content)
+      # Convert the tokenized content of this section into a Ruby
+      # string we can use.
+      code = compile(content)
+
+      # Compile the Ruby for this section now that we know what's
+      # inside the section.
+      ev(<<-compiled)
+      if v = ctx[#{name.to_sym.inspect}]
+        if v == true
+          #{code}
+        elsif v.is_a?(Proc)
+          v.call(#{code})
+        else
+          # Shortcut when passed non-array
+          v = [v] if v.respond_to?(:has_key?) || !v.respond_to?(:map)
+
+          v.map { |h| ctx.push(h); r = #{code}; ctx.pop; r }.join
+        end
+      end
+      compiled
+    end
+
+    # Fired when we find an inverted section. Just like `on_section`,
+    # we're passed the inverted section name and the array of tokens.
+    def on_inverted_section(name, content)
+      # Convert the tokenized content of this section into a Ruby
+      # string we can use.
+      code = compile(content)
+
+      # Compile the Ruby for this inverted section now that we know
+      # what's inside.
+      ev(<<-compiled)
+      v = ctx[#{name.to_sym.inspect}]
+      if v.nil? || v == false || v.respond_to?(:empty?) && v.empty?
+        #{code}
+      end
+      compiled
+    end
+
+    # Fired when the compiler finds a partial. We want to return code
+    # which calls a partial at runtime instead of expanding and
+    # including the partial's body to allow for recursive partials.
+    def on_partial(name)
+      ev("ctx.partial(#{name.to_sym.inspect})")
+    end
+
+    # An unescaped tag.
+    def on_utag(name)
+      ev("ctx[#{name.to_sym.inspect}]")
+    end
+
+    # An escaped tag.
+    def on_etag(name)
+      ev("CGI.escapeHTML(ctx[#{name.to_sym.inspect}].to_s)")
+    end
+
+    # An interpolation-friendly version of a string, for use within a
+    # Ruby string.
+    def ev(s)
+      "#\{#{s}}"
+    end
+
+    def str(s)
+      s.inspect[1..-2]
+    end
+  end
+end

data/vendor/mustache/lib/mustache/parser.rb

@@ -0,0 +1,230 @@
+require 'strscan'
+
+class Mustache
+  # The Parser is responsible for taking a string template and
+  # converting it into an array of tokens and, really, expressions. It
+  # raises SyntaxError if there is anything it doesn't understand and
+  # knows which sigil corresponds to which tag type.
+  #
+  # For example, given this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # Run through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # You can see the array of tokens for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --tokens test.mustache
+  #   [:multi, [:static, "Hi "], [:mustache, :etag, "thing"], [:static, "!\n"]]
+  class Parser
+    # A SyntaxError is raised when the Parser comes across unclosed
+    # tags, sections, illegal content in tags, or anything of that
+    # sort.
+    class SyntaxError < StandardError
+      def initialize(message, position)
+        @message = message
+        @lineno, @column, @line = position
+        @stripped_line = @line.strip
+        @stripped_column = @column - (@line.size - @line.lstrip.size)
+      end
+
+      def to_s
+        <<-EOF
+#{@message}
+  Line #{@lineno}
+    #{@stripped_line}
+    #{' ' * @stripped_column}^
+EOF
+      end
+    end
+
+    # After these types of tags, all whitespace will be skipped.
+    SKIP_WHITESPACE = [ '#', '^', '/' ]
+
+    # 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 = [ '!', '=' ]
+
+    attr_reader :scanner, :result
+    attr_writer :otag, :ctag
+
+    # Accepts an options hash which does nothing but may be used in
+    # the future.
+    def initialize(options = {})
+      @options = {}
+    end
+
+    # The opening tag delimiter. This may be changed at runtime.
+    def otag
+      @otag ||= '{{'
+    end
+
+    # The closing tag delimiter. This too may be changed at runtime.
+    def ctag
+      @ctag ||= '}}'
+    end
+
+    # Given a string template, returns an array of tokens.
+    def compile(template)
+      if template.respond_to?(:encoding)
+        @encoding = template.encoding
+        template = template.dup.force_encoding("BINARY")
+      else
+        @encoding = nil
+      end
+
+      # Keeps information about opened sections.
+      @sections = []
+      @result = [:multi]
+      @scanner = StringScanner.new(template)
+
+      # Scan until the end of the template.
+      until @scanner.eos?
+        scan_tags || scan_text
+      end
+
+      if !@sections.empty?
+        # We have parsed the whole file, but there's still opened sections.
+        type, pos, result = @sections.pop
+        error "Unclosed section #{type.inspect}", pos
+      end
+
+      @result
+    end
+
+    # Find {{mustaches}} and add them to the @result array.
+    def scan_tags
+      # Scan until we hit an opening delimiter.
+      return unless @scanner.scan(regexp(otag))
+
+      # Since {{= rewrites ctag, we store the ctag which should be used
+      # when parsing this specific tag.
+      current_ctag = self.ctag
+      type = @scanner.scan(/#|\^|\/|=|!|<|>|&|\{/)
+      @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
+
+      # We found {{ but we can't figure out what's going on inside.
+      error "Illegal content in tag" if content.empty?
+
+      # Based on the sigil, do what needs to be done.
+      case type
+      when '#'
+        block = [:multi]
+        @result << [:mustache, :section, content, block]
+        @sections << [content, position, @result]
+        @result = block
+      when '^'
+        block = [:multi]
+        @result << [:mustache, :inverted_section, content, block]
+        @sections << [content, position, @result]
+        @result = block
+      when '/'
+        section, pos, result = @sections.pop
+        @result = result
+
+        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]
+      when '{', '&'
+        # The closing } in unescaped tags is just a hack for
+        # aesthetics.
+        type = "}" if type == "{"
+        @result << [:mustache, :utag, content]
+      else
+        @result << [:mustache, :etag, content]
+      end
+
+      # 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
+
+      # Skip whitespace following this tag if we need to.
+      @scanner.skip(/\s+/) if SKIP_WHITESPACE.include?(type)
+    end
+
+    # Try to find static text, e.g. raw HTML with no {{mustaches}}.
+    def scan_text
+      text = scan_until_exclusive(regexp(otag))
+
+      if text.nil?
+        # Couldn't find any otag, which means the rest is just static text.
+        text = @scanner.rest
+        # Mark as done.
+        @scanner.clear
+      end
+
+      text.force_encoding(@encoding) if @encoding
+
+      @result << [:static, text]
+    end
+
+    # Scans the string until the pattern is matched. Returns the substring
+    # *excluding* the end of the match, advancing the scan pointer to that
+    # location. If there is no match, nil is returned.
+    def scan_until_exclusive(regexp)
+      pos = @scanner.pos
+      if @scanner.scan_until(regexp)
+        @scanner.pos -= @scanner.matched.size
+        @scanner.pre_match[pos..-1]
+      end
+    end
+
+    # Returns [lineno, column, line]
+    def position
+      # The rest of the current line
+      rest = @scanner.check_until(/\n|\Z/).to_s.chomp
+
+      # What we have parsed so far
+      parsed = @scanner.string[0...@scanner.pos]
+
+      lines = parsed.split("\n")
+
+      [ lines.size, lines.last.size - 1, lines.last + rest ]
+    end
+
+    # Used to quickly convert a string into a regular expression
+    # usable by the string scanner.
+    def regexp(thing)
+      /#{Regexp.escape(thing)}/
+    end
+
+    # Raises a SyntaxError. The message should be the name of the
+    # error - other details such as line number and position are
+    # handled for you.
+    def error(message, pos = position)
+      raise SyntaxError.new(message, pos)
+    end
+  end
+end