km-psych 0.1.0

data/ext/psych/to_ruby.h

@@ -0,0 +1,8 @@
+#ifndef PSYCH_TO_RUBY_H
+#define PSYCH_TO_RUBY_H
+
+#include <psych.h>
+
+void Init_psych_to_ruby(void);
+
+#endif

data/ext/psych/yaml_tree.c

@@ -0,0 +1,24 @@
+#include <psych.h>
+
+VALUE cPsychVisitorsYamlTree;
+
+/*
+ * call-seq: private_iv_get(target, prop)
+ *
+ * Get the private instance variable +prop+ from +target+
+ */
+static VALUE private_iv_get(VALUE self, VALUE target, VALUE prop)
+{
+    return rb_attr_get(target, rb_intern(StringValuePtr(prop)));
+}
+
+void Init_psych_yaml_tree(void)
+{
+    VALUE psych     = rb_define_module("Psych");
+    VALUE visitors  = rb_define_module_under(psych, "Visitors");
+    VALUE visitor   = rb_define_class_under(visitors, "Visitor", rb_cObject);
+    cPsychVisitorsYamlTree = rb_define_class_under(visitors, "YAMLTree", visitor);
+
+    rb_define_private_method(cPsychVisitorsYamlTree, "private_iv_get", private_iv_get, 2);
+}
+/* vim: set noet sws=4 sw=4: */

data/ext/psych/yaml_tree.h

@@ -0,0 +1,8 @@
+#ifndef PSYCH_YAML_TREE_H
+#define PSYCH_YAML_TREE_H
+
+#include <psych.h>
+
+void Init_psych_yaml_tree(void);
+
+#endif

data/lib/km-psych.rb

@@ -0,0 +1,244 @@
+require 'psych.so'
+require 'psych/nodes'
+require 'psych/visitors'
+require 'psych/handler'
+require 'psych/tree_builder'
+require 'psych/parser'
+require 'psych/omap'
+require 'psych/set'
+require 'psych/coder'
+require 'psych/core_ext'
+require 'psych/deprecated'
+
+###
+# = Overview
+#
+# Psych is a YAML parser and emitter.  Psych leverages
+# libyaml[http://libyaml.org] for it's YAML parsing and emitting capabilities.
+# In addition to wrapping libyaml, Psych also knows how to serialize and
+# de-serialize most Ruby objects to and from the YAML format.
+#
+# = I NEED TO PARSE OR EMIT YAML RIGHT NOW!
+#
+#   # Parse some YAML
+#   Psych.load("--- foo") # => "foo"
+#
+#   # Emit some YAML
+#   Psych.dump("foo")     # => "--- foo\n...\n"
+#   { :a => 'b'}.to_yaml  # => "---\n:a: b\n"
+#
+# Got more time on your hands?  Keep on reading!
+#
+# == YAML Parsing
+#
+# Psych provides a range of interfaces for parsing a YAML document ranging from
+# low level to high level, depending on your parsing needs.  At the lowest
+# level, is an event based parser.  Mid level is access to the raw YAML AST,
+# and at the highest level is the ability to unmarshal YAML to ruby objects.
+#
+# === Low level parsing
+#
+# The lowest level parser should be used when the YAML input is already known,
+# and the developer does not want to pay the price of building an AST or
+# automatic detection and conversion to ruby objects.  See Psych::Parser for
+# more information on using the event based parser.
+#
+# === Mid level parsing
+#
+# Psych provides access to an AST produced from parsing a YAML document.  This
+# tree is built using the Psych::Parser and Psych::TreeBuilder.  The AST can
+# be examined and manipulated freely.  Please see Psych::parse_stream,
+# Psych::Nodes, and Psych::Nodes::Node for more information on dealing with
+# YAML syntax trees.
+#
+# === High level parsing
+#
+# The high level YAML parser provided by Psych simply takes YAML as input and
+# returns a Ruby data structure.  For information on using the high level parser
+# see Psych.load
+#
+# == YAML Emitting
+#
+# Psych provides a range of interfaces ranging from low to high level for
+# producing YAML documents.  Very similar to the YAML parsing interfaces, Psych
+# provides at the lowest level, an event based system, mid-level is building
+# a YAML AST, and the highest level is converting a Ruby object straight to
+# a YAML document.
+#
+# === Low level emitting
+#
+# The lowest level emitter is an event based system.  Events are sent to a
+# Psych::Emitter object.  That object knows how to convert the events to a YAML
+# document.  This interface should be used when document format is known in
+# advance or speed is a concern.  See Psych::Emitter for more information.
+#
+# === Mid level emitting
+#
+# At the mid level is building an AST.  This AST is exactly the same as the AST
+# used when parsing a YAML document.  Users can build an AST by hand and the
+# AST knows how to emit itself as a YAML document.  See Psych::Nodes,
+# Psych::Nodes::Node, and Psych::TreeBuilder for more information on building
+# a YAML AST.
+#
+# === High level emitting
+#
+# The high level emitter has the easiest interface.  Psych simply takes a Ruby
+# data structure and converts it to a YAML document.  See Psych.dump for more
+# information on dumping a Ruby data structure.
+
+module Psych
+  # The version is Psych you're using
+  VERSION         = '1.0.0'
+
+  # The version of libyaml Psych is using
+  LIBYAML_VERSION = Psych.libyaml_version.join '.'
+
+  class Exception < RuntimeError
+  end
+
+  autoload :Stream, 'psych/stream'
+  autoload :JSON, 'psych/json'
+
+  ###
+  # Load +yaml+ in to a Ruby data structure.  If multiple documents are
+  # provided, the object contained in the first document will be returned.
+  #
+  # Example:
+  #
+  #   Psych.load("--- a")           # => 'a'
+  #   Psych.load("---\n - a\n - b") # => ['a', 'b']
+  def self.load yaml
+    result = parse(yaml)
+    result ? result.to_ruby : result
+  end
+
+  ###
+  # Parse a YAML string in +yaml+.  Returns the first object of a YAML AST.
+  #
+  # Example:
+  #
+  #   Psych.parse("---\n - a\n - b") # => #<Psych::Nodes::Sequence:0x00>
+  #
+  # See Psych::Nodes for more information about YAML AST.
+  def self.parse yaml
+    children = parse_stream(yaml).children
+    children.empty? ? false : children.first.children.first
+  end
+
+  ###
+  # Parse a file at +filename+. Returns the YAML AST.
+  def self.parse_file filename
+    File.open filename do |f|
+      parse f
+    end
+  end
+
+  ###
+  # Returns a default parser
+  def self.parser
+    Psych::Parser.new(TreeBuilder.new)
+  end
+
+  ###
+  # Parse a YAML string in +yaml+.  Returns the full AST for the YAML document.
+  # This method can handle multiple YAML documents contained in +yaml+.
+  #
+  # Example:
+  #
+  #   Psych.parse_stream("---\n - a\n - b") # => #<Psych::Nodes::Stream:0x00>
+  #
+  # See Psych::Nodes for more information about YAML AST.
+  def self.parse_stream yaml
+    parser = self.parser
+    parser.parse yaml
+    parser.handler.root
+  end
+
+  ###
+  # Dump Ruby object +o+ to a YAML string using +options+.
+  #
+  # Example:
+  #
+  #   Psych.dump(['a', 'b'])  # => "---\n- a\n- b\n"
+  def self.dump o, io = nil, options = {}
+    if Hash === io
+      options = io
+      io      = nil
+    end
+
+    visitor = Psych::Visitors::YAMLTree.new options
+    visitor << o
+    visitor.tree.to_yaml io
+  end
+
+  ###
+  # Dump a list of objects as separate documents to a document stream.
+  #
+  # Example:
+  #
+  #   Psych.dump_stream("foo\n  ", {}) # => "--- ! \"foo\\n  \"\n--- {}\n"
+  def self.dump_stream *objects
+    visitor = Psych::Visitors::YAMLTree.new {}
+    objects.each do |o|
+      visitor << o
+    end
+    visitor.tree.to_yaml
+  end
+
+  ###
+  # Dump Ruby object +o+ to a JSON string.
+  def self.to_json o
+    visitor = Psych::Visitors::JSONTree.new
+    visitor << o
+    visitor.tree.to_yaml
+  end
+
+  ###
+  # Load multiple documents given in +yaml+.  Returns the parsed documents
+  # as a list.  For example:
+  #
+  #   Psych.load_stream("--- foo\n...\n--- bar\n...") # => ['foo', 'bar']
+  #
+  def self.load_stream yaml
+    parse_stream(yaml).children.map { |child| child.to_ruby }
+  end
+
+  ###
+  # Load the document contained in +filename+.  Returns the yaml contained in
+  # +filename+ as a ruby object
+  def self.load_file filename
+    self.load File.open(filename)
+  end
+
+  # :stopdoc:
+  @domain_types = {}
+  def self.add_domain_type domain, type_tag, &block
+    key = ['tag', domain, type_tag].join ':'
+    @domain_types[key] = [key, block]
+    @domain_types["tag:#{type_tag}"] = [key, block]
+  end
+
+  def self.add_builtin_type type_tag, &block
+    domain = 'yaml.org,2002'
+    key = ['tag', domain, type_tag].join ':'
+    @domain_types[key] = [key, block]
+  end
+
+  def self.remove_type type_tag
+    @domain_types.delete type_tag
+  end
+
+  @load_tags = {}
+  @dump_tags = {}
+  def self.add_tag tag, klass
+    @load_tags[tag] = klass
+    @dump_tags[klass] = tag
+  end
+
+  class << self
+    attr_accessor :load_tags
+    attr_accessor :dump_tags
+    attr_accessor :domain_types
+  end
+  # :startdoc:
+end

data/lib/psych/coder.rb

@@ -0,0 +1,86 @@
+module Psych
+  ###
+  # If an object defines +encode_with+, then an instance of Psych::Coder will
+  # be passed to the method when the object is being serialized.  The Coder
+  # automatically assumes a Psych::Nodes::Mapping is being emitted.  Other
+  # objects like Sequence and Scalar may be emitted if +seq=+ or +scalar=+ are
+  # called, respectively.
+  class Coder
+    attr_accessor :tag, :style, :implicit
+    attr_reader   :type, :seq
+
+    def initialize tag
+      @map        = {}
+      @seq        = []
+      @implicit   = false
+      @type       = :map
+      @tag        = tag
+      @style      = Psych::Nodes::Mapping::BLOCK
+      @scalar     = nil
+    end
+
+    def scalar *args
+      if args.length > 0
+        warn "#{caller[0]}: Coder#scalar(a,b,c) is deprecated" if $VERBOSE
+        @tag, @scalar, _ = args
+        @type = :scalar
+      end
+      @scalar
+    end
+
+    # Emit a map.  The coder will be yielded to the block.
+    def map tag = @tag, style = @style
+      @tag   = tag
+      @style = style
+      yield self if block_given?
+      @map
+    end
+
+    # Emit a scalar with +value+ and +tag+
+    def represent_scalar tag, value
+      self.tag    = tag
+      self.scalar = value
+    end
+
+    # Emit a sequence with +list+ and +tag+
+    def represent_seq tag, list
+      @tag = tag
+      self.seq = list
+    end
+
+    # Emit a sequence with +map+ and +tag+
+    def represent_map tag, map
+      @tag = tag
+      self.map = map
+    end
+
+    # Emit a scalar with +value+
+    def scalar= value
+      @type   = :scalar
+      @scalar = value
+    end
+
+    # Emit a map with +value+
+    def map= map
+      @type = :map
+      @map  = map
+    end
+
+    def []= k, v
+      @type = :map
+      @map[k] = v
+    end
+    alias :add :[]=
+
+    def [] k
+      @type = :map
+      @map[k]
+    end
+
+    # Emit a sequence of +list+
+    def seq= list
+      @type = :seq
+      @seq  = list
+    end
+  end
+end

data/lib/psych/core_ext.rb

@@ -0,0 +1,38 @@
+class Object
+  def self.yaml_tag url
+    Psych.add_tag(url, self)
+  end
+
+  # FIXME: rename this to "to_yaml" when syck is removed
+
+  ###
+  # call-seq: to_yaml
+  #
+  # Convert an object to YAML
+  def psych_to_yaml options = {}
+    Psych.dump self, options
+  end
+  remove_method :to_yaml rescue nil
+  alias :to_yaml :psych_to_yaml
+end
+
+class Module
+  def psych_yaml_as url
+    return if caller[0].end_with?('rubytypes.rb')
+    if $VERBOSE
+      warn "#{caller[0]}: yaml_as is deprecated, please use yaml_tag"
+    end
+    Psych.add_tag(url, self)
+  end
+
+  remove_method :yaml_as rescue nil
+  alias :yaml_as :psych_yaml_as
+end
+
+module Kernel
+  def psych_y *objects
+    puts Psych.dump_stream(*objects)
+  end
+  remove_method :y rescue nil
+  alias y psych_y
+end

data/lib/psych/deprecated.rb

@@ -0,0 +1,82 @@
+require 'date'
+
+module Psych
+  DEPRECATED = __FILE__ # :nodoc:
+
+  module DeprecatedMethods # :nodoc:
+    attr_accessor :taguri
+    attr_accessor :to_yaml_style
+  end
+
+  def self.quick_emit thing, opts = {}, &block # :nodoc:
+    warn "#{caller[0]}: YAML.quick_emit is deprecated" if $VERBOSE && !caller[0].start_with?(File.dirname(__FILE__))
+    target = eval 'self', block.binding
+    target.extend DeprecatedMethods
+    metaclass = class << target; self; end
+    metaclass.send(:define_method, :encode_with) do |coder|
+      target.taguri        = coder.tag
+      target.to_yaml_style = coder.style
+      block.call coder
+    end
+    target.psych_to_yaml unless opts[:nodump]
+  end
+
+  def self.load_documents yaml, &block
+    if $VERBOSE
+      warn "#{caller[0]}: load_documents is deprecated, use load_stream"
+    end
+    list = load_stream yaml
+    return list unless block_given?
+    list.each(&block)
+  end
+
+  def self.detect_implicit thing
+    warn "#{caller[0]}: detect_implicit is deprecated" if $VERBOSE
+    return '' unless String === thing
+    return 'null' if '' == thing
+    ScalarScanner.new.tokenize(thing).class.name.downcase
+  end
+
+  def self.add_ruby_type type_tag, &block
+    warn "#{caller[0]}: add_ruby_type is deprecated, use add_domain_type" if $VERBOSE
+    domain = 'ruby.yaml.org,2002'
+    key = ['tag', domain, type_tag].join ':'
+    @domain_types[key] = [key, block]
+  end
+
+  def self.add_private_type type_tag, &block
+    warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE
+    domain = 'x-private'
+    key = [domain, type_tag].join ':'
+    @domain_types[key] = [key, block]
+  end
+
+  def self.tagurize thing
+    warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE
+    return thing unless String === thing
+    "tag:yaml.org,2002:#{thing}"
+  end
+
+  def self.read_type_class type, reference
+    warn "#{caller[0]}: read_type_class is deprecated" if $VERBOSE
+    _, _, type, name = type.split ':', 4
+
+    reference = name.split('::').inject(reference) do |k,n|
+      k.const_get(n.to_sym)
+    end if name
+    [type, reference]
+  end
+
+  def self.object_maker klass, hash
+    warn "#{caller[0]}: object_maker is deprecated" if $VERBOSE
+    klass.allocate.tap do |obj|
+      hash.each { |k,v| obj.instance_variable_set(:"@#{k}", v) }
+    end
+  end
+end
+
+class Object
+  def to_yaml_properties # :nodoc:
+    instance_variables
+  end
+end