benofsky-yajl-ruby 0.7.6

data/lib/yajl/bzip2/stream_reader.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+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,15 @@
+# encoding: UTF-8
+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/bzip2.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+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/deflate/stream_reader.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+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,21 @@
+# encoding: UTF-8
+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/deflate.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+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/gzip/stream_reader.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+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,14 @@
+# encoding: UTF-8
+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/gzip.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+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/http_stream.rb

@@ -0,0 +1,197 @@
+# encoding: UTF-8
+require 'socket' unless defined?(Socket)
+require 'yajl' unless defined?(Yajl::Parser)
+require 'uri' unless defined?(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
+
+        user_agent = opts.has_key?('User-Agent') ? opts.delete(['User-Agent']) : "Yajl::HttpStream #{Yajl::VERSION}"
+        if method == "POST" || method == "PUT"
+          content_type = opts.has_key?('Content-Type') ? opts.delete(['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
+        end
+
+        socket = opts.has_key?(: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"
+        request << "Authorization: Basic #{[uri.userinfo].pack('m').strip!}\r\n" unless uri.userinfo.nil?
+        request << "User-Agent: #{user_agent}\r\n"
+        request << "Accept: */*\r\n"
+        if method == "POST" || method == "PUT"
+          request << "Content-Length: #{body.length}\r\n"
+          request << "Content-Type: #{content_type}\r\n"
+        end
+        encodings = []
+        encodings << "bzip2" if defined?(Yajl::Bzip2)
+        encodings << "gzip" if defined?(Yajl::Gzip)
+        encodings << "deflate" if defined?(Yajl::Deflate)
+        request << "Accept-Encoding: #{encodings.join(',')}\r\n" if encodings.any?
+        request << "Accept-Charset: utf-8\r\n\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 = {})
+      @socket = TCPSocket.new(uri.host, uri.port)
+      opts.merge!({:socket => @socket})
+      @intentional_termination = false
+    end
+  end
+end

data/lib/yajl/json_gem/encoding.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+require 'yajl' unless defined?(Yajl::Parser)
+
+# NOTE: this is probably temporary until I can split out the JSON compat C code into it's own
+# extension that can be included when this file is.
+Yajl::Encoder.enable_json_gem_compatability
+
+# Our fallback to_json definition
+class Object
+  def to_json(*args, &block)
+    "\"#{to_s}\""
+  end
+end
+
+module JSON
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class GeneratorError < JSONError; end unless defined?(JSON::GeneratorError)
+
+  def self.generate(obj, opts={})
+    begin
+      options_map = {}
+      if opts.has_key?(:indent)
+        options_map[:pretty] = true
+        options_map[:indent] = opts[:indent]
+      end
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+
+  def self.pretty_generate(obj, opts={})
+    begin
+      options_map = {}
+      options_map[:pretty] = true
+      options_map[:indent] = opts[:indent] if opts.has_key?(:indent)
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+
+  def self.dump(obj, io=nil, *args)
+    begin
+      Yajl::Encoder.encode(obj, io)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+end

data/lib/yajl/json_gem/parsing.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+require 'yajl' unless defined?(Yajl::Parser)
+
+module JSON
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class ParserError < JSONError; end unless defined?(JSON::ParserError)
+
+  def self.default_options
+    @default_options ||= {:symbolize_keys => false}
+  end
+
+  def self.parse(str, opts=JSON.default_options)
+    begin
+      Yajl::Parser.parse(str, opts)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+
+  def self.load(input, *args)
+    begin
+      Yajl::Parser.parse(input, default_options)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+end

data/lib/yajl/json_gem.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+require 'yajl' unless defined?(Yajl::Parser)
+require 'yajl/json_gem/parsing'
+require 'yajl/json_gem/encoding'
+
+module ::Kernel
+  def JSON(object, opts = {})
+    if object.respond_to? :to_s
+      JSON.parse(object.to_s, JSON.default_options.merge(opts))
+    else
+      JSON.generate(object, opts)
+    end
+  end
+end

data/lib/yajl.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require 'yajl_ext'
+
+# = 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
+  VERSION = "0.7.6"
+
+  # 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
+
+  # DEPRECATED - See Yajl::Parser and Yajl::Encoder
+  module Stream
+    # DEPRECATED - See Yajl::Parser
+    def self.parse(str_or_io)
+      warn "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Parser class instead."
+      Parser.new.parse(str_or_io)
+    end
+
+    # DEPRECATED - See Yajl::Encoder
+    def self.encode(obj, str_or_io=nil)
+      warn "WARNING: Yajl::Stream has be deprecated and will most likely be gone in the next release. Use the Yajl::Encoder class instead."
+      Encoder.new.encode(obj, str_or_io)
+    end
+  end
+end