benschwarz-smoke 0.5.7 → 0.5.8

data/vendor/gems/gems/json-1.1.3/ext/json/ext/parser/unicode.c

@@ -1,154 +0,0 @@
-#include "unicode.h"
-
-/*
- * Copyright 2001-2004 Unicode, Inc.
- * 
- * Disclaimer
- * 
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- * 
- * Limitations on Rights to Redistribute This Code
- * 
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
-/*
- * Index into the table below with the first byte of a UTF-8 sequence to
- * get the number of trailing bytes that are supposed to follow it.
- * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
- * left as-is for anyone who may want to do such conversion, which was
- * allowed in earlier algorithms.
- */
-static const char trailingBytesForUTF8[256] = {
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
-};
-
-/*
- * Magic values subtracted from a buffer value during UTF8 conversion.
- * This table contains as many values as there might be trailing bytes
- * in a UTF-8 sequence.
- */
-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
-             0x03C82080UL, 0xFA082080UL, 0x82082080UL };
-
-/*
- * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
- * into the first byte, depending on how many bytes follow.  There are
- * as many entries in this table as there are UTF-8 sequence types.
- * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
- * for *legal* UTF-8 will be 4 or fewer bytes total.
- */
-static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-char *JSON_convert_UTF16_to_UTF8 (
-        VALUE buffer,
-        char *source,
-        char *sourceEnd,
-        ConversionFlags flags)
-{
-    UTF16 *tmp, *tmpPtr, *tmpEnd;
-    char buf[5];
-    long n = 0, i;
-    char *p = source - 1;
-
-    while (p < sourceEnd && p[0] == '\\' && p[1] == 'u') {
-        p += 6;
-        n++;
-    }
-    p = source + 1;
-    buf[4] = 0;
-    tmpPtr = tmp = ALLOC_N(UTF16, n);
-    tmpEnd = tmp + n;
-    for (i = 0; i < n; i++) {
-        buf[0] = *p++;
-        buf[1] = *p++;
-        buf[2] = *p++;
-        buf[3] = *p++;
-        tmpPtr[i] = strtol(buf, NULL, 16);
-        p += 2;
-    }
-
-    while (tmpPtr < tmpEnd) {
-        UTF32 ch;
-        unsigned short bytesToWrite = 0;
-        const UTF32 byteMask = 0xBF;
-        const UTF32 byteMark = 0x80; 
-        ch = *tmpPtr++;
-        /* If we have a surrogate pair, convert to UTF32 first. */
-        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
-            /* If the 16 bits following the high surrogate are in the source
-             * buffer... */
-            if (tmpPtr < tmpEnd) {
-                UTF32 ch2 = *tmpPtr;
-                /* If it's a low surrogate, convert to UTF32. */
-                if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
-                    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
-                        + (ch2 - UNI_SUR_LOW_START) + halfBase;
-                    ++tmpPtr;
-                } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
-                    free(tmp);
-                    rb_raise(rb_path2class("JSON::ParserError"),
-                            "source sequence is illegal/malformed near %s", source);
-                }
-            } else { /* We don't have the 16 bits following the high surrogate. */
-                free(tmp);
-                rb_raise(rb_path2class("JSON::ParserError"),
-                    "partial character in source, but hit end near %s", source);
-                break;
-            }
-        } else if (flags == strictConversion) {
-            /* UTF-16 surrogate values are illegal in UTF-32 */
-            if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
-                free(tmp);
-                rb_raise(rb_path2class("JSON::ParserError"),
-                    "source sequence is illegal/malformed near %s", source);
-            }
-        }
-        /* Figure out how many bytes the result will require */
-        if (ch < (UTF32) 0x80) {
-            bytesToWrite = 1;
-        } else if (ch < (UTF32) 0x800) {
-            bytesToWrite = 2;
-        } else if (ch < (UTF32) 0x10000) {
-            bytesToWrite = 3;
-        } else if (ch < (UTF32) 0x110000) {
-            bytesToWrite = 4;
-        } else {
-            bytesToWrite = 3;
-            ch = UNI_REPLACEMENT_CHAR;
-        }
-
-        buf[0] = 0;
-        buf[1] = 0;
-        buf[2] = 0;
-        buf[3] = 0;
-        p = buf + bytesToWrite;
-        switch (bytesToWrite) { /* note: everything falls through. */
-            case 4: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
-            case 3: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
-            case 2: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
-            case 1: *--p = (UTF8) (ch | firstByteMark[bytesToWrite]);
-        }
-        rb_str_buf_cat(buffer, p, bytesToWrite);
-    }
-    free(tmp);
-    source += 5 + (n - 1) * 6;
-    return source;
-}

data/vendor/gems/gems/json-1.1.3/ext/json/ext/parser/unicode.h

@@ -1,58 +0,0 @@
-
-#ifndef _PARSER_UNICODE_H_
-#define _PARSER_UNICODE_H_
-
-#include "ruby.h"
-
-typedef unsigned long	UTF32;	/* at least 32 bits */
-typedef unsigned short	UTF16;	/* at least 16 bits */
-typedef unsigned char	UTF8;	/* typically 8 bits */
-
-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
-#define UNI_MAX_BMP (UTF32)0x0000FFFF
-#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
-#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
-
-#define UNI_SUR_HIGH_START  (UTF32)0xD800
-#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
-#define UNI_SUR_LOW_START   (UTF32)0xDC00
-#define UNI_SUR_LOW_END     (UTF32)0xDFFF
-
-static const int halfShift  = 10; /* used for shifting by 10 bits */
-
-static const UTF32 halfBase = 0x0010000UL;
-static const UTF32 halfMask = 0x3FFUL;
-
-typedef enum {
-	conversionOK = 0, 	/* conversion successful */
-	sourceExhausted,	/* partial character in source, but hit end */
-	targetExhausted,	/* insuff. room in target for conversion */
-	sourceIllegal		/* source sequence is illegal/malformed */
-} ConversionResult;
-
-typedef enum {
-	strictConversion = 0,
-	lenientConversion
-} ConversionFlags;
-
-char *JSON_convert_UTF16_to_UTF8 (
-    VALUE buffer,
-    char *source,
-    char *sourceEnd,
-		ConversionFlags flags);
-
-#ifndef RARRAY_PTR
-#define RARRAY_PTR(ARRAY) RARRAY(ARRAY)->ptr
-#endif
-#ifndef RARRAY_LEN
-#define RARRAY_LEN(ARRAY) RARRAY(ARRAY)->len
-#endif
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(string) RSTRING(string)->ptr
-#endif
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(string) RSTRING(string)->len
-#endif
-
-#endif

data/vendor/gems/gems/json-1.1.3/install.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rbconfig'
-require 'fileutils'
-include FileUtils::Verbose
-
-include Config
-
-bindir = CONFIG["bindir"]
-cd 'bin' do
-  filename = 'edit_json.rb'
-  #install(filename, bindir)
-end
-sitelibdir = CONFIG["sitelibdir"]
-cd 'lib' do
-  install('json.rb', sitelibdir)
-  mkdir_p File.join(sitelibdir, 'json')
-  for file in Dir['json/**/*.{rb,xpm}']
-    d = File.join(sitelibdir, file)
-    mkdir_p File.dirname(d)
-    install(file, d)
-  end
-  install(File.join('json', 'editor.rb'), File.join(sitelibdir,'json'))
-  install(File.join('json', 'json.xpm'), File.join(sitelibdir,'json'))
-end
-warn " *** Installed PURE ruby library."

data/vendor/gems/gems/json-1.1.3/lib/json.rb

@@ -1,235 +0,0 @@
-require 'json/common'
-# = json - JSON for Ruby
-#
-# == Description
-#
-# This is a implementation of the JSON specification according to RFC 4627
-# (http://www.ietf.org/rfc/rfc4627.txt). Starting from version 1.0.0 on there
-# will be two variants available:
-#
-# * A pure ruby variant, that relies on the iconv and the stringscan
-#   extensions, which are both part of the ruby standard library.
-# * The quite a bit faster C extension variant, which is in parts implemented
-#   in C and comes with its own unicode conversion functions and a parser
-#   generated by the ragel state machine compiler
-#   (http://www.cs.queensu.ca/~thurston/ragel).
-#
-# Both variants of the JSON generator escape all non-ASCII an control
-# characters with \uXXXX escape sequences, and support UTF-16 surrogate pairs
-# in order to be able to generate the whole range of unicode code points. This
-# means that generated JSON text is encoded as UTF-8 (because ASCII is a subset
-# of UTF-8) and at the same time avoids decoding problems for receiving
-# endpoints, that don't expect UTF-8 encoded texts. On the negative side this
-# may lead to a bit longer strings than necessarry.
-#
-# All strings, that are to be encoded as JSON strings, should be UTF-8 byte
-# sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
-# encoded, please use the to_json_raw_object method of String (which produces
-# an object, that contains a byte array) and decode the result on the receiving
-# endpoint.
-#
-# == Author
-#
-# Florian Frank <mailto:flori@ping.de>
-#
-# == License
-#
-# This software is distributed under the same license as Ruby itself, see
-# http://www.ruby-lang.org/en/LICENSE.txt.
-#
-# == Download
-#
-# The latest version of this library can be downloaded at
-#
-# * http://rubyforge.org/frs?group_id=953
-#
-# Online Documentation should be located at
-#
-# * http://json.rubyforge.org
-#
-# == Usage
-# 
-# To use JSON you can
-#   require 'json'
-# to load the installed variant (either the extension 'json' or the pure
-# variant 'json_pure'). If you have installed the extension variant, you can
-# pick either the extension variant or the pure variant by typing
-#   require 'json/ext'
-# or
-#   require 'json/pure'
-#
-# You can choose to load a set of common additions to ruby core's objects if
-# you
-#   require 'json/add/core'
-#
-# After requiring this you can, e. g., serialise/deserialise Ruby ranges:
-#
-#   JSON JSON(1..10) # => 1..10
-#
-# To find out how to add JSON support to other or your own classes, read the
-# Examples section below.
-#
-# To get the best compatibility to rails' JSON implementation, you can
-#   require 'json/add/rails'
-#
-# Both of the additions attempt to require 'json' (like above) first, if it has
-# not been required yet.
-#
-# == Speed Comparisons
-#
-# I have created some benchmark results (see the benchmarks subdir of the
-# package) for the JSON-Parser to estimate the speed up in the C extension:
-#
-# JSON::Pure::Parser::  28.90  calls/second
-# JSON::Ext::Parser::  505.50 calls/second
-#
-# This is ca. <b>17.5</b> times the speed of the pure Ruby implementation.
-#
-# I have benchmarked the JSON-Generator as well. This generates a few more
-# values, because there are different modes, that also influence the achieved
-# speed:
-#
-# * JSON::Pure::Generator:
-#   generate::        35.06 calls/second
-#   pretty_generate:: 34.00 calls/second
-#   fast_generate::   41.06 calls/second
-#
-# * JSON::Ext::Generator:
-#   generate::        492.11 calls/second
-#   pretty_generate:: 348.85 calls/second
-#   fast_generate::   541.60 calls/second
-#
-# * Speedup Ext/Pure:
-#   generate safe::   14.0 times
-#   generate pretty:: 10.3 times
-#   generate fast::   13.2 times
-#
-# The rails framework includes a generator as well, also it seems to be rather
-# slow: I measured only 23.87 calls/second which is slower than any of my pure
-# generator results. Here a comparison of the different speedups with the Rails
-# measurement as the divisor:
-#
-# * Speedup Pure/Rails:
-#   generate safe::   1.5 times
-#   generate pretty:: 1.4 times
-#   generate fast::   1.7 times
-#
-# * Speedup Ext/Rails:
-#   generate safe::   20.6 times
-#   generate pretty:: 14.6 times
-#   generate fast::   22.7 times
-#
-# To achieve the fastest JSON text output, you can use the
-# fast_generate/fast_unparse methods. Beware, that this will disable the
-# checking for circular Ruby data structures, which may cause JSON to go into
-# an infinite loop.
-#
-# == Examples
-#
-# To create a JSON text from a ruby data structure, you
-# can call JSON.generate (or JSON.unparse) like that:
-#
-#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-#  # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
-#
-# To create a valid JSON text you have to make sure, that the output is
-# embedded in either a JSON array [] or a JSON object {}. The easiest way to do
-# this, is by putting your values in a Ruby Array or Hash instance.
-#
-# To get back a ruby data structure from a JSON text, you have to call
-# JSON.parse on it:
-#
-#  JSON.parse json
-#  # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
-# 
-# Note, that the range from the original data structure is a simple
-# string now. The reason for this is, that JSON doesn't support ranges
-# or arbitrary classes. In this case the json library falls back to call
-# Object#to_json, which is the same as #to_s.to_json.
-#
-# It's possible to add JSON support serialization to arbitrary classes by
-# simply implementing a more specialized version of the #to_json method, that
-# should return a JSON object (a hash converted to JSON with #to_json) like
-# this (don't forget the *a for all the arguments):
-#
-#  class Range
-#    def to_json(*a)
-#      {
-#        'json_class'   => self.class.name, # = 'Range'
-#        'data'         => [ first, last, exclude_end? ]
-#      }.to_json(*a)
-#    end
-#  end
-#
-# The hash key 'json_class' is the class, that will be asked to deserialise the
-# JSON representation later. In this case it's 'Range', but any namespace of
-# the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
-# used to store the necessary data to configure the object to be deserialised.
-#
-# If a the key 'json_class' is found in a JSON object, the JSON parser checks
-# if the given class responds to the json_create class method. If so, it is
-# called with the JSON object converted to a Ruby hash. So a range can
-# be deserialised by implementing Range.json_create like this:
-# 
-#  class Range
-#    def self.json_create(o)
-#      new(*o['data'])
-#    end
-#  end
-#
-# Now it possible to serialise/deserialise ranges as well:
-#
-#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-#  # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
-#  JSON.parse json
-#  # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
-#
-# JSON.generate always creates the shortest possible string representation of a
-# ruby data structure in one line. This good for data storage or network
-# protocols, but not so good for humans to read. Fortunately there's also
-# JSON.pretty_generate (or JSON.pretty_generate) that creates a more
-# readable output:
-#
-#  puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
-#  [
-#    1,
-#    2,
-#    {
-#      "a": 3.141
-#    },
-#    false,
-#    true,
-#    null,
-#    {
-#      "json_class": "Range",
-#      "data": [
-#        4,
-#        10,
-#        false
-#      ]
-#    }
-#  ]
-#
-# There are also the methods Kernel#j for unparse, and Kernel#jj for
-# pretty_unparse output to the console, that work analogous to Core Ruby's p
-# and the pp library's pp methods.
-#
-# The script tools/server.rb contains a small example if you want to test, how
-# receiving a JSON object from a webrick server in your browser with the
-# javasript prototype library (http://www.prototypejs.org) works.
-#
-module JSON
-  require 'json/version'
-
-  if VARIANT_BINARY
-    require 'json/ext'
-  else
-    begin
-      require 'json/ext'
-    rescue LoadError
-      require 'json/pure'
-    end
-  end
-
-  JSON_LOADED = true
-end