km-psych 0.1.0

data/lib/psych/stream.rb

@@ -0,0 +1,53 @@
+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
+
+    ###
+    # Create a new streaming emitter.  Emitter will print to +io+.  See
+    # Psych::Stream for an example.
+    def initialize io
+      super({}, self.class.const_get(:Emitter).new(io))
+    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/lib/psych/tree_builder.rb

@@ -0,0 +1,94 @@
+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
+      @last.children << Nodes::Scalar.new(value,anchor,tag,plain,quoted,style)
+    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/lib/psych/visitors.rb

@@ -0,0 +1,5 @@
+require 'psych/visitors/visitor'
+require 'psych/visitors/to_ruby'
+require 'psych/visitors/emitter'
+require 'psych/visitors/yaml_tree'
+require 'psych/visitors/json_tree'

data/lib/psych/visitors/emitter.rb

@@ -0,0 +1,41 @@
+module Psych
+  module Visitors
+    class Emitter < Psych::Visitors::Visitor
+      def initialize io
+        @handler = Psych::Emitter.new io
+      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/lib/psych/visitors/json_tree.rb

@@ -0,0 +1,14 @@
+module Psych
+  module Visitors
+    class JSONTree < YAMLTree
+      def initialize options = {}, emitter = Psych::JSON::TreeBuilder.new
+        super
+      end
+
+      def visit_String o
+        @emitter.scalar o.to_s, nil, nil, false, true, Nodes::Scalar::ANY
+      end
+      alias :visit_Symbol :visit_String
+    end
+  end
+end

data/lib/psych/visitors/to_ruby.rb

@@ -0,0 +1,263 @@
+require 'psych/scalar_scanner'
+
+module Psych
+  module Visitors
+    ###
+    # This class walks a YAML AST, converting each node to ruby
+    class ToRuby < Psych::Visitors::Visitor
+      def initialize
+        super
+        @st = {}
+        @ss = ScalarScanner.new
+        @domain_types = Psych.domain_types
+      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 visit_Psych_Nodes_Scalar o
+        @st[o.anchor] = o.value if o.anchor
+
+        if klass = 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', 'tag:yaml.org,2002:str'
+          o.value
+        when "!ruby/object:DateTime"
+          require 'date'
+          @ss.parse_time(o.value).to_datetime
+        when "!ruby/object:Complex"
+          Complex(o.value)
+        when "!ruby/object:Rational"
+          Rational(o.value)
+        when "tag:yaml.org,2002:float", "!float"
+          Float(@ss.tokenize(o.value))
+        when "!ruby/regexp"
+          o.value =~ /^\/(.*)\/([mix]*)$/
+          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
+            else lang = option
+            end
+          end
+          Regexp.new(*[source, options, lang].compact)
+        when "!ruby/range"
+          args = o.value.split(/([.]{2,3})/, 2).map { |s|
+            accept Nodes::Scalar.new(s)
+          }
+          args.push(args.delete_at(1) == '...')
+          Range.new(*args)
+        when /^!ruby\/sym(bol)?:?(.*)?$/
+          o.value.to_sym
+        else
+          @ss.tokenize o.value
+        end
+      end
+
+      def visit_Psych_Nodes_Sequence o
+        if klass = 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 '!omap', 'tag:yaml.org,2002:omap'
+          map = Psych::Omap.new
+          @st[o.anchor] = map if o.anchor
+          o.children.each { |a|
+            map[accept(a.children.first)] = accept a.children.last
+          }
+          map
+        else
+          list = []
+          @st[o.anchor] = list if o.anchor
+          o.children.each { |c| list.push accept c }
+          list
+        end
+      end
+
+      def visit_Psych_Nodes_Mapping o
+        return revive(Psych.load_tags[o.tag], o) if Psych.load_tags[o.tag]
+
+        case o.tag
+        when '!str', 'tag:yaml.org,2002:str'
+          members = Hash[*o.children.map { |c| accept c }]
+          string = members.delete 'str'
+          init_with(string, members.map { |k,v| [k.to_s.sub(/^@/, ''),v] }, o)
+        when /^!ruby\/struct:?(.*)?$/
+          klass = resolve_class($1)
+
+          if klass
+            s = klass.allocate
+            @st[o.anchor] = s if o.anchor
+
+            members = {}
+            struct_members = s.members.map { |x| x.to_sym }
+            o.children.each_slice(2) do |k,v|
+              member = accept(k)
+              value  = accept(v)
+              if struct_members.include?(member.to_sym)
+                s.send("#{member}=", value)
+              else
+                members[member.to_s.sub(/^@/, '')] = value
+              end
+            end
+            init_with(s, members, o)
+          else
+            members = o.children.map { |c| accept c }
+            h = Hash[*members]
+            Struct.new(*h.map { |k,v| k.to_sym }).new(*h.map { |k,v| v })
+          end
+
+        when '!ruby/range'
+          h = Hash[*o.children.map { |c| accept c }]
+          Range.new(h['begin'], h['end'], h['excl'])
+
+        when /^!ruby\/exception:?(.*)?$/
+          h = Hash[*o.children.map { |c| accept c }]
+
+          e = build_exception((resolve_class($1) || Exception),
+                              h.delete('message'))
+          init_with(e, h, o)
+
+        when '!set', 'tag:yaml.org,2002:set'
+          set = 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 '!ruby/object:Complex'
+          h = Hash[*o.children.map { |c| accept c }]
+          Complex(h['real'], h['image'])
+
+        when '!ruby/object:Rational'
+          h = Hash[*o.children.map { |c| accept c }]
+          Rational(h['numerator'], h['denominator'])
+
+        when /^!ruby\/object:?(.*)?$/
+          name = $1 || 'Object'
+          obj = revive((resolve_class(name) || Object), o)
+          @st[o.anchor] = obj if o.anchor
+          obj
+        else
+          hash = {}
+          @st[o.anchor] = hash if o.anchor
+
+          o.children.each_slice(2) { |k,v|
+            key = accept(k)
+
+            if key == '<<' && Nodes::Alias === v
+              # FIXME: remove this when "<<" syntax is deprecated
+              if $VERBOSE
+                where = caller.find { |x| x !~ /psych/ }
+                warn where
+                warn "\"<<: *#{v.anchor}\" is no longer supported, please switch to \"*#{v.anchor}\""
+              end
+              return accept(v)
+            else
+              hash[key] = accept(v)
+            end
+
+          }
+          hash
+        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[o.anchor]
+      end
+
+      private
+      def revive klass, node
+        s = klass.allocate
+        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
+            "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
+        return nil unless klassname and not klassname.empty?
+
+        name    = klassname
+        retried = false
+
+        begin
+          path2class(name)
+        rescue ArgumentError, NameError => ex
+          unless retried
+            name    = "Struct::#{name}"
+            retried = ex
+            retry
+          end
+          raise retried
+        end
+      end
+    end
+  end
+end