bahuvrihi-syckle 1.0

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008, Regents of the University of Colorado.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,53 @@
+= {Syckle}[http://bahuvrihi.github.com/syckle]
+
+A sick little syck loader.
+
+== Description
+
+YAML is great and complete, but load relatively slowly in large part because
+it loads everything at once.  In cases where you need to quickly load a
+simple YAML configuration file, the overhead is too much.
+
+Syckle is a very simple syck binding that can load basic ruby types:
+true, false, nil, numbers, strings, symbols, arrays, and hashes.  When
+Syckle.load encounters a more complex object, it autoloads YAML and
+defers to YAML.load.  The result is a quicker-loading, seamless
+alternative to using YAML.
+
+Benchmarks indicate a require + load using Syckle is about 10x faster than
+the same using YAML, entirely due to the require time.
+
+== Usage
+
+Simply require syckle instead of yaml.  YAML will be set for autoloading
+as necessary, and can be required at a later time if necessary (although
+note that using syckle only provides a load-time benefit up until YAML
+is loaded, duh).
+
+  start = Time.now
+  
+  require 'syckle'
+  Syckle.load("key: value")   # => {'key' => 'value'}
+  
+  puts "#{Time.now-start} s"
+
+=== Bugs/Known Issues
+
+- Syckle seems to work on both Ruby 1.8.* and Ruby 1.9.1.  It does not work
+  on JRuby (I don't think JRuby uses syck).  One word of caution, for reasons
+  unknown, an autoloading test under 1.9 was found to hang when written one
+  way and not when written in what looks to be an identical way.  See
+  {syckle_allows_subsequent_autoloads_test.rb}[http://github.com/bahuvrihi/syckle/tree/master/test/syckle_allows_subsequent_autoloads_test.rb]
+
+== Installation
+
+Syckle is available as a gem on GitHub[http://rubyforge.org/projects/tap].  Use:
+
+  % gem install bahuvrihi-syckle
+
+== Info 
+
+Copyright (c) 2008, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/lib/syckle/setup.rb

@@ -0,0 +1,85 @@
+require 'syck'
+
+# unassign YAML
+Syckle = YAML
+Object.send(:remove_const, :YAML)
+
+# setup the load cycle
+$:.unshift File.expand_path(File.dirname(__FILE__))
+autoload(:YAML, "yaml")
+
+# === The cyclical syckle load cycle
+# 
+# Syckle has a tricky require cycle to load syck without affecting YAML
+# autoloading. Normally requiring 'syck' loads the 'syck.bundle'; this 
+# is what happens during the require cycle of YAML itself.  
+# 
+# Syckle requires 'syck' then unshifts the syckle directory to the top of the 
+# load path, so that any subsequent requires of 'syck' will load 'syckle/sick'
+# and not 'syck.bundle' (which has already been loaded).  The result is that 
+# the normal load cycle for yaml, invoked directly or through an autoload,
+# will cause 'syckle/syck' to be required.
+# 
+# Syckle is designed so that 'syckle/syck' tears down Syckle and effectively
+# replaces Syckle.load with YAML.load.  If YAML is loaded before Syckle, the
+# syckle load cycle directly calls 'syckle/syck' and the replacement occurs
+# immediately.
+module Syckle
+  Syck::DefaultResolver.use_types_at(
+    "tag:ruby.yaml.org,2002:symbol" => Symbol,
+    "tag:ruby.yaml.org,2002:sym" => Symbol)
+  SyckleParser = Syck::Parser.new.set_resolver( Syck::DefaultResolver )
+  
+  # Loads the input string as YAML.  If the string has YAML that
+  # is too complex for Syckle, YAML itself is loaded and will be
+  # used to load the string.
+  #
+  # Note that only strings are allowed, IO objects will immediately
+  # trigger YAML loading.
+  def Syckle.load(str)
+    begin
+      raise Syckle::Error unless str.kind_of?(String)
+      yp = SyckleParser.load( str )
+    
+    rescue(Exception)
+      require 'yaml'
+      load(str)
+    end
+  end
+  
+  # Raised to trigger YAML loading for a string that is too complex for Syckle.
+  class Error < StandardError; end
+  
+  class PrivateType
+    
+    # Raises a Syckle::Error on initialization, and thereby triggers YAML
+    # loading.  When YAML is loaded, this method is overridden.
+    def initialize( domain, type, val )
+      raise Syckle::Error
+    end
+  end
+
+  class DomainType
+    
+    # Raises a Syckle::Error on initialization, and thereby triggers YAML
+    # loading.  When YAML is loaded, this method is overridden.
+    def initialize( domain, type, val )
+      raise Syckle::Error
+    end
+  end
+end
+
+class Symbol
+  
+  # Raises a Syckle::Error on errors, and thereby triggers YAML loading.
+  # Otherwise the same as the Symbol.yaml_new defined by YAML itself.  
+  # When YAML is loaded, this method is overridden.
+  def Symbol.yaml_new( klass, tag, val )
+    if String === val
+      val = Syckle::load( val ) if val =~ /\A(["']).*\1\z/
+      val.intern
+    else
+      raise Syckle::Error
+    end
+  end
+end

data/lib/syckle/syck.rb

@@ -0,0 +1,24 @@
+
+# Reassign unassigned YAML constants.  Note that even though
+# PrivateType and DomainType are modified in setup, the changes
+# are effectively rolled back when the rest of YAML is loaded.
+module YAML # :nodoc:
+  unless const_defined?(:Syck)
+    Syck = Syckle::Syck
+    PrivateType = Syckle::PrivateType
+    DomainType = Syckle::DomainType
+    Object = Syckle::Object
+  end
+end if Object.const_defined?(:Syckle)
+
+module Syckle
+  def Syckle.load(io)
+    YAML.load(io)
+  end
+end
+
+# teardown the load cycle
+$:.delete File.expand_path(File.dirname(__FILE__))
+
+# ensure yaml is loaded
+require 'yaml'

data/lib/syckle.rb

@@ -0,0 +1,5 @@
+if Object.const_defined?(:YAML)
+  require 'syckle/syck'
+else
+  require 'syckle/setup'
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: bahuvrihi-syckle
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-22 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- lib/syckle.rb
+- lib/syckle/setup.rb
+- lib/syckle/syck.rb
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://bahuvrihi.github.com/syckle
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- -S
+- -N
+- --title
+- Syckle
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A sick little syck loader.
+test_files: []
+