psych 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b60d3bf3233df7c3abe9184e81b79eed85129ba1
-  data.tar.gz: b06bdbf39cd19feaf29b19d5fb49f2d0ae6cfe0e
+  metadata.gz: f2e70b3ff8828fe0241a7047bdd843ad39f669c7
+  data.tar.gz: ec14c0a1d14bb917e2b43701d97c23ff32c037d2
 SHA512:
-  metadata.gz: d9a6914218ecaece3214bb8698a6589bb67b3ded99be295fee23894be97e40dac2c67ca730c4c8c7bf12bc89e68ec7974132adb3a81f6f8f54ae8507fda324a6
-  data.tar.gz: 105c008b421b79781e25f041a4f5d9ddc99fbf79b8a0db1fad1329abee305387fd10156612279daf0bdcaa4baaf1c13382cef0164833ca9e4fc52448e87060c4
+  metadata.gz: 24c746dc58c84d37adf9e1660c002d3882bbd4ae81bf5f800094959593c0b06ca1d246c563e95ed40e4459d3fa179260f8358ce1dd6a57d9b44d2187b8a52401
+  data.tar.gz: 01df0982d787422a5cd43ff68adc5dca474d0e7b5012205095f43ccc04d55c5b80d3f112da68c46617c5b587631307fb1e75e61e6acfafe0cee3f378afa6ab7d

data/.gitignore

@@ -0,0 +1,14 @@
+*.swp
+*.bundle
+*.jar
+*.class
+.mvn
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -4,13 +4,4 @@ rvm:
   - 2.2
   - 2.3.0
   - ruby-head
-  - rbx-2
-before_script:
-  - gem install hoe
-  - gem install rake-compiler
-  - gem install minitest -v '~> 5.0'
-script: rake test
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: rbx-2
+before_install: gem install bundler --no-document

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Mavenfile

@@ -0,0 +1,7 @@
+#-*- mode: ruby -*-
+
+jar 'org.yaml:snakeyaml:${snakeyaml.version}'
+
+plugin :dependency, '2.8', :outputFile => 'pkg/classpath'
+
+# vim: syntax=Ruby

data/Rakefile

@@ -1,123 +1,31 @@
-# -*- ruby -*-
-
-require 'psych'
-require 'rubygems'
-require 'hoe'
-
-def java?
-  RUBY_PLATFORM =~ /java/
-end
-
-class Hoe
-  remove_const :RUBY_FLAGS
-  flags = "-I#{%w(lib ext bin test).join(File::PATH_SEPARATOR)}"
-  flags = "--1.9 " + flags if java?
-  RUBY_FLAGS = flags
-end
-
-gem 'rake-compiler', '>= 0.4.1'
-gem 'minitest', '~> 5.0'
-require "rake/extensiontask"
-
-Hoe.plugin :doofus, :git, :gemspec
-
-$hoe = Hoe.spec 'psych' do
-  license   'MIT'
-  developer 'Aaron Patterson', 'aaron@tenderlovemaking.com'
-
-  self.extra_rdoc_files  = Dir['*.rdoc']
-  self.history_file      = 'CHANGELOG.rdoc'
-  self.readme_file       = 'README.rdoc'
-  self.testlib           = :minitest
-
-  extra_dev_deps << ['rake-compiler', '>= 0.4.1']
-  extra_dev_deps << ['minitest', '~> 5.0']
-
-  self.spec_extras = {
-    :required_ruby_version => '>= 1.9.2'
-  }
-
-  if java?
-    require './lib/psych/versions.rb'
-    extra_deps << ['jar-dependencies', '>= 0.1.7']
-
-    # the jar declaration for jar-dependencies
-    self.spec_extras[ 'requirements' ] = "jar org.yaml:snakeyaml, #{Psych::DEFAULT_SNAKEYAML_VERSION}"
-    self.spec_extras[ 'platform' ] = 'java'
-    # TODO: clean this section up.
-    require "rake/javaextensiontask"
-    Rake::JavaExtensionTask.new("psych", spec) do |ext|
-      require 'maven/ruby/maven'
-      # uses Mavenfile to write classpath into pkg/classpath
-      # and tell maven via system properties the snakeyaml version
-      # this is basically the same as running from the commandline:
-      # rmvn dependency:build-classpath -Dsnakeyaml.version='use version from Psych::DEFAULT_SNAKEYAML_VERSION here'
-      Maven::Ruby::Maven.new.exec( 'dependency:build-classpath', "-Dsnakeyaml.version=#{Psych::DEFAULT_SNAKEYAML_VERSION}", '-Dverbose=true')#, '--quiet' )
-      ext.source_version = '1.7'
-      ext.target_version = '1.7'
-      ext.classpath = File.read('pkg/classpath')
-      ext.ext_dir = 'ext/java'
-    end
-  else
-    self.spec_extras[:extensions] = ["ext/psych/extconf.rb"]
-    Rake::ExtensionTask.new "psych", spec do |ext|
-      ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
-    end
-  end
-end
-
-def gem_build_path
-  File.join 'pkg', $hoe.spec.full_name
-end
-
-def add_file_to_gem relative_path
-  target_path = File.join gem_build_path, relative_path
-  target_dir = File.dirname(target_path)
-  mkdir_p target_dir unless File.directory?(target_dir)
-  rm_f target_path
-  safe_ln relative_path, target_path
-  $hoe.spec.files.concat [relative_path]
-end
-
-if java?
-  task gem_build_path => [:compile] do
-    add_file_to_gem 'lib/psych.jar'
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+if RUBY_PLATFORM =~ /java/
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new("psych") do |ext|
+    require 'maven/ruby/maven'
+    # uses Mavenfile to write classpath into pkg/classpath
+    # and tell maven via system properties the snakeyaml version
+    # this is basically the same as running from the commandline:
+    # rmvn dependency:build-classpath -Dsnakeyaml.version='use version from Psych::DEFAULT_SNAKEYAML_VERSION here'
+    Maven::Ruby::Maven.new.exec( 'dependency:build-classpath', "-Dsnakeyaml.version=#{Psych::DEFAULT_SNAKEYAML_VERSION}", '-Dverbose=true')#, '--quiet' )
+    ext.source_version = '1.7'
+    ext.target_version = '1.7'
+    ext.classpath = File.read('pkg/classpath')
+    ext.ext_dir = 'ext/java'
   end
-end
-
-Hoe.add_include_dirs('.:lib/psych')
-
-task :test => :compile
-
-task :hack_spec do
-  $hoe.spec.extra_rdoc_files.clear
-end
-task 'core:spec' => [:hack_spec, 'gem:spec']
-
-desc "merge psych in to ruby trunk"
-namespace :merge do
-  basedir = File.expand_path File.dirname __FILE__
-  rubydir = File.join ENV['HOME'], 'git', 'ruby'
-  mergedirs = {
-    # From                          # To
-    [basedir, 'ext', 'psych/']  => [rubydir, 'ext', 'psych/'],
-    [basedir, 'lib/']           => [rubydir, 'ext', 'psych', 'lib/'],
-    [basedir, 'test', 'psych/'] => [rubydir, 'test', 'psych/'],
-  }
-
-  rsync = 'rsync -av --exclude lib --exclude ".*" --exclude "*.o" --exclude Makefile --exclude mkmf.log --delete'
-
-  task :to_ruby do
-    mergedirs.each do |from, to|
-      sh "#{rsync} #{File.join(*from)} #{File.join(*to)}"
-    end
-  end
-
-  task :from_ruby do
-    mergedirs.each do |from, to|
-      sh "#{rsync} #{File.join(*to)} #{File.join(*from)}"
-    end
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new("psych") do |ext|
+    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
   end
 end
 
-# vim: syntax=ruby
+task :default => [:compile, :test]

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "psych"
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/ext/java/PsychEmitter.java

@@ -0,0 +1,345 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 1.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2010 Charles O Nutter <headius@headius.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the EPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package org.jruby.ext.psych;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jcodings.Encoding;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.IOOutputStream;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.emitter.Emitter;
+import org.yaml.snakeyaml.emitter.EmitterException;
+import org.yaml.snakeyaml.error.Mark;
+import org.yaml.snakeyaml.events.AliasEvent;
+import org.yaml.snakeyaml.events.DocumentEndEvent;
+import org.yaml.snakeyaml.events.DocumentStartEvent;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.events.ImplicitTuple;
+import org.yaml.snakeyaml.events.MappingEndEvent;
+import org.yaml.snakeyaml.events.MappingStartEvent;
+import org.yaml.snakeyaml.events.ScalarEvent;
+import org.yaml.snakeyaml.events.SequenceEndEvent;
+import org.yaml.snakeyaml.events.SequenceStartEvent;
+import org.yaml.snakeyaml.events.StreamEndEvent;
+import org.yaml.snakeyaml.events.StreamStartEvent;
+
+import static org.jruby.runtime.Visibility.*;
+
+public class PsychEmitter extends RubyObject {
+    public static void initPsychEmitter(Ruby runtime, RubyModule psych) {
+        RubyClass psychHandler = runtime.defineClassUnder("Handler", runtime.getObject(), runtime.getObject().getAllocator(), psych);
+        RubyClass psychEmitter = runtime.defineClassUnder("Emitter", psychHandler, new ObjectAllocator() {
+            public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+                return new PsychEmitter(runtime, klazz);
+            }
+        }, psych);
+
+        psychEmitter.defineAnnotatedMethods(PsychEmitter.class);
+    }
+
+    public PsychEmitter(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    @JRubyMethod(visibility = PRIVATE)
+    public IRubyObject initialize(ThreadContext context, IRubyObject io) {
+        options = new DumperOptions();
+        options.setIndent(2);
+
+        this.io = io;
+
+        return context.nil;
+    }
+
+    @JRubyMethod(visibility = PRIVATE)
+    public IRubyObject initialize(ThreadContext context, IRubyObject io, IRubyObject rbOptions) {
+        IRubyObject width     = rbOptions.callMethod(context, "line_width");
+        IRubyObject canonical = rbOptions.callMethod(context, "canonical");
+        IRubyObject level     = rbOptions.callMethod(context, "indentation");
+
+        options = new DumperOptions();
+
+        options.setCanonical(canonical.isTrue());
+        options.setIndent((int)level.convertToInteger().getLongValue());
+        options.setWidth((int)width.convertToInteger().getLongValue());
+
+        this.io = io;
+
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject start_stream(ThreadContext context, IRubyObject encoding) {
+        if (!(encoding instanceof RubyFixnum)) {
+            throw context.runtime.newTypeError(encoding, context.runtime.getFixnum());
+        }
+
+        initEmitter(context, encoding);
+
+        StreamStartEvent event = new StreamStartEvent(NULL_MARK, NULL_MARK);
+
+        emit(context, event);
+
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject end_stream(ThreadContext context) {
+        StreamEndEvent event = new StreamEndEvent(NULL_MARK, NULL_MARK);
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject start_document(ThreadContext context, IRubyObject _version, IRubyObject tags, IRubyObject implicit) {
+        DumperOptions.Version version = null;
+        boolean implicitBool = implicit.isTrue();
+        Map<String, String> tagsMap = null;
+
+        RubyArray versionAry = _version.convertToArray();
+        if (versionAry.size() == 2) {
+            int versionInt0 = (int)versionAry.eltInternal(0).convertToInteger().getLongValue();
+            int versionInt1 = (int)versionAry.eltInternal(1).convertToInteger().getLongValue();
+
+            if (versionInt0 == 1) {
+                if (versionInt1 == 0) {
+                    version = DumperOptions.Version.V1_0;
+                } else if (versionInt1 == 1) {
+                    version = DumperOptions.Version.V1_1;
+                }
+            }
+            if (version == null) {
+                throw context.runtime.newArgumentError("invalid YAML version: " + versionAry);
+            }
+        }
+
+        RubyArray tagsAry = tags.convertToArray();
+        if (tagsAry.size() > 0) {
+            tagsMap = new HashMap<String, String>(tagsAry.size());
+            for (int i = 0; i < tagsAry.size(); i++) {
+                RubyArray tagsTuple = tagsAry.eltInternal(i).convertToArray();
+                if (tagsTuple.size() != 2) {
+                    throw context.runtime.newRuntimeError("tags tuple must be of length 2");
+                }
+                IRubyObject key = tagsTuple.eltInternal(0);
+                IRubyObject value = tagsTuple.eltInternal(1);
+                tagsMap.put(
+                        key.asJavaString(),
+                        value.asJavaString());
+            }
+        }
+
+        DocumentStartEvent event = new DocumentStartEvent(NULL_MARK, NULL_MARK, !implicitBool, version, tagsMap);
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject end_document(ThreadContext context, IRubyObject implicit) {
+        DocumentEndEvent event = new DocumentEndEvent(NULL_MARK, NULL_MARK, !implicit.isTrue());
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod(required = 6)
+    public IRubyObject scalar(ThreadContext context, IRubyObject[] args) {
+        IRubyObject value = args[0];
+        IRubyObject anchor = args[1];
+        IRubyObject tag = args[2];
+        IRubyObject plain = args[3];
+        IRubyObject quoted = args[4];
+        IRubyObject style = args[5];
+        
+        if (!(value instanceof RubyString)) {
+            throw context.runtime.newTypeError(value, context.runtime.getString());
+        }
+
+        ScalarEvent event = new ScalarEvent(
+                anchor.isNil() ? null : anchor.asJavaString(),
+                tag.isNil() ? null : tag.asJavaString(),
+                new ImplicitTuple(plain.isTrue(),
+                quoted.isTrue()),
+                value.asJavaString(),
+                NULL_MARK,
+                NULL_MARK,
+                SCALAR_STYLES[(int)style.convertToInteger().getLongValue()]);
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod(required = 4)
+    public IRubyObject start_sequence(ThreadContext context, IRubyObject[] args) {
+        IRubyObject anchor = args[0];
+        IRubyObject tag = args[1];
+        IRubyObject implicit = args[2];
+        IRubyObject style = args[3];
+
+        final int SEQUENCE_BLOCK = 1; // see psych/nodes/sequence.rb
+
+        SequenceStartEvent event = new SequenceStartEvent(
+                anchor.isNil() ? null : anchor.asJavaString(),
+                tag.isNil() ? null : tag.asJavaString(),
+                implicit.isTrue(),
+                NULL_MARK,
+                NULL_MARK,
+                SEQUENCE_BLOCK != style.convertToInteger().getLongValue());
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject end_sequence(ThreadContext context) {
+        SequenceEndEvent event = new SequenceEndEvent(NULL_MARK, NULL_MARK);
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod(required = 4)
+    public IRubyObject start_mapping(ThreadContext context, IRubyObject[] args) {
+        IRubyObject anchor = args[0];
+        IRubyObject tag = args[1];
+        IRubyObject implicit = args[2];
+        IRubyObject style = args[3];
+
+        final int MAPPING_BLOCK = 1; // see psych/nodes/mapping.rb
+
+        MappingStartEvent event = new MappingStartEvent(
+                anchor.isNil() ? null : anchor.asJavaString(),
+                tag.isNil() ? null : tag.asJavaString(),
+                implicit.isTrue(),
+                NULL_MARK,
+                NULL_MARK,
+                MAPPING_BLOCK != style.convertToInteger().getLongValue());
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject end_mapping(ThreadContext context) {
+        MappingEndEvent event = new MappingEndEvent(NULL_MARK, NULL_MARK);
+        emit(context, event);
+        return this;
+    }
+    
+    @JRubyMethod
+    public IRubyObject alias(ThreadContext context, IRubyObject anchor) {
+        AliasEvent event = new AliasEvent(anchor.asJavaString(), NULL_MARK, NULL_MARK);
+        emit(context, event);
+        return this;
+    }
+
+    @JRubyMethod(name = "canonical=")
+    public IRubyObject canonical_set(ThreadContext context, IRubyObject canonical) {
+        // TODO: unclear if this affects a running emitter
+        options.setCanonical(canonical.isTrue());
+        return canonical;
+    }
+
+    @JRubyMethod
+    public IRubyObject canonical(ThreadContext context) {
+        // TODO: unclear if this affects a running emitter
+        return context.runtime.newBoolean(options.isCanonical());
+    }
+
+    @JRubyMethod(name = "indentation=")
+    public IRubyObject indentation_set(ThreadContext context, IRubyObject level) {
+        // TODO: unclear if this affects a running emitter
+        options.setIndent((int)level.convertToInteger().getLongValue());
+        return level;
+    }
+
+    @JRubyMethod
+    public IRubyObject indentation(ThreadContext context) {
+        // TODO: unclear if this affects a running emitter
+        return context.runtime.newFixnum(options.getIndent());
+    }
+
+    @JRubyMethod(name = "line_width=")
+    public IRubyObject line_width_set(ThreadContext context, IRubyObject width) {
+        options.setWidth((int)width.convertToInteger().getLongValue());
+        return width;
+    }
+
+    @JRubyMethod
+    public IRubyObject line_width(ThreadContext context) {
+        return context.runtime.newFixnum(options.getWidth());
+    }
+
+    private void emit(ThreadContext context, Event event) {
+        try {
+            if (emitter == null) throw context.runtime.newRuntimeError("uninitialized emitter");
+
+            emitter.emit(event);
+        } catch (IOException ioe) {
+            throw context.runtime.newIOErrorFromException(ioe);
+        } catch (EmitterException ee) {
+            throw context.runtime.newRuntimeError(ee.toString());
+        }
+    }
+
+    private void initEmitter(ThreadContext context, IRubyObject _encoding) {
+        if (emitter != null) throw context.runtime.newRuntimeError("already initialized emitter");
+
+        Encoding encoding = PsychLibrary.YAMLEncoding.values()[(int)_encoding.convertToInteger().getLongValue()].encoding;
+        Charset charset = context.runtime.getEncodingService().charsetForEncoding(encoding);
+
+        emitter = new Emitter(new OutputStreamWriter(new IOOutputStream(io, encoding), charset), options);
+    }
+
+    Emitter emitter;
+    DumperOptions options = new DumperOptions();
+    IRubyObject io;
+
+    private static final Mark NULL_MARK = new Mark(null, 0, 0, 0, null, 0);
+
+    // Map style constants from Psych values (ANY = 0 ... FOLDED = 5)
+    // to SnakeYaml values; see psych/nodes/scalar.rb.
+    private static final Character[] SCALAR_STYLES = new Character[] {
+        null, // ANY; we'll choose plain
+        null, // PLAIN
+        '\'', // SINGLE_QUOTED
+        '"',  // DOUBLE_QUOTED
+        '|',  // LITERAL
+        '>',  // FOLDED
+    };
+}