streamly_ffi 0.1.6 → 0.2.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gsolr.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'rspec-core'
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    streamly_ffi (0.1.6)
+      curl_ffi
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    curl_ffi (0.0.6)
+      ffi
+    diff-lcs (1.1.2)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    rake (0.8.7)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  curl_ffi
+  rspec
+  rspec-core
+  streamly_ffi!

data/benchmark/basic_request.rb

@@ -34,10 +34,18 @@ Benchmark.bmbm do |x|
     end
   end
 
+  x.report do
+    puts "StreamlyFFI2"
+    conn = StreamlyFFI::Connection.new
+    (ARGV[1] || 1).to_i.times do
+      conn.get(url)
+    end
+  end
+
   x.report do
     puts "`curl`"
     (ARGV[1] || 1).to_i.times do
-      `curl -s --compressed #{url}`
+      `curl --compressed --silent #{url}`
     end
   end
 

data/lib/streamly_ffi.rb

@@ -5,7 +5,10 @@ $:.unshift(File.dirname(__FILE__)) unless
 require 'streamly_ffi/version'
 
 module StreamlyFFI
-  autoload :Request, "streamly_ffi/request"
+  autoload :Base,               "streamly_ffi/base"
+  autoload :Connection,         "streamly_ffi/connection"
+  autoload :Request,            "streamly_ffi/request"
+  autoload :PersistentRequest,  "streamly_ffi/persistent_request"
 
   class Error               < StandardError; end
   class UnsupportedProtocol < StandardError; end
@@ -117,6 +120,22 @@ module StreamlyFFI
     opts.merge!({:response_body_handler => block}) if block_given?
     Request.execute(opts)
   end
-end
 
-# require "streamly/request"  # May need to do this? Not sure how autoload works with FFI yet
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.delete("www.somehost.com/some_resource/1")
+  #
+  #   Streamly.delete("www.somehost.com/some_resource/1") do |chunk|
+  #     # do something with _chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String, the url to request
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response body in chunks to the caller
+  def self.connect
+    Connection.new
+  end
+end

data/lib/streamly_ffi/base.rb

@@ -0,0 +1,155 @@
+module StreamlyFFI
+  module Base
+    alias __method__ method
+
+    attr_accessor :url, :method, :default_write_handler, :default_header_handler
+
+    def execute(options={})
+      set_options(options).perform
+
+      CurlFFI.slist_free_all(@request_headers) if @request_headers
+
+      connection.reset
+
+      resp  = if(options.has_key?(:response_header_handler) or options.has_key?(:response_body_handler))
+                nil
+              elsif(options[:method] == :head && response_header.respond_to?(:to_str))
+                response_header
+              elsif(response_body.is_a?(String))
+                response_body
+              else
+                nil
+              end
+
+      return resp
+    end
+
+    def perform
+      connection.perform
+    end
+
+    def set_options(options={})
+      @url      = options[:url]     if options.has_key?(:url)     # Make sure @url is set, if not
+      @method   = options[:method]  if options.has_key?(:method)  # Make sure @method is set, if not
+      @payload  = options[:payload]
+
+      @response_body          = nil
+      @response_header        = nil
+      @custom_header_handler  = nil
+      @custom_write_handler   = nil
+
+      # url should be a string that doesn't suck
+      # method should be :post, :get, :put, :delete, :head
+      # options should contain any of the following keys:
+      #   :headers, :response_header_handler, :response_body_handler, :payload (required if method = :post / :put)
+
+      case @method
+      when :get     then  connection.setopt :HTTPGET,        1
+      when :head    then  connection.setopt :NOBODY,         1
+      when :post    then  connection.setopt :POST,           1
+                          connection.setopt :POSTFIELDS,     @payload
+                          connection.setopt :POSTFIELDSIZE,  @payload.size
+      when :put     then  connection.setopt :CUSTOMREQUEST,  "PUT"
+                          connection.setopt :POSTFIELDS,     @payload
+                          connection.setopt :POSTFIELDSIZE,  @payload.size
+      when :delete  then  connection.setopt :CUSTOMREQUEST,  "DELETE"
+      # else I WILL CUT YOU
+      end
+
+      if options.has_key?(:headers) and not options[:headers].nil?
+        options[:headers].each_pair do |key_and_value|
+          self.request_headers = CurlFFI.slist_append(self.request_headers, key_and_value.join(": "))
+        end
+        connection.setopt :HTTPHEADER, @request_headers
+      end
+
+      if options.has_key?(:response_header_handler)
+        @custom_header_handler = options[:response_header_handler]
+        set_header_handler(:custom_header_callback)
+      else
+        set_header_handler
+      end
+
+      if options.has_key?(:response_body_handler)
+        @custom_write_handler = options[:response_body_handler]
+        set_write_handler(:custom_write_callback)
+      else
+        set_write_handler
+      end
+
+      connection.setopt :ENCODING,        "identity, deflate, gzip" unless @method == :head
+      connection.setopt :URL,             @url
+
+      # Other common options (blame streamly guy)
+      connection.setopt :FOLLOWLOCATION,  1
+      connection.setopt :MAXREDIRS,       3
+      # @TODO: This should be an option
+      connection.setopt :SSL_VERIFYPEER,  0
+      connection.setopt :SSL_VERIFYHOST,  0
+
+      connection.setopt :ERRORBUFFER,     self.error_buffer
+
+      return self
+    end
+
+    def connection
+      @connection ||= CurlFFI::Easy.new
+    end
+
+    def error_buffer
+      @error_buffer ||= FFI::MemoryPointer.new(:char, CurlFFI::ERROR_SIZE, :clear)
+    end
+    alias :error    :error_buffer
+
+    def request_headers
+      @request_headers ||= FFI::MemoryPointer.from_string("")
+    end
+
+    def response_body
+      @response_body ||= ""
+    end
+    alias :response :response_body
+    alias :body     :response_body
+
+    def response_header
+      @response_header ||= ""
+    end
+    alias :headers  :response_header
+
+    def set_write_handler(_callback=:default_write_callback)
+      connection.setopt(:WRITEFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t,], &self.__method__(_callback)))
+    end
+
+    def set_header_handler(_callback=:default_header_callback)
+      connection.setopt(:HEADERFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t], &self.__method__(_callback)))
+    end
+
+    def default_write_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+      response_body << string_ptr.read_string(length)
+
+      return length
+    end
+
+    def default_header_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+      response_header << string_ptr.read_string(length)
+
+      return length
+    end
+
+    def custom_write_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+      @custom_write_handler.call(string_ptr.read_string(length))
+
+      return length
+    end
+
+    def custom_header_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+      @custom_header_handler.call(string_ptr.read_string(length))
+
+      return length
+    end
+  end
+end

data/lib/streamly_ffi/connection.rb

@@ -0,0 +1,112 @@
+module StreamlyFFI
+  class Connection
+
+    attr_accessor :connection
+
+    def initialize
+      self.connection = StreamlyFFI::PersistentRequest.new
+    end
+
+    # A helper method to make HEAD requests a dead-simple one-liner
+    #
+    # Example:
+    #   Streamly.head("www.somehost.com/some_resource/1")
+    #
+    #   Streamly.head("www.somehost.com/some_resource/1") do |header_chunk|
+    #     # do something with _header_chunk_
+    #   end
+    #
+    # Parameters:
+    # +url+ should be a String, the url to request
+    # +headers+ should be a Hash and is optional
+    # 
+    # This method also accepts a block, which will stream the response headers in chunks to the caller
+    def head(url, headers=nil, &block)
+      opts = {:method => :head, :url => url, :headers => headers}
+      opts[:response_header_handler] = block if block_given?
+      self.connection.execute(opts)
+    end
+
+    # A helper method to make HEAD requests a dead-simple one-liner
+    #
+    # Example:
+    #   Streamly.get("www.somehost.com/some_resource/1")
+    #
+    #   Streamly.get("www.somehost.com/some_resource/1") do |chunk|
+    #     # do something with _chunk_
+    #   end
+    #
+    # Parameters:
+    # +url+ should be a String, the url to request
+    # +headers+ should be a Hash and is optional
+    # 
+    # This method also accepts a block, which will stream the response body in chunks to the caller
+    def get(url, headers=nil, &block)
+      opts = {:method => :get, :url => url, :headers => headers}
+      opts[:response_body_handler] = block if block_given?
+      self.connection.execute(opts)
+    end
+
+    # A helper method to make HEAD requests a dead-simple one-liner
+    #
+    # Example:
+    #   Streamly.post("www.somehost.com/some_resource", "asset[id]=2&asset[name]=bar")
+    #
+    #   Streamly.post("www.somehost.com/some_resource", "asset[id]=2&asset[name]=bar") do |chunk|
+    #     # do something with _chunk_
+    #   end
+    #
+    # Parameters:
+    # +url+ should be a String (the url to request) and is required
+    # +payload+ should be a String and is required
+    # +headers+ should be a Hash and is optional
+    # 
+    # This method also accepts a block, which will stream the response body in chunks to the caller
+    def post(url, payload, headers=nil, &block)
+      opts = {:method => :post, :url => url, :payload => payload, :headers => headers}
+      opts[:response_body_handler] = block if block_given?
+      self.connection.execute(opts)
+    end
+
+    # A helper method to make HEAD requests a dead-simple one-liner
+    #
+    # Example:
+    #   Streamly.put("www.somehost.com/some_resource/1", "asset[name]=foo")
+    #
+    #   Streamly.put("www.somehost.com/some_resource/1", "asset[name]=foo") do |chunk|
+    #     # do something with _chunk_
+    #   end
+    #
+    # Parameters:
+    # +url+ should be a String (the url to request) and is required
+    # +payload+ should be a String and is required
+    # +headers+ should be a Hash and is optional
+    # 
+    # This method also accepts a block, which will stream the response body in chunks to the caller
+    def put(url, payload, headers=nil, &block)
+      opts = {:method => :put, :url => url, :payload => payload, :headers => headers}
+      opts[:response_body_handler] = block if block_given?
+      self.connection.execute(opts)
+    end
+
+    # A helper method to make HEAD requests a dead-simple one-liner
+    #
+    # Example:
+    #   Streamly.delete("www.somehost.com/some_resource/1")
+    #
+    #   Streamly.delete("www.somehost.com/some_resource/1") do |chunk|
+    #     # do something with _chunk_
+    #   end
+    #
+    # Parameters:
+    # +url+ should be a String, the url to request
+    # +headers+ should be a Hash and is optional
+    # 
+    # This method also accepts a block, which will stream the response body in chunks to the caller
+    def delete(url, headers={}, &block)
+      opts = {:method => :delete, :url => url, :headers => headers}
+      opts[:response_body_handler] = block if block_given?
+      self.connection.execute(opts)
+    end
+  end
+end

data/lib/streamly_ffi/persistent_request.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "curl_ffi"
+
+module StreamlyFFI
+  class PersistentRequest
+    include StreamlyFFI::Base
+
+    def [](_sym)
+        send _sym
+    end
+
+  end
+end

data/lib/streamly_ffi/request.rb

@@ -7,157 +7,14 @@ require "singleton"
 module StreamlyFFI
   class Request
     include Singleton
+    include StreamlyFFI::Base
 
-    alias __method__ method
-
-    attr_reader :url, :method
-
-    # @TODO: Argumenting Checking + Error Handling
     def initialize(options={})
-      url     = options[:url]
-      method  = options[:method]
-      
-      @response_body          = nil
-      @response_header        = nil
-      @custom_header_handler  = nil
-      @custom_write_handler   = nil
-
-      # url should be a string that doesn't suck
-      # method should be :post, :get, :put, :delete, :head
-      # options should contain any of the following keys:
-      #   :headers, :response_header_handler, :response_body_handler, :payload (required if method = :post / :put)
-
-      case method
-      when :get     then  connection.setopt :HTTPGET,        1
-      when :head    then  connection.setopt :NOBODY,         1
-      when :post    then  connection.setopt :POST,           1
-                          connection.setopt :POSTFIELDS,     options[:payload]
-                          connection.setopt :POSTFIELDSIZE,  options[:payload].size
-      when :put     then  connection.setopt :CUSTOMREQUEST,  "PUT"
-                          connection.setopt :POSTFIELDS,     options[:payload]
-                          connection.setopt :POSTFIELDSIZE,  options[:payload].size
-      when :delete  then  connection.setopt :CUSTOMREQUEST,  "DELETE"
-      # else I WILL CUT YOU
-      end
-
-      if options[:headers].is_a? Hash and options[:headers].size > 0
-        options[:headers].each_pair do |key_and_value|
-          request_headers = CurlFFI.slist_append(request_headers, key_and_value.join(": "))
-        end
-        connection.setopt :HTTPHEADER, request_headers
-      end
-
-      @custom_header_handler  = options[:response_header_handler] if options.has_key?(:response_header_handler)
-      @custom_write_handler   = options[:response_body_handler]   if options.has_key?(:response_body_handler)
-
-      default_header_handler
-      default_write_handler
-
-      
-      connection.setopt :ENCODING,        "identity, deflate, gzip" unless method == :head
-      connection.setopt :URL,             url
-
-      # Other common options (blame streamly guy)
-      connection.setopt :FOLLOWLOCATION,  1
-      connection.setopt :MAXREDIRS,       3
-      # @TODO: This should be an option
-      connection.setopt :SSL_VERIFYPEER,  0
-      connection.setopt :SSL_VERIFYHOST,  0
-
-      connection.setopt :ERRORBUFFER,     error_buffer
-
-      return self # I am a terrible hack. I should abandon the singleton
-    end
-
-    def connection
-      @connection ||= CurlFFI::Easy.new
-    end
-
-    def error_buffer
-      @error_buffer ||= FFI::MemoryPointer.new(:char, CurlFFI::ERROR_SIZE, :clear)
+      self.set_options(options)
     end
-    
-    def request_headers
-      @request_headers ||= FFI::MemoryPointer.from_string("")
-    end
-    
-    def response_body
-      @response_body ||= ""
-    end
-    
-    def response_header
-      @response_header ||= ""
-    end
-
-    def execute
-      status = connection.perform
-
-      # @TODO: Intelligent error stuff
-#      raise Streamly::Error if status 
 
-      CurlFFI.slist_free_all(@request_headers) if @request_headers
-
-      @connection.reset
-    end
-    
     def self.execute(options={})
-      request = new(options)
-
-      request.execute
-
-      return nil if(options.has_key?(:response_header_handler) or options.has_key?(:response_body_handler))
-
-      resp  = if(options[:method] == :head && request.response_header.respond_to?(:to_str))
-                request.response_header
-              elsif(request.response_body.is_a?(String))
-                request.response_body
-              else
-                nil
-              end
-
-      return resp
-    end
-
-    def default_write_handler
-      connection.setopt(:WRITEFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t,], &self.__method__(:write_callback)))
-    end
-
-    def default_header_handler
-      connection.setopt(:HEADERFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t], &self.__method__(:header_callback)))
+      new(options).execute
     end
-
-    def write_callback(string_ptr, size, nmemb)
-      length = size * nmemb
-
-      if(@custom_write_handler)
-        @custom_write_handler.call(string_ptr.read_string(length))
-      else
-        response_body << string_ptr.read_string(length)
-      end
-
-      return length
-    end
-
-    def header_callback(string_ptr, size, nmemb)
-      length = size * nmemb
-
-      if(@custom_header_handler)
-        @custom_header_handler.call(string_ptr.read_string(length))
-      else
-        response_header << string_ptr.read_string(length)
-      end
-
-      return length
-    end
-
-  # streamly's .c internal methods:
-  # @TODO: header_handler
-  # @TODO: data_handler
-  # @TODO: each_http_header
-  # @TODO: select_error
-  # @TODO: rb_streamly_new
-  # @TODO: rb_streamly_init
-  # @TODO: nogvl_perform
-  # @TODO: rb_streamly_execute
   end
 end

data/lib/streamly_ffi/version.rb

@@ -1,3 +1,3 @@
 module StreamlyFFI
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

data/streamly_ffi.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.email           = %q{seniorlopez@gmail.com}
   s.homepage        = %q{http://github.com/aitrus/streamly_ffi}
 
-  s.platform        = Gem::Platform::RUBY
   s.add_dependency    "curl_ffi"
   s.add_development_dependency "rspec"
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 6
-  version: 0.1.6
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Brian Lopez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-09 00:00:00 -08:00
+date: 2010-11-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,6 +56,8 @@ files:
 - .gitignore
 - .rspec
 - CHANGELOG.md
+- Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
@@ -76,6 +78,9 @@ files:
 - ext/streamly.c
 - ext/streamly.h
 - lib/streamly_ffi.rb
+- lib/streamly_ffi/base.rb
+- lib/streamly_ffi/connection.rb
+- lib/streamly_ffi/persistent_request.rb
 - lib/streamly_ffi/request.rb
 - lib/streamly_ffi/version.rb
 - spec/server.rb