sauce_whisk 0.0.1

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

@@ -0,0 +1,37 @@
+module Psych
+  ###
+  # Psych::Stream is a streaming YAML emitter.  It will not buffer your YAML,
+  # but send it straight to an IO.
+  #
+  # Here is an example use:
+  #
+  #   stream = Psych::Stream.new($stdout)
+  #   stream.start
+  #   stream.push({:foo => 'bar'})
+  #   stream.finish
+  #
+  # YAML will be immediately emitted to $stdout with no buffering.
+  #
+  # Psych::Stream#start will take a block and ensure that Psych::Stream#finish
+  # is called, so you can do this form:
+  #
+  #   stream = Psych::Stream.new($stdout)
+  #   stream.start do |em|
+  #     em.push(:foo => 'bar')
+  #   end
+  #
+  class Stream < Psych::Visitors::YAMLTree
+    class Emitter < Psych::Emitter # :nodoc:
+      def end_document implicit_end = !streaming?
+        super
+      end
+
+      def streaming?
+        true
+      end
+    end
+
+    include Psych::Streaming
+    extend Psych::Streaming::ClassMethods
+  end
+end

data/vendor/psych/lib/psych/streaming.rb

@@ -0,0 +1,27 @@
+module Psych
+  module Streaming
+    module ClassMethods
+      ###
+      # Create a new streaming emitter.  Emitter will print to +io+.  See
+      # Psych::Stream for an example.
+      def new io
+        emitter      = const_get(:Emitter).new(io)
+        class_loader = ClassLoader.new
+        ss           = ScalarScanner.new class_loader
+        super(emitter, ss, {})
+      end
+    end
+
+    ###
+    # Start streaming using +encoding+
+    def start encoding = Nodes::Stream::UTF8
+      super.tap { yield self if block_given?  }
+    ensure
+      finish if block_given?
+    end
+
+    private
+    def register target, obj
+    end
+  end
+end

data/vendor/psych/lib/psych/syntax_error.rb

@@ -0,0 +1,21 @@
+require 'psych/exception'
+
+module Psych
+  class SyntaxError < Psych::Exception
+    attr_reader :file, :line, :column, :offset, :problem, :context
+
+    def initialize file, line, col, offset, problem, context
+      err      = [problem, context].compact.join ' '
+      filename = file || '<unknown>'
+      message  = "(%s): %s at line %d column %d" % [filename, err, line, col]
+
+      @file    = file
+      @line    = line
+      @column  = col
+      @offset  = offset
+      @problem = problem
+      @context = context
+      super(message)
+    end
+  end
+end

data/vendor/psych/lib/psych/tree_builder.rb

@@ -0,0 +1,96 @@
+require 'psych/handler'
+
+module Psych
+  ###
+  # This class works in conjunction with Psych::Parser to build an in-memory
+  # parse tree that represents a YAML document.
+  #
+  # == Example
+  #
+  #   parser = Psych::Parser.new Psych::TreeBuilder.new
+  #   parser.parse('--- foo')
+  #   tree = parser.handler.root
+  #
+  # See Psych::Handler for documentation on the event methods used in this
+  # class.
+  class TreeBuilder < Psych::Handler
+    # Returns the root node for the built tree
+    attr_reader :root
+
+    # Create a new TreeBuilder instance
+    def initialize
+      @stack = []
+      @last  = nil
+      @root  = nil
+    end
+
+    %w{
+      Sequence
+      Mapping
+    }.each do |node|
+      class_eval %{
+        def start_#{node.downcase}(anchor, tag, implicit, style)
+          n = Nodes::#{node}.new(anchor, tag, implicit, style)
+          @last.children << n
+          push n
+        end
+
+        def end_#{node.downcase}
+          pop
+        end
+      }
+    end
+
+    ###
+    # Handles start_document events with +version+, +tag_directives+,
+    # and +implicit+ styling.
+    #
+    # See Psych::Handler#start_document
+    def start_document version, tag_directives, implicit
+      n = Nodes::Document.new version, tag_directives, implicit
+      @last.children << n
+      push n
+    end
+
+    ###
+    # Handles end_document events with +version+, +tag_directives+,
+    # and +implicit+ styling.
+    #
+    # See Psych::Handler#start_document
+    def end_document implicit_end = !streaming?
+      @last.implicit_end = implicit_end
+      pop
+    end
+
+    def start_stream encoding
+      @root = Nodes::Stream.new(encoding)
+      push @root
+    end
+
+    def end_stream
+      pop
+    end
+
+    def scalar value, anchor, tag, plain, quoted, style
+      s = Nodes::Scalar.new(value,anchor,tag,plain,quoted,style)
+      @last.children << s
+      s
+    end
+
+    def alias anchor
+      @last.children << Nodes::Alias.new(anchor)
+    end
+
+    private
+    def push value
+      @stack.push value
+      @last = value
+    end
+
+    def pop
+      x = @stack.pop
+      @last = @stack.last
+      x
+    end
+  end
+end

data/vendor/psych/lib/psych/visitors/depth_first.rb

@@ -0,0 +1,26 @@
+module Psych
+  module Visitors
+    class DepthFirst < Psych::Visitors::Visitor
+      def initialize block
+        @block = block
+      end
+
+      private
+
+      def nary o
+        o.children.each { |x| visit x }
+        @block.call o
+      end
+      alias :visit_Psych_Nodes_Stream   :nary
+      alias :visit_Psych_Nodes_Document :nary
+      alias :visit_Psych_Nodes_Sequence :nary
+      alias :visit_Psych_Nodes_Mapping  :nary
+
+      def terminal o
+        @block.call o
+      end
+      alias :visit_Psych_Nodes_Scalar :terminal
+      alias :visit_Psych_Nodes_Alias  :terminal
+    end
+  end
+end

data/vendor/psych/lib/psych/visitors/emitter.rb

@@ -0,0 +1,51 @@
+module Psych
+  module Visitors
+    class Emitter < Psych::Visitors::Visitor
+      def initialize io, options = {}
+        opts = [:indentation, :canonical, :line_width].find_all { |opt|
+          options.key?(opt)
+        }
+
+        if opts.empty?
+          @handler = Psych::Emitter.new io
+        else
+          du = Handler::DumperOptions.new
+          opts.each { |option| du.send :"#{option}=", options[option] }
+          @handler = Psych::Emitter.new io, du
+        end
+      end
+
+      def visit_Psych_Nodes_Stream o
+        @handler.start_stream o.encoding
+        o.children.each { |c| accept c }
+        @handler.end_stream
+      end
+
+      def visit_Psych_Nodes_Document o
+        @handler.start_document o.version, o.tag_directives, o.implicit
+        o.children.each { |c| accept c }
+        @handler.end_document o.implicit_end
+      end
+
+      def visit_Psych_Nodes_Scalar o
+        @handler.scalar o.value, o.anchor, o.tag, o.plain, o.quoted, o.style
+      end
+
+      def visit_Psych_Nodes_Sequence o
+        @handler.start_sequence o.anchor, o.tag, o.implicit, o.style
+        o.children.each { |c| accept c }
+        @handler.end_sequence
+      end
+
+      def visit_Psych_Nodes_Mapping o
+        @handler.start_mapping o.anchor, o.tag, o.implicit, o.style
+        o.children.each { |c| accept c }
+        @handler.end_mapping
+      end
+
+      def visit_Psych_Nodes_Alias o
+        @handler.alias o.anchor
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/visitors/json_tree.rb

@@ -0,0 +1,24 @@
+require 'psych/json/ruby_events'
+
+module Psych
+  module Visitors
+    class JSONTree < YAMLTree
+      include Psych::JSON::RubyEvents
+
+      def self.create options = {}
+        emitter = Psych::JSON::TreeBuilder.new
+        class_loader = ClassLoader.new
+        ss           = ScalarScanner.new class_loader
+        new(emitter, ss, options)
+      end
+
+      def accept target
+        if target.respond_to?(:encode_with)
+          dump_coder target
+        else
+          send(@dispatch_cache[target.class], target)
+        end
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/visitors/to_ruby.rb

@@ -0,0 +1,372 @@
+require 'psych/scalar_scanner'
+require 'psych/class_loader'
+require 'psych/exception'
+
+unless defined?(Regexp::NOENCODING)
+  Regexp::NOENCODING = 32
+end
+
+module Psych
+  module Visitors
+    ###
+    # This class walks a YAML AST, converting each node to ruby
+    class ToRuby < Psych::Visitors::Visitor
+      def self.create
+        class_loader = ClassLoader.new
+        scanner      = ScalarScanner.new class_loader
+        new(scanner, class_loader)
+      end
+
+      attr_reader :class_loader
+
+      def initialize ss, class_loader
+        super()
+        @st = {}
+        @ss = ss
+        @domain_types = Psych.domain_types
+        @class_loader = class_loader
+      end
+
+      def accept target
+        result = super
+        return result if @domain_types.empty? || !target.tag
+
+        key = target.tag.sub(/^[!\/]*/, '').sub(/(,\d+)\//, '\1:')
+        key = "tag:#{key}" unless key =~ /^(tag:|x-private)/
+
+        if @domain_types.key? key
+          value, block = @domain_types[key]
+          return block.call value, result
+        end
+
+        result
+      end
+
+      def deserialize o
+        if klass = resolve_class(Psych.load_tags[o.tag])
+          instance = klass.allocate
+
+          if instance.respond_to?(:init_with)
+            coder = Psych::Coder.new(o.tag)
+            coder.scalar = o.value
+            instance.init_with coder
+          end
+
+          return instance
+        end
+
+        return o.value if o.quoted
+        return @ss.tokenize(o.value) unless o.tag
+
+        case o.tag
+        when '!binary', 'tag:yaml.org,2002:binary'
+          o.value.unpack('m').first
+        when /^!(?:str|ruby\/string)(?::(.*))?/, 'tag:yaml.org,2002:str'
+          klass = resolve_class($1)
+          if klass
+            klass.allocate.replace o.value
+          else
+            o.value
+          end
+        when '!ruby/object:BigDecimal'
+          require 'bigdecimal'
+          class_loader.big_decimal._load o.value
+        when "!ruby/object:DateTime"
+          class_loader.date_time
+          require 'date'
+          @ss.parse_time(o.value).to_datetime
+        when "!ruby/object:Complex"
+          class_loader.complex
+          Complex(o.value)
+        when "!ruby/object:Rational"
+          class_loader.rational
+          Rational(o.value)
+        when "!ruby/class", "!ruby/module"
+          resolve_class o.value
+        when "tag:yaml.org,2002:float", "!float"
+          Float(@ss.tokenize(o.value))
+        when "!ruby/regexp"
+          klass = class_loader.regexp
+          o.value =~ /^\/(.*)\/([mixn]*)$/
+          source  = $1
+          options = 0
+          lang    = nil
+          ($2 || '').split('').each do |option|
+            case option
+            when 'x' then options |= Regexp::EXTENDED
+            when 'i' then options |= Regexp::IGNORECASE
+            when 'm' then options |= Regexp::MULTILINE
+            when 'n' then options |= Regexp::NOENCODING
+            else lang = option
+            end
+          end
+          klass.new(*[source, options, lang].compact)
+        when "!ruby/range"
+          klass = class_loader.range
+          args = o.value.split(/([.]{2,3})/, 2).map { |s|
+            accept Nodes::Scalar.new(s)
+          }
+          args.push(args.delete_at(1) == '...')
+          klass.new(*args)
+        when /^!ruby\/sym(bol)?:?(.*)?$/
+          class_loader.symbolize o.value
+        else
+          @ss.tokenize o.value
+        end
+      end
+      private :deserialize
+
+      def visit_Psych_Nodes_Scalar o
+        register o, deserialize(o)
+      end
+
+      def visit_Psych_Nodes_Sequence o
+        if klass = resolve_class(Psych.load_tags[o.tag])
+          instance = klass.allocate
+
+          if instance.respond_to?(:init_with)
+            coder = Psych::Coder.new(o.tag)
+            coder.seq = o.children.map { |c| accept c }
+            instance.init_with coder
+          end
+
+          return instance
+        end
+
+        case o.tag
+        when nil
+          register_empty(o)
+        when '!omap', 'tag:yaml.org,2002:omap'
+          map = register(o, Psych::Omap.new)
+          o.children.each { |a|
+            map[accept(a.children.first)] = accept a.children.last
+          }
+          map
+        when /^!(?:seq|ruby\/array):(.*)$/
+          klass = resolve_class($1)
+          list  = register(o, klass.allocate)
+          o.children.each { |c| list.push accept c }
+          list
+        else
+          register_empty(o)
+        end
+      end
+
+      def visit_Psych_Nodes_Mapping o
+        if Psych.load_tags[o.tag]
+          return revive(resolve_class(Psych.load_tags[o.tag]), o)
+        end
+        return revive_hash({}, o) unless o.tag
+
+        case o.tag
+        when /^!ruby\/struct:?(.*)?$/
+          klass = resolve_class($1) if $1
+
+          if klass
+            s = register(o, klass.allocate)
+
+            members = {}
+            struct_members = s.members.map { |x| class_loader.symbolize x }
+            o.children.each_slice(2) do |k,v|
+              member = accept(k)
+              value  = accept(v)
+              if struct_members.include?(class_loader.symbolize(member))
+                s.send("#{member}=", value)
+              else
+                members[member.to_s.sub(/^@/, '')] = value
+              end
+            end
+            init_with(s, members, o)
+          else
+            klass = class_loader.struct
+            members = o.children.map { |c| accept c }
+            h = Hash[*members]
+            klass.new(*h.map { |k,v|
+              class_loader.symbolize k
+            }).new(*h.map { |k,v| v })
+          end
+
+        when /^!ruby\/object:?(.*)?$/
+          name = $1 || 'Object'
+
+          if name == 'Complex'
+            class_loader.complex
+            h = Hash[*o.children.map { |c| accept c }]
+            register o, Complex(h['real'], h['image'])
+          elsif name == 'Rational'
+            class_loader.rational
+            h = Hash[*o.children.map { |c| accept c }]
+            register o, Rational(h['numerator'], h['denominator'])
+          else
+            obj = revive((resolve_class(name) || class_loader.object), o)
+            obj
+          end
+
+        when /^!(?:str|ruby\/string)(?::(.*))?/, 'tag:yaml.org,2002:str'
+          klass   = resolve_class($1)
+          members = {}
+          string  = nil
+
+          o.children.each_slice(2) do |k,v|
+            key   = accept k
+            value = accept v
+
+            if key == 'str'
+              if klass
+                string = klass.allocate.replace value
+              else
+                string = value
+              end
+              register(o, string)
+            else
+              members[key] = value
+            end
+          end
+          init_with(string, members.map { |k,v| [k.to_s.sub(/^@/, ''),v] }, o)
+        when /^!ruby\/array:(.*)$/
+          klass = resolve_class($1)
+          list  = register(o, klass.allocate)
+
+          members = Hash[o.children.map { |c| accept c }.each_slice(2).to_a]
+          list.replace members['internal']
+
+          members['ivars'].each do |ivar, v|
+            list.instance_variable_set ivar, v
+          end
+          list
+
+        when '!ruby/range'
+          klass = class_loader.range
+          h = Hash[*o.children.map { |c| accept c }]
+          register o, klass.new(h['begin'], h['end'], h['excl'])
+
+        when /^!ruby\/exception:?(.*)?$/
+          h = Hash[*o.children.map { |c| accept c }]
+
+          e = build_exception((resolve_class($1) || class_loader.exception),
+                              h.delete('message'))
+          init_with(e, h, o)
+
+        when '!set', 'tag:yaml.org,2002:set'
+          set = class_loader.psych_set.new
+          @st[o.anchor] = set if o.anchor
+          o.children.each_slice(2) do |k,v|
+            set[accept(k)] = accept(v)
+          end
+          set
+
+        when /^!map:(.*)$/, /^!ruby\/hash:(.*)$/
+          revive_hash resolve_class($1).new, o
+
+        when '!omap', 'tag:yaml.org,2002:omap'
+          map = register(o, class_loader.psych_omap.new)
+          o.children.each_slice(2) do |l,r|
+            map[accept(l)] = accept r
+          end
+          map
+
+        else
+          revive_hash({}, o)
+        end
+      end
+
+      def visit_Psych_Nodes_Document o
+        accept o.root
+      end
+
+      def visit_Psych_Nodes_Stream o
+        o.children.map { |c| accept c }
+      end
+
+      def visit_Psych_Nodes_Alias o
+        @st.fetch(o.anchor) { raise BadAlias, "Unknown alias: #{o.anchor}" }
+      end
+
+      private
+      def register node, object
+        @st[node.anchor] = object if node.anchor
+        object
+      end
+
+      def register_empty object
+        list = register(object, [])
+        object.children.each { |c| list.push accept c }
+        list
+      end
+
+      def revive_hash hash, o
+        @st[o.anchor] = hash if o.anchor
+
+        o.children.each_slice(2) { |k,v|
+          key = accept(k)
+          val = accept(v)
+
+          if key == '<<'
+            case v
+            when Nodes::Alias
+              begin
+                hash.merge! val
+              rescue TypeError
+                hash[key] = val
+              end
+            when Nodes::Sequence
+              begin
+                h = {}
+                val.reverse_each do |value|
+                  h.merge! value
+                end
+                hash.merge! h
+              rescue TypeError
+                hash[key] = val
+              end
+            else
+              hash[key] = val
+            end
+          else
+            hash[key] = val
+          end
+
+        }
+        hash
+      end
+
+      def merge_key hash, key, val
+      end
+
+      def revive klass, node
+        s = klass.allocate
+        @st[node.anchor] = s if node.anchor
+        h = Hash[*node.children.map { |c| accept c }]
+        init_with(s, h, node)
+      end
+
+      def init_with o, h, node
+        c = Psych::Coder.new(node.tag)
+        c.map = h
+
+        if o.respond_to?(:init_with)
+          o.init_with c
+        elsif o.respond_to?(:yaml_initialize)
+          if $VERBOSE
+            warn "Implementing #{o.class}#yaml_initialize is deprecated, please implement \"init_with(coder)\""
+          end
+          o.yaml_initialize c.tag, c.map
+        else
+          h.each { |k,v| o.instance_variable_set(:"@#{k}", v) }
+        end
+        o
+      end
+
+      # Convert +klassname+ to a Class
+      def resolve_class klassname
+        class_loader.load klassname
+      end
+    end
+
+    class NoAliasRuby < ToRuby
+      def visit_Psych_Nodes_Alias o
+        raise BadAlias, "Unknown alias: #{o.anchor}"
+      end
+    end
+  end
+end

data/vendor/psych/lib/psych/visitors/visitor.rb

@@ -0,0 +1,19 @@
+module Psych
+  module Visitors
+    class Visitor
+      def accept target
+        visit target
+      end
+
+      private
+
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+      end
+
+      def visit target
+        send DISPATCH[target.class], target
+      end
+    end
+  end
+end