yajl-ruby 1.0.0-x86-mswin32-60

data/ext/yajl/yajl_parser.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010, Lloyd Hilaiel.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ * 
+ *  3. Neither the name of Lloyd Hilaiel nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */ 
+
+#ifndef __YAJL_PARSER_H__
+#define __YAJL_PARSER_H__
+
+#include "api/yajl_parse.h"
+#include "yajl_bytestack.h"
+#include "yajl_buf.h"
+
+
+typedef enum {
+    yajl_state_start = 0,
+    yajl_state_parse_complete,
+    yajl_state_parse_error,
+    yajl_state_lexical_error,
+    yajl_state_map_start,
+    yajl_state_map_sep,    
+    yajl_state_map_need_val,
+    yajl_state_map_got_val,
+    yajl_state_map_need_key,
+    yajl_state_array_start,
+    yajl_state_array_got_val,
+    yajl_state_array_need_val
+} yajl_state;
+
+struct yajl_handle_t {
+    const yajl_callbacks * callbacks;
+    void * ctx;
+    yajl_lexer lexer;
+    const char * parseError;
+    /* the number of bytes consumed from the last client buffer,
+     * in the case of an error this will be an error offset, in the
+     * case of an error this can be used as the error offset */
+    unsigned int bytesConsumed;
+    /* temporary storage for decoded strings */
+    yajl_buf decodeBuf;
+    /* a stack of states.  access with yajl_state_XXX routines */
+    yajl_bytestack stateStack;
+    /* memory allocation routines */
+    yajl_alloc_funcs alloc;
+};
+
+yajl_status
+yajl_do_parse(yajl_handle handle, const unsigned char * jsonText,
+              unsigned int jsonTextLen);
+
+unsigned char *
+yajl_render_error_string(yajl_handle hand, const unsigned char * jsonText,
+                         unsigned int jsonTextLen, int verbose);
+
+
+#endif

data/ext/yajl/yajl_version.c

@@ -0,0 +1,7 @@
+#include "api/yajl_version.h"
+
+int yajl_version(void)
+{
+	return YAJL_VERSION;
+}
+

data/lib/yajl.rb

@@ -0,0 +1,75 @@
+require 'yajl/yajl'
+
+# = Extras
+# We're not going to load these auotmatically, because you might not need them ;)
+#
+# require 'yajl/http_stream.rb' unless defined?(Yajl::HttpStream)
+# require 'yajl/gzip.rb' unless defined?(Yajl::Gzip)
+# require 'yajl/deflate.rb' unless defined?(Yajl::Deflate)
+# require 'yajl/bzip2.rb' unless defined?(Yajl::Bzip2)
+
+# = Yajl
+#
+# Ruby bindings to the excellent Yajl (Yet Another JSON Parser) ANSI C library.
+module Yajl
+  # For compatibility, has the same signature of Yajl::Parser.parse
+  def self.load(str_or_io, options={}, read_bufsize=nil, &block)
+    Parser.parse(str_or_io, options, read_bufsize, &block)
+  end
+
+  # For compatibility, has the same signature of Yajl::Encoder.encode
+  def self.dump(obj, *args, &block)
+    Encoder.encode(obj, args, &block)
+  end
+
+  class Parser
+    # A helper method for parse-and-forget use-cases
+    #
+    # +io+ is the stream to parse JSON from
+    #
+    # The +options+ hash allows you to set two parsing options - :allow_comments and :check_utf8
+    #
+    # :allow_comments accepts a boolean will enable/disable checks for in-line comments in the JSON stream
+    #
+    # :check_utf8 accepts a boolean will enable/disable UTF8 validation for the JSON stream
+    def self.parse(str_or_io, options={}, read_bufsize=nil, &block)
+      new(options).parse(str_or_io, read_bufsize, &block)
+    end
+  end
+
+  class Encoder
+    # A helper method for encode-and-forget use-cases
+    #
+    # Examples:
+    #   Yajl::Encoder.encode(obj[, io, :pretty => true, :indent => "\t", &block])
+    #
+    #   output = Yajl::Encoder.encode(obj[, :pretty => true, :indent => "\t", &block])
+    #
+    # +obj+ is a ruby object to encode to JSON format
+    #
+    # +io+ is the optional IO stream to encode the ruby object to.
+    # If +io+ isn't passed, the resulting JSON string is returned. If +io+ is passed, nil is returned.
+    #
+    # The +options+ hash allows you to set two encoding options - :pretty and :indent
+    #
+    # :pretty accepts a boolean and will enable/disable "pretty printing" the resulting output
+    #
+    # :indent accepts a string and will be used as the indent character(s) during the pretty print process
+    #
+    # If a block is passed, it will be used as (and work the same as) the +on_progress+ callback
+    def self.encode(obj, *args, &block)
+      # TODO: this code smells, any ideas?
+      args.flatten!
+      options = {}
+      io = nil
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          options = arg
+        elsif arg.respond_to?(:read)
+          io = arg
+        end
+      end if args.any?
+      new(options).encode(obj, io, &block)
+    end
+  end
+end

data/lib/yajl/bzip2.rb

@@ -0,0 +1,11 @@
+puts "DEPRECATION WARNING: Yajl's Bzip2 support is going to be removed in 2.0"
+
+require 'yajl' unless defined?(Yajl::Parser)
+
+begin
+  require 'bzip2' unless defined?(Bzip2)
+  require 'yajl/bzip2/stream_reader.rb'
+  require 'yajl/bzip2/stream_writer.rb'
+rescue LoadError => e
+  raise "Unable to load the bzip2 library. Is the bzip2-ruby gem installed?"
+end

data/lib/yajl/bzip2/stream_reader.rb

@@ -0,0 +1,31 @@
+module Yajl
+  module Bzip2
+    # This is a wrapper around Bzip::Reader to allow it's #read method to adhere
+    # to the IO spec, allowing for two parameters (length, and buffer)
+    class StreamReader < ::Bzip2::Reader
+      # A helper method to allow use similar to IO#read
+      def read(len=nil, buffer=nil)
+        if val = super(len)
+          unless buffer.nil?
+            buffer.replace(val)
+            return buffer
+          end
+          super(len)
+        else
+          nil
+        end
+      end
+
+      # Helper method for one-off parsing from a bzip2-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+
+        Yajl::Parser.new(options).parse(new(input), buffer_size, &block)
+      end
+    end
+  end
+end

data/lib/yajl/bzip2/stream_writer.rb

@@ -0,0 +1,14 @@
+module Yajl
+  module Bzip2
+    # A wrapper around the Bzip2::Writer class for easier JSON stream encoding
+    class StreamWriter < ::Bzip2::Writer
+
+      # A helper method for encoding to a bzip2-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
+      def self.encode(obj, io)
+        Yajl::Encoder.new.encode(obj, new(io))
+      end
+    end
+  end
+end

data/lib/yajl/deflate.rb

@@ -0,0 +1,6 @@
+puts "DEPRECATION WARNING: Yajl's Deflate support is going to be removed in 2.0"
+
+require 'yajl' unless defined?(Yajl::Parser)
+require 'zlib' unless defined?(Zlib)
+require 'yajl/deflate/stream_reader.rb'
+require 'yajl/deflate/stream_writer.rb'

data/lib/yajl/deflate/stream_reader.rb

@@ -0,0 +1,43 @@
+module Yajl
+  module Deflate
+    # This is a wrapper around Zlib::Inflate, creating a #read method that adheres
+    # to the IO spec, allowing for two parameters (length, and buffer)
+    class StreamReader < ::Zlib::Inflate
+
+      # Wrapper to the initialize method so we can set the initial IO to parse from.
+      def initialize(io, options)
+        @io = io
+        super(options)
+      end
+
+      # A helper method to allow use similar to IO#read
+      def read(len=nil, buffer=nil)
+        if val = @io.read(len)
+          unless buffer.nil?
+            buffer.replace(inflate(val))
+            return buffer
+          end
+          inflate(@io.read(len))
+        else
+          nil
+        end
+      end
+
+      # Helper method for one-off parsing from a deflate-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+
+        if options.is_a?(Hash)
+          deflate_options = options.delete(:deflate_options)
+          Yajl::Parser.new(options).parse(new(input, deflate_options), buffer_size, &block)
+        elsif options.is_a?(Fixnum)
+          Yajl::Parser.new.parse(new(input, options), buffer_size, &block)
+        end
+      end
+    end
+  end
+end

data/lib/yajl/deflate/stream_writer.rb

@@ -0,0 +1,20 @@
+module Yajl
+  module Deflate
+    # A wrapper around the Zlib::Deflate class for easier JSON stream parsing
+    class StreamWriter < ::Zlib::Deflate
+
+      # A helper method to allow use similar to IO#write
+      def write(str)
+        deflate(str)
+        str.size unless str.nil?
+      end
+
+      # A helper method for one-off encoding to a deflate-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
+      def self.encode(obj, io)
+        Yajl::Encoder.new.encode(obj, new(io))
+      end
+    end
+  end
+end

data/lib/yajl/gzip.rb

@@ -0,0 +1,6 @@
+puts "DEPRECATION WARNING: Yajl's Gzip support is going to be removed in 2.0"
+
+require 'yajl' unless defined?(Yajl::Parser)
+require 'zlib' unless defined?(Zlib)
+require 'yajl/gzip/stream_reader.rb'
+require 'yajl/gzip/stream_writer.rb'

data/lib/yajl/gzip/stream_reader.rb

@@ -0,0 +1,30 @@
+module Yajl
+  module Gzip
+    # This is a wrapper around Zlib::GzipReader to allow it's #read method to adhere
+    # to the IO spec, allowing for two parameters (length, and buffer)
+    class StreamReader < ::Zlib::GzipReader
+      # A helper method to allow use similar to IO#read
+      def read(len=nil, buffer=nil)
+        if val = super(len)
+          unless buffer.nil?
+            buffer.replace(val)
+            return buffer
+          end
+          super(len)
+        else
+          nil
+        end
+      end
+
+      # Helper method for one-off parsing from a gzip-compressed stream
+      #
+      # See Yajl::Parser#parse for parameter documentation
+      def self.parse(input, options={}, buffer_size=nil, &block)
+        if input.is_a?(String)
+          input = StringIO.new(input)
+        end
+        Yajl::Parser.new(options).parse(new(input), buffer_size, &block)
+      end
+    end
+  end
+end

data/lib/yajl/gzip/stream_writer.rb

@@ -0,0 +1,13 @@
+module Yajl
+  module Gzip
+    # Wraper around the Zlib::GzipWriter class
+    class StreamWriter < ::Zlib::GzipWriter
+      # A helper method for one-off encoding to a gzip-compressed stream
+      #
+      # Look up Yajl::Encoder#encode for parameter documentation
+      def self.encode(obj, io)
+        Yajl::Encoder.new.encode(obj, new(io))
+      end
+    end
+  end
+end

data/lib/yajl/http_stream.rb

@@ -0,0 +1,212 @@
+puts "DEPRECATION WARNING: Yajl::HttpStream is going to be removed in 2.0"
+
+require 'socket'
+require 'yajl'
+require 'yajl/version' unless defined? Yajl::VERSION
+require 'uri'
+
+module Yajl
+  # This module is for making HTTP requests to which the response bodies (and possibly requests in the near future)
+  # are streamed directly into Yajl.
+  class HttpStream
+
+    # This Exception is thrown when an HTTP response isn't in ALLOWED_MIME_TYPES
+    # and therefore cannot be parsed.
+    class InvalidContentType < Exception; end
+    class HttpError < StandardError
+
+      attr_reader :message, :headers
+
+      def initialize(message, headers)
+        @message = message
+        @headers = headers
+      end
+    end
+
+    # The mime-type we expect the response to be. If it's anything else, we can't parse it
+    # and an InvalidContentType is raised.
+    ALLOWED_MIME_TYPES = ["application/json", "text/plain"]
+
+    # Makes a basic HTTP GET request to the URI provided
+    def self.get(uri, opts = {}, &block)
+      request("GET", uri, opts, &block)
+    end
+
+    # Makes a basic HTTP GET request to the URI provided allowing the user to terminate the connection
+    def get(uri, opts = {}, &block)
+      initialize_socket(uri, opts)
+      HttpStream::get(uri, opts, &block)
+    rescue IOError => e
+      raise e unless @intentional_termination
+    end
+
+    # Makes a basic HTTP POST request to the URI provided
+    def self.post(uri, body, opts = {}, &block)
+      request("POST", uri, opts.merge({:body => body}), &block)
+    end
+
+    # Makes a basic HTTP POST request to the URI provided allowing the user to terminate the connection
+    def post(uri, body, opts = {}, &block)
+      initialize_socket(uri, opts)
+      HttpStream::post(uri, body, opts, &block)
+    rescue IOError => e
+      raise e unless @intentional_termination
+    end
+
+    # Makes a basic HTTP PUT request to the URI provided
+    def self.put(uri, body, opts = {}, &block)
+      request("PUT", uri, opts.merge({:body => body}), &block)
+    end
+
+    # Makes a basic HTTP PUT request to the URI provided allowing the user to terminate the connection
+    def put(uri, body, opts = {}, &block)
+      initialize_socket(uri, opts)
+      HttpStream::put(uri, body, opts, &block)
+    rescue IOError => e
+      raise e unless @intentional_termination
+    end
+
+    # Makes a basic HTTP DELETE request to the URI provided
+    def self.delete(uri, opts = {}, &block)
+      request("DELETE", uri, opts, &block)
+    end
+
+    # Makes a basic HTTP DELETE request to the URI provided allowing the user to terminate the connection
+    def delete(uri, opts = {}, &block)
+      initialize_socket(uri, opts)
+      HttpStream::delete(uri, opts, &block)
+    rescue IOError => e
+      raise e unless @intentional_termination
+    end
+
+    # Terminate a running HTTPStream instance
+    def terminate
+      @intentional_termination = true
+      @socket.close
+    end
+
+    protected
+      def self.request(method, uri, opts = {}, &block)
+        if uri.is_a?(String)
+          uri = URI.parse(uri)
+        end
+
+        default_headers = {
+          "User-Agent" => opts["User-Agent"] || "Yajl::HttpStream #{Yajl::VERSION}",
+          "Accept" => "*/*",
+          "Accept-Charset" => "utf-8"
+        }
+
+        if method == "POST" || method == "PUT"
+          default_headers["Content-Type"] = opts["Content-Type"] || "application/x-www-form-urlencoded"
+          body = opts.delete(:body)
+          if body.is_a?(Hash)
+            body = body.keys.collect {|param| "#{URI.escape(param.to_s)}=#{URI.escape(body[param].to_s)}"}.join('&')
+          end
+          default_headers["Content-Length"] = body.length
+        end
+
+        unless uri.userinfo.nil?
+          default_headers["Authorization"] = "Basic #{[uri.userinfo].pack('m').strip!}\r\n"
+        end
+
+        encodings = []
+        encodings << "bzip2" if defined?(Yajl::Bzip2)
+        encodings << "gzip" if defined?(Yajl::Gzip)
+        encodings << "deflate" if defined?(Yajl::Deflate)
+        if encodings.any?
+          default_headers["Accept-Encoding"] = "#{encodings.join(',')}\r\n"
+        end
+
+        headers = default_headers.merge(opts[:headers] || {})
+
+        socket = opts.delete(:socket) || TCPSocket.new(uri.host, uri.port)
+        request = "#{method} #{uri.path}#{uri.query ? "?"+uri.query : nil} HTTP/1.1\r\n"
+        request << "Host: #{uri.host}\r\n"
+        headers.each do |k, v|
+          request << "#{k}: #{v}\r\n"
+        end
+        request << "\r\n"
+        if method == "POST" || method == "PUT"
+          request << body
+        end
+        socket.write(request)
+        response_head = {}
+        response_head[:headers] = {}
+
+        socket.each_line do |line|
+          if line == "\r\n" # end of the headers
+            break
+          else
+            header = line.split(": ")
+            if header.size == 1
+              header = header[0].split(" ")
+              response_head[:version] = header[0]
+              response_head[:code] = header[1].to_i
+              response_head[:msg] = header[2]
+              # this is the response code line
+            else
+              response_head[:headers][header[0]] = header[1].strip
+            end
+          end
+        end
+
+        if (response_head[:code] != 200)
+          raise HttpError.new("Code 200 expected got #{response_head[:code]}", response_head[:headers])
+        end
+
+        parser = Yajl::Parser.new(opts)
+        parser.on_parse_complete = block if block_given?
+        if response_head[:headers]["Transfer-Encoding"] == 'chunked'
+          if block_given?
+            chunkLeft = 0
+            while !socket.eof? && (line = socket.gets)
+              break if line.match /^0.*?\r\n/
+              next if line == "\r\n"
+              size = line.hex
+              json = socket.read(size)
+              next if json.nil?
+              chunkLeft = size-json.size
+              if chunkLeft == 0
+                parser << json
+              else
+                # received only part of the chunk, grab the rest
+                parser << socket.read(chunkLeft)
+              end
+            end
+          else
+            raise Exception, "Chunked responses detected, but no block given to handle the chunks."
+          end
+        else
+          content_type = response_head[:headers]["Content-Type"].split(';')
+          content_type = content_type.first
+          if ALLOWED_MIME_TYPES.include?(content_type)
+            case response_head[:headers]["Content-Encoding"]
+            when "gzip"
+              return Yajl::Gzip::StreamReader.parse(socket, opts, &block)
+            when "deflate"
+              return Yajl::Deflate::StreamReader.parse(socket, opts.merge({:deflate_options => -Zlib::MAX_WBITS}), &block)
+            when "bzip2"
+              return Yajl::Bzip2::StreamReader.parse(socket, opts, &block)
+            else
+              return parser.parse(socket)
+            end
+          else
+            raise InvalidContentType, "The response MIME type #{content_type}"
+          end
+        end
+      ensure
+        socket.close if !socket.nil? and !socket.closed?
+      end
+
+  private
+    # Initialize socket and add it to the opts
+    def initialize_socket(uri, opts = {})
+      return if opts[:socket]
+
+      @socket = TCPSocket.new(uri.host, uri.port)
+      opts.merge!({:socket => @socket})
+      @intentional_termination = false
+    end
+  end
+end