sauce_whisk 0.0.1

data/vendor/psych/lib/psych/json/yaml_events.rb

@@ -0,0 +1,29 @@
+module Psych
+  module JSON
+    module YAMLEvents # :nodoc:
+      def start_document version, tag_directives, implicit
+        super(version, tag_directives, !streaming?)
+      end
+
+      def end_document implicit_end = !streaming?
+        super(implicit_end)
+      end
+
+      def start_mapping anchor, tag, implicit, style
+        super(anchor, nil, true, Nodes::Mapping::FLOW)
+      end
+
+      def start_sequence anchor, tag, implicit, style
+        super(anchor, nil, true, Nodes::Sequence::FLOW)
+      end
+
+      def scalar value, anchor, tag, plain, quoted, style
+        if "tag:yaml.org,2002:null" == tag
+          super('null', nil, nil, true, false, Nodes::Scalar::PLAIN)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/alias.rb

@@ -0,0 +1,18 @@
+module Psych
+  module Nodes
+    ###
+    # This class represents a {YAML Alias}[http://yaml.org/spec/1.1/#alias].
+    # It points to an +anchor+.
+    #
+    # A Psych::Nodes::Alias is a terminal node and may have no children.
+    class Alias < Psych::Nodes::Node
+      # The anchor this alias links to
+      attr_accessor :anchor
+
+      # Create a new Alias that points to an +anchor+
+      def initialize anchor
+        @anchor = anchor
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/document.rb

@@ -0,0 +1,60 @@
+module Psych
+  module Nodes
+    ###
+    # This represents a YAML Document.  This node must be a child of
+    # Psych::Nodes::Stream.  A Psych::Nodes::Document must have one child,
+    # and that child may be one of the following:
+    #
+    # * Psych::Nodes::Sequence
+    # * Psych::Nodes::Mapping
+    # * Psych::Nodes::Scalar
+    class Document < Psych::Nodes::Node
+      # The version of the YAML document
+      attr_accessor :version
+
+      # A list of tag directives for this document
+      attr_accessor :tag_directives
+
+      # Was this document implicitly created?
+      attr_accessor :implicit
+
+      # Is the end of the document implicit?
+      attr_accessor :implicit_end
+
+      ###
+      # Create a new Psych::Nodes::Document object.
+      #
+      # +version+ is a list indicating the YAML version.
+      # +tags_directives+ is a list of tag directive declarations
+      # +implicit+ is a flag indicating whether the document will be implicitly
+      # started.
+      #
+      # == Example:
+      # This creates a YAML document object that represents a YAML 1.1 document
+      # with one tag directive, and has an implicit start:
+      #
+      #   Psych::Nodes::Document.new(
+      #     [1,1],
+      #     [["!", "tag:tenderlovemaking.com,2009:"]],
+      #     true
+      #   )
+      #
+      # == See Also
+      # See also Psych::Handler#start_document
+      def initialize version = [], tag_directives = [], implicit = false
+        super()
+        @version        = version
+        @tag_directives = tag_directives
+        @implicit       = implicit
+        @implicit_end   = true
+      end
+
+      ###
+      # Returns the root node.  A Document may only have one root node:
+      # http://yaml.org/spec/1.1/#id898031
+      def root
+        children.first
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/mapping.rb

@@ -0,0 +1,56 @@
+module Psych
+  module Nodes
+    ###
+    # This class represents a {YAML Mapping}[http://yaml.org/spec/1.1/#mapping].
+    #
+    # A Psych::Nodes::Mapping node may have 0 or more children, but must have
+    # an even number of children.  Here are the valid children a
+    # Psych::Nodes::Mapping node may have:
+    #
+    # * Psych::Nodes::Sequence
+    # * Psych::Nodes::Mapping
+    # * Psych::Nodes::Scalar
+    # * Psych::Nodes::Alias
+    class Mapping < Psych::Nodes::Node
+      # Any Map Style
+      ANY   = 0
+
+      # Block Map Style
+      BLOCK = 1
+
+      # Flow Map Style
+      FLOW  = 2
+
+      # The optional anchor for this mapping
+      attr_accessor :anchor
+
+      # The optional tag for this mapping
+      attr_accessor :tag
+
+      # Is this an implicit mapping?
+      attr_accessor :implicit
+
+      # The style of this mapping
+      attr_accessor :style
+
+      ###
+      # Create a new Psych::Nodes::Mapping object.
+      #
+      # +anchor+ is the anchor associated with the map or +nil+.
+      # +tag+ is the tag associated with the map or +nil+.
+      # +implicit+ is a boolean indicating whether or not the map was implicitly
+      # started.
+      # +style+ is an integer indicating the mapping style.
+      #
+      # == See Also
+      # See also Psych::Handler#start_mapping
+      def initialize anchor = nil, tag = nil, implicit = true, style = BLOCK
+        super()
+        @anchor   = anchor
+        @tag      = tag
+        @implicit = implicit
+        @style    = style
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/node.rb

@@ -0,0 +1,55 @@
+require 'stringio'
+require 'psych/class_loader'
+require 'psych/scalar_scanner'
+
+module Psych
+  module Nodes
+    ###
+    # The base class for any Node in a YAML parse tree.  This class should
+    # never be instantiated.
+    class Node
+      include Enumerable
+
+      # The children of this node
+      attr_reader :children
+
+      # An associated tag
+      attr_reader :tag
+
+      # Create a new Psych::Nodes::Node
+      def initialize
+        @children = []
+      end
+
+      ###
+      # Iterate over each node in the tree. Yields each node to +block+ depth
+      # first.
+      def each &block
+        return enum_for :each unless block_given?
+        Visitors::DepthFirst.new(block).accept self
+      end
+
+      ###
+      # Convert this node to Ruby.
+      #
+      # See also Psych::Visitors::ToRuby
+      def to_ruby
+        Visitors::ToRuby.create.accept(self)
+      end
+      alias :transform :to_ruby
+
+      ###
+      # Convert this node to YAML.
+      #
+      # See also Psych::Visitors::Emitter
+      def yaml io = nil, options = {}
+        real_io = io || StringIO.new(''.encode('utf-8'))
+
+        Visitors::Emitter.new(real_io, options).accept self
+        return real_io.string unless io
+        io
+      end
+      alias :to_yaml :yaml
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/scalar.rb

@@ -0,0 +1,67 @@
+module Psych
+  module Nodes
+    ###
+    # This class represents a {YAML Scalar}[http://yaml.org/spec/1.1/#id858081].
+    #
+    # This node type is a terminal node and should not have any children.
+    class Scalar < Psych::Nodes::Node
+      # Any style scalar, the emitter chooses
+      ANY           = 0
+
+      # Plain scalar style
+      PLAIN         = 1
+
+      # Single quoted style
+      SINGLE_QUOTED = 2
+
+      # Double quoted style
+      DOUBLE_QUOTED = 3
+
+      # Literal style
+      LITERAL       = 4
+
+      # Folded style
+      FOLDED        = 5
+
+      # The scalar value
+      attr_accessor :value
+
+      # The anchor value (if there is one)
+      attr_accessor :anchor
+
+      # The tag value (if there is one)
+      attr_accessor :tag
+
+      # Is this a plain scalar?
+      attr_accessor :plain
+
+      # Is this scalar quoted?
+      attr_accessor :quoted
+
+      # The style of this scalar
+      attr_accessor :style
+
+      ###
+      # Create a new Psych::Nodes::Scalar object.
+      #
+      # +value+ is the string value of the scalar
+      # +anchor+ is an associated anchor or nil
+      # +tag+ is an associated tag or nil
+      # +plain+ is a boolean value
+      # +quoted+ is a boolean value
+      # +style+ is an integer idicating the string style
+      #
+      # == See Also
+      #
+      # See also Psych::Handler#scalar
+      def initialize value, anchor = nil, tag = nil, plain = true, quoted = false, style = ANY
+        @value  = value
+        @anchor = anchor
+        @tag    = tag
+        @plain  = plain
+        @quoted = quoted
+        @style  = style
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/sequence.rb

@@ -0,0 +1,81 @@
+module Psych
+  module Nodes
+    ###
+    # This class represents a
+    # {YAML sequence}[http://yaml.org/spec/1.1/#sequence/syntax].
+    #
+    # A YAML sequence is basically a list, and looks like this:
+    #
+    #   %YAML 1.1
+    #   ---
+    #   - I am
+    #   - a Sequence
+    #
+    # A YAML sequence may have an anchor like this:
+    #
+    #   %YAML 1.1
+    #   ---
+    #   &A [
+    #     "This sequence",
+    #     "has an anchor"
+    #   ]
+    #
+    # A YAML sequence may also have a tag like this:
+    #
+    #   %YAML 1.1
+    #   ---
+    #   !!seq [
+    #     "This sequence",
+    #     "has a tag"
+    #   ]
+    #
+    # This class represents a sequence in a YAML document.  A
+    # Psych::Nodes::Sequence node may have 0 or more children.  Valid children
+    # for this node are:
+    #
+    # * Psych::Nodes::Sequence
+    # * Psych::Nodes::Mapping
+    # * Psych::Nodes::Scalar
+    # * Psych::Nodes::Alias
+    class Sequence < Psych::Nodes::Node
+      # Any Styles, emitter chooses
+      ANY   = 0
+
+      # Block style sequence
+      BLOCK = 1
+
+      # Flow style sequence
+      FLOW  = 2
+
+      # The anchor for this sequence (if any)
+      attr_accessor :anchor
+
+      # The tag name for this sequence (if any)
+      attr_accessor :tag
+
+      # Is this sequence started implicitly?
+      attr_accessor :implicit
+
+      # The sequece style used
+      attr_accessor :style
+
+      ###
+      # Create a new object representing a YAML sequence.
+      #
+      # +anchor+ is the anchor associated with the sequence or nil.
+      # +tag+ is the tag associated with the sequence or nil.
+      # +implicit+ a boolean indicating whether or not the sequence was
+      # implicitly started.
+      # +style+ is an integer indicating the list style.
+      #
+      # See Psych::Handler#start_sequence
+      def initialize anchor = nil, tag = nil, implicit = true, style = BLOCK
+        super()
+        @anchor   = anchor
+        @tag      = tag
+        @implicit = implicit
+        @style    = style
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes/stream.rb

@@ -0,0 +1,37 @@
+module Psych
+  module Nodes
+    ###
+    # Represents a YAML stream.  This is the root node for any YAML parse
+    # tree.  This node must have one or more child nodes.  The only valid
+    # child node for a Psych::Nodes::Stream node is Psych::Nodes::Document.
+    class Stream < Psych::Nodes::Node
+
+      # Encodings supported by Psych (and libyaml)
+
+      # Any encoding
+      ANY     = Psych::Parser::ANY
+
+      # UTF-8 encoding
+      UTF8    = Psych::Parser::UTF8
+
+      # UTF-16LE encoding
+      UTF16LE = Psych::Parser::UTF16LE
+
+      # UTF-16BE encoding
+      UTF16BE = Psych::Parser::UTF16BE
+
+      # The encoding used for this stream
+      attr_accessor :encoding
+
+      ###
+      # Create a new Psych::Nodes::Stream node with an +encoding+ that
+      # defaults to Psych::Nodes::Stream::UTF8.
+      #
+      # See also Psych::Handler#start_stream
+      def initialize encoding = UTF8
+        super()
+        @encoding = encoding
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/nodes.rb

@@ -0,0 +1,77 @@
+require 'psych/nodes/node'
+require 'psych/nodes/stream'
+require 'psych/nodes/document'
+require 'psych/nodes/sequence'
+require 'psych/nodes/scalar'
+require 'psych/nodes/mapping'
+require 'psych/nodes/alias'
+
+module Psych
+  ###
+  # = Overview
+  #
+  # When using Psych.load to deserialize a YAML document, the document is
+  # translated to an intermediary AST.  That intermediary AST is then
+  # translated in to a Ruby object graph.
+  #
+  # In the opposite direction, when using Psych.dump, the Ruby object graph is
+  # translated to an intermediary AST which is then converted to a YAML
+  # document.
+  #
+  # Psych::Nodes contains all of the classes that make up the nodes of a YAML
+  # AST.  You can manually build an AST and use one of the visitors (see
+  # Psych::Visitors) to convert that AST to either a YAML document or to a
+  # Ruby object graph.
+  #
+  # Here is an example of building an AST that represents a list with one
+  # scalar:
+  #
+  #   # Create our nodes
+  #   stream = Psych::Nodes::Stream.new
+  #   doc    = Psych::Nodes::Document.new
+  #   seq    = Psych::Nodes::Sequence.new
+  #   scalar = Psych::Nodes::Scalar.new('foo')
+  #
+  #   # Build up our tree
+  #   stream.children << doc
+  #   doc.children    << seq
+  #   seq.children    << scalar
+  #
+  # The stream is the root of the tree.  We can then convert the tree to YAML:
+  #
+  #   stream.to_yaml => "---\n- foo\n"
+  #
+  # Or convert it to Ruby:
+  #
+  #   stream.to_ruby => [["foo"]]
+  #
+  # == YAML AST Requirements
+  #
+  # A valid YAML AST *must* have one Psych::Nodes::Stream at the root.  A
+  # Psych::Nodes::Stream node must have 1 or more Psych::Nodes::Document nodes
+  # as children.
+  #
+  # Psych::Nodes::Document nodes must have one and *only* one child.  That child
+  # may be one of:
+  #
+  # * Psych::Nodes::Sequence
+  # * Psych::Nodes::Mapping
+  # * Psych::Nodes::Scalar
+  #
+  # Psych::Nodes::Sequence and Psych::Nodes::Mapping nodes may have many
+  # children, but Psych::Nodes::Mapping nodes should have an even number of
+  # children.
+  #
+  # All of these are valid children for Psych::Nodes::Sequence and
+  # Psych::Nodes::Mapping nodes:
+  #
+  # * Psych::Nodes::Sequence
+  # * Psych::Nodes::Mapping
+  # * Psych::Nodes::Scalar
+  # * Psych::Nodes::Alias
+  #
+  # Psych::Nodes::Scalar and Psych::Nodes::Alias are both terminal nodes and
+  # should not have any children.
+  module Nodes
+  end
+end

data/vendor/psych/lib/psych/omap.rb

@@ -0,0 +1,4 @@
+module Psych
+  class Omap < ::Hash
+  end
+end

data/vendor/psych/lib/psych/parser.rb

@@ -0,0 +1,51 @@
+module Psych
+  ###
+  # YAML event parser class.  This class parses a YAML document and calls
+  # events on the handler that is passed to the constructor.  The events can
+  # be used for things such as constructing a YAML AST or deserializing YAML
+  # documents.  It can even be fed back to Psych::Emitter to emit the same
+  # document that was parsed.
+  #
+  # See Psych::Handler for documentation on the events that Psych::Parser emits.
+  #
+  # Here is an example that prints out ever scalar found in a YAML document:
+  #
+  #   # Handler for detecting scalar values
+  #   class ScalarHandler < Psych::Handler
+  #     def scalar value, anchor, tag, plain, quoted, style
+  #       puts value
+  #     end
+  #   end
+  #
+  #   parser = Psych::Parser.new(ScalarHandler.new)
+  #   parser.parse(yaml_document)
+  #
+  # Here is an example that feeds the parser back in to Psych::Emitter.  The
+  # YAML document is read from STDIN and written back out to STDERR:
+  #
+  #   parser = Psych::Parser.new(Psych::Emitter.new($stderr))
+  #   parser.parse($stdin)
+  #
+  # Psych uses Psych::Parser in combination with Psych::TreeBuilder to
+  # construct an AST of the parsed YAML document.
+
+  class Parser
+    class Mark < Struct.new(:index, :line, :column)
+    end
+
+    # The handler on which events will be called
+    attr_accessor :handler
+
+    # Set the encoding for this parser to +encoding+
+    attr_writer :external_encoding
+
+    ###
+    # Creates a new Psych::Parser instance with +handler+.  YAML events will
+    # be called on +handler+.  See Psych::Parser for more details.
+
+    def initialize handler = Handler.new
+      @handler = handler
+      @external_encoding = ANY
+    end
+  end
+end

data/vendor/psych/lib/psych/scalar_scanner.rb

@@ -0,0 +1,149 @@
+require 'strscan'
+
+module Psych
+  ###
+  # Scan scalars for built in types
+  class ScalarScanner
+    # Taken from http://yaml.org/type/timestamp.html
+    TIME = /^\d{4}-\d{1,2}-\d{1,2}([Tt]|\s+)\d{1,2}:\d\d:\d\d(\.\d*)?(\s*Z|[-+]\d{1,2}(:\d\d)?)?/
+
+    # Taken from http://yaml.org/type/float.html
+    FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10)
+              |[-+]?[0-9][0-9_,]*(:[0-5]?[0-9])+\.[0-9_]*(?# base 60)
+              |[-+]?\.(inf|Inf|INF)(?# infinity)
+              |\.(nan|NaN|NAN)(?# not a number))$/x
+
+    # Taken from http://yaml.org/type/int.html
+    INTEGER = /^(?:[-+]?0b[0-1_]+          (?# base 2)
+                  |[-+]?0[0-7_]+           (?# base 8)
+                  |[-+]?(?:0|[1-9][0-9_]*) (?# base 10)
+                  |[-+]?0x[0-9a-fA-F_]+    (?# base 16))$/x
+
+    attr_reader :class_loader
+
+    # Create a new scanner
+    def initialize class_loader
+      @string_cache = {}
+      @symbol_cache = {}
+      @class_loader = class_loader
+    end
+
+    # Tokenize +string+ returning the ruby object
+    def tokenize string
+      return nil if string.empty?
+      return string if @string_cache.key?(string)
+      return @symbol_cache[string] if @symbol_cache.key?(string)
+
+      case string
+      # Check for a String type, being careful not to get caught by hash keys, hex values, and
+      # special floats (e.g., -.inf).
+      when /^[^\d\.:-]?[A-Za-z_\s!@#\$%\^&\*\(\)\{\}\<\>\|\/\\~;=]+/
+        if string.length > 5
+          @string_cache[string] = true
+          return string
+        end
+
+        case string
+        when /^[^ytonf~]/i
+          @string_cache[string] = true
+          string
+        when '~', /^null$/i
+          nil
+        when /^(yes|true|on)$/i
+          true
+        when /^(no|false|off)$/i
+          false
+        else
+          @string_cache[string] = true
+          string
+        end
+      when TIME
+        begin
+          parse_time string
+        rescue ArgumentError
+          string
+        end
+      when /^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/
+        require 'date'
+        begin
+          class_loader.date.strptime(string, '%Y-%m-%d')
+        rescue ArgumentError
+          string
+        end
+      when /^\.inf$/i
+        Float::INFINITY
+      when /^-\.inf$/i
+        -Float::INFINITY
+      when /^\.nan$/i
+        Float::NAN
+      when /^:./
+        if string =~ /^:(["'])(.*)\1/
+          @symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
+        else
+          @symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
+        end
+      when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+$/
+        i = 0
+        string.split(':').each_with_index do |n,e|
+          i += (n.to_i * 60 ** (e - 2).abs)
+        end
+        i
+      when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\.[0-9_]*$/
+        i = 0
+        string.split(':').each_with_index do |n,e|
+          i += (n.to_f * 60 ** (e - 2).abs)
+        end
+        i
+      when FLOAT
+        if string == '.'
+          @string_cache[string] = true
+          string
+        else
+          Float(string.gsub(/[,_]|\.$/, ''))
+        end
+      else
+        int = parse_int string.gsub(/[,_]/, '')
+        return int if int
+
+        @string_cache[string] = true
+        string
+      end
+    end
+
+    ###
+    # Parse and return an int from +string+
+    def parse_int string
+      return unless INTEGER === string
+      Integer(string)
+    end
+
+    ###
+    # Parse and return a Time from +string+
+    def parse_time string
+      klass = class_loader.load 'Time'
+
+      date, time = *(string.split(/[ tT]/, 2))
+      (yy, m, dd) = date.split('-').map { |x| x.to_i }
+      md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
+
+      (hh, mm, ss) = md[1].split(':').map { |x| x.to_i }
+      us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1000000
+
+      time = klass.utc(yy, m, dd, hh, mm, ss, us)
+
+      return time if 'Z' == md[3]
+      return klass.at(time.to_i, us) unless md[3]
+
+      tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
+      offset = tz.first * 3600
+
+      if offset < 0
+        offset -= ((tz[1] || 0) * 60)
+      else
+        offset += ((tz[1] || 0) * 60)
+      end
+
+      klass.at((time - offset).to_i, us)
+    end
+  end
+end

data/vendor/psych/lib/psych/set.rb

@@ -0,0 +1,4 @@
+module Psych
+  class Set < ::Hash
+  end
+end