curl_ffi 0.0.3 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    curl_ffi (0.0.2)
+    curl_ffi (0.0.4)
       ffi
 
 GEM

data/Rakefile

@@ -13,7 +13,6 @@ task :gem => :gemspec
 desc %{Build the gemspec file.}
 task :gemspec do
   gemspec.validate
-  File.open("#{gemspec.name}.gemspec", 'w'){|f| f.write gemspec.to_ruby }
 end
 
 desc %{Release the gem to RubyGems.org}

data/curl_ffi.gemspec

@@ -1,34 +1,24 @@
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "curl_ffi/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{curl_ffi}
-  s.version = "0.0.3"
+  s.name        = "curl_ffi"
+  s.version     = CurlFFI::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Arthur Schreiber", "Scott Gonyea"]
+  s.email       = ["schreiber.arthur@gmail.com"]
+  s.homepage    = "http://github.com/nokarma/curl-ffi"
+  s.summary     = "An FFI based libCurl interface"
+  s.description = "An FFI based libCurl interface, intended to serve as a common backend for existing interfaces to libcurl"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Arthur Schreiber", "Scott Gonyea"]
-  s.date = %q{2010-11-06}
-  s.description = %q{An FFI based libCurl interface, intended to serve as a common backend for existing interfaces to libcurl}
-  s.email = ["schreiber.arthur@gmail.com"]
-  s.files = [".gitignore", "Gemfile", "Gemfile.lock", "Rakefile", "curl_ffi.gemspec", "examples/evented_multi.rb", "examples/perform_multi.rb", "examples/select_multi.rb", "lib/bindings.rb", "lib/curl_ffi.rb", "lib/curl_ffi/easy.rb", "lib/curl_ffi/multi.rb", "lib/curl_ffi/version.rb", "spec/curl_ffi/easy_spec.rb", "spec/curl_ffi/multi_spec.rb", "spec/spec_helper.rb"]
-  s.homepage = %q{http://github.com/nokarma/curl-ffi}
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{curl-ffi}
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{An FFI based libCurl interface}
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "curl-ffi"
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.add_dependency "ffi"
+  s.add_development_dependency "rspec"
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ffi>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<ffi>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<ffi>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-  end
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
 end

data/lib/bindings.rb

@@ -14,6 +14,8 @@ module CurlFFI
     SOCKET_BAD = -1
   end
 
+  ERROR_SIZE            = 256 + 1
+
   SOCKET_TIMEOUT        = SOCKET_BAD
 
   OPTION_LONG           = 0
@@ -889,9 +891,6 @@ module CurlFFI
     :LOCAL_PORT,              INFO_LONG   + 42
   ]
 
-
-
-
   class MessageData < FFI::Union
     layout  :whatever,  :pointer,
             :result,    :code
@@ -905,6 +904,10 @@ module CurlFFI
 
   # Returns a char * - needs to be freed manually using curl_free
   attach_function :easy_escape, :curl_easy_escape, [:pointer, :string, :int], :pointer
+  # Returns a char * - needs to be freed manually using curl_free
+  attach_function :easy_unescape, :curl_easy_unescape, [:pointer, :string, :int, :pointer], :pointer
+
+
   attach_function :easy_init, :curl_easy_init, [], :pointer
   attach_function :easy_cleanup, :curl_easy_cleanup, [:pointer], :void
   attach_function :easy_duphandle, :curl_easy_duphandle, [:pointer], :pointer
@@ -919,6 +922,13 @@ module CurlFFI
   attach_function :easy_setopt_string, :curl_easy_setopt, [:pointer, :option, :string], :code
   attach_function :easy_setopt_pointer, :curl_easy_setopt, [:pointer, :option, :pointer], :code
   attach_function :easy_setopt_curl_off_t, :curl_easy_setopt, [:pointer, :option, :curl_off_t], :code
+  attach_function :easy_strerror, :curl_easy_strerror, [:code], :string
+
+  callback :handler_function, [:string, :size_t, :size_t, :pointer], :size_t
+  attach_function :easy_setopt_handler_function, :curl_easy_setopt, [:pointer, :option, :handler_function], :code
+
+  callback :handler_string, [:string, :size_t, :size_t, :string], :size_t
+  attach_function :easy_setopt_handler_string, :curl_easy_setopt, [:pointer, :option, :handler_string], :code
 
   def self.easy_setopt(handle, option, value)
     option = OPTION[option] if option.is_a?(Symbol)
@@ -938,10 +948,15 @@ module CurlFFI
     end
   end
 
-  attach_function :easy_strerror, :curl_easy_strerror, [:code], :string
+  # @TODO: checking to ensure that value is a proc?
+  def self.easy_setopt_handler(handle, option, value)
+    option = OPTION[option] if option.is_a?(Symbol)
+
+    if option >= OPTION_FUNCTIONPOINT
+      self.easy_setopt_handler_function(handle, option, value)
+    end
+  end
 
-  # Returns a char * that has to be freed using curl_free
-  attach_function :easy_unescape, :curl_easy_unescape, [:pointer, :string, :int, :pointer], :pointer
   attach_function :multi_add_handle, :curl_multi_add_handle, [:pointer, :pointer], :multi_code
   attach_function :multi_assign, :curl_multi_assign, [:pointer, :curl_socket_t, :pointer], :multi_code
   attach_function :multi_cleanup, :curl_multi_cleanup, [:pointer], :void
@@ -956,6 +971,10 @@ module CurlFFI
   attach_function :multi_setopt_pointer, :curl_multi_setopt, [:pointer, :multi_option, :pointer], :multi_code
   attach_function :multi_setopt_curl_off_t, :curl_multi_setopt, [:pointer, :multi_option, :curl_off_t], :multi_code
 
+  attach_function :multi_socket_action, :curl_multi_socket_action, [:pointer, :curl_socket_t, :int, :pointer], :multi_code
+  attach_function :multi_strerror, :curl_multi_strerror, [:multi_code], :string
+  attach_function :multi_timeout, :curl_multi_timeout, [:pointer, :pointer], :multi_code
+
   def self.multi_setopt(handle, option, value)
     option = MULTI_OPTION[option] if option.is_a?(Symbol)
 
@@ -974,10 +993,6 @@ module CurlFFI
     end
   end
 
-  attach_function :multi_socket_action, :curl_multi_socket_action, [:pointer, :curl_socket_t, :int, :pointer], :multi_code
-  attach_function :multi_strerror, :curl_multi_strerror, [:multi_code], :string
-  attach_function :multi_timeout, :curl_multi_timeout, [:pointer, :pointer], :multi_code
-
   attach_function :free, :curl_free, [:pointer], :void
 
   attach_function :slist_append, :curl_slist_append, [:pointer, :string], :pointer

data/lib/curl_ffi.rb

@@ -1,3 +1,5 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require "ffi"
 require "bindings"

data/lib/curl_ffi/easy.rb

@@ -2,6 +2,7 @@ require "curl_ffi"
 
 module CurlFFI
   class Easy
+
     attr_reader :pointer
 
     def initialize
@@ -43,6 +44,14 @@ module CurlFFI
       check_code(CurlFFI.easy_setopt(@pointer, option, value))
     end
 
+    def setopt_handler(option, value)
+      check_code(CurlFFI.easy_setopt_handler(@pointer, option, value))
+    end
+
+    def setopt_str_handler(option, value)
+      check_code(CurlFFI.easy_setopt_handler_string(@pointer, option, value))
+    end
+
     def getinfo(info)
       info = INFO[info] if info.is_a?(Symbol)
 
@@ -59,9 +68,11 @@ module CurlFFI
 
     protected
       def check_code(result)
+        
         if result != :OK
-          raise "Error - #{result}"
+          raise "Error - #{result}" unless result.nil?
         end
+        return result
       end
 
       def getinfo_double(info)

data/lib/curl_ffi/multi.rb

@@ -2,6 +2,7 @@ require "curl_ffi"
 
 module CurlFFI
   class Multi
+
     attr_reader :pointer, :running
 
     def initialize

data/lib/curl_ffi/version.rb

@@ -1,3 +1,3 @@
 module CurlFFI
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/lib/streamly.rb

@@ -0,0 +1,124 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "ffi"
+require "curl_ffi"
+
+module Streamly
+  extend FFI::Library
+
+  autoload :Request, "streamly/request"
+
+  class Error               < StandardError; end
+  class UnsupportedProtocol < StandardError; end
+  class URLFormatError      < StandardError; end
+  class HostResolutionError < StandardError; end
+  class ConnectionFailed    < StandardError; end
+  class PartialFileError    < StandardError; end
+  class TimeoutError        < StandardError; end
+  class TooManyRedirects    < StandardError; 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 self.head(url, headers=nil, &block)
+    opts = {:method => :head, :url => url, :headers => headers}
+    opts.merge!({:response_header_handler => block}) if block_given?
+    Request.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 self.get(url, headers=nil, &block)
+    opts = {:headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(url, :get, 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 self.post(url, payload, headers=nil, &block)
+    opts = {:payload => payload, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(url, :post, 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 self.put(url, payload, headers=nil, &block)
+    opts = {:payload => payload, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(url, :put, 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 self.delete(url, headers={}, &block)
+    opts = {:method => :delete, :url => url, :headers => headers}
+    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

data/lib/streamly/request.rb

@@ -0,0 +1,136 @@
+require "ffi"
+require "singleton"
+
+module Streamly
+  class Request
+    include Singleton
+
+    attr_reader :response_header_handler, :response_body_handler
+
+    CallHandler = Proc.new do |stream, size, nmemb, handler|
+      handler.call(stream)
+      size * nmemb
+    end
+
+    StringHandler = Proc.new do |stream, size, nmemb, handler|
+      if handler.nil?
+        handler = stream.clone
+      else
+        handler << stream
+      end
+      size * nmemb
+    end
+
+    DataHandler = Proc.new do |stream, size, nmemb, handler|
+      case handler
+      when  String  then  handler << stream
+      else                handler.call(stream)
+      end
+      size * nmemb
+    end
+
+    # @TODO: Argumenting Checking + Error Handling
+    def initialize(url, method=:get, options={})
+      # 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)
+
+#      @response_header_handler  ||= options[:response_header_handler] || FFI::MemoryPointer.from_string("")
+#      @response_body_handler    ||= options[:response_body_handler]   || FFI::MemoryPointer.from_string("")
+
+      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
+
+      if options[:response_header_handler].nil?
+#        @response_header_handler = FFI::MemoryPointer.from_string("")
+        @response_header_handler = FFI::MemoryPointer.new(:pointer)
+        connection.setopt_str_handler :HEADERFUNCTION,  StringHandler
+        connection.setopt_str_handler :WRITEHEADER,     @response_header_handler
+      else
+        @response_header_handler = options[:response_header_handler]
+        connection.setopt_handler :HEADERFUNCTION,  CallHandler
+        connection.setopt_handler :WRITEHEADER,     @response_header_handler
+      end
+
+      unless method == :head
+        connection.setopt :ENCODING,  "identity, deflate, gzip"
+
+        if options[:response_body_handler].nil?
+#          @response_body_handler = FFI::MemoryPointer.from_string("")
+          @response_body_handler = FFI::MemoryPointer.new(:pointer)
+          connection.setopt_str_handler :WRITEFUNCTION, StringHandler
+          connection.setopt_str_handler :FILE,          @response_body_handler
+        else
+          @response_body_handler = options[:response_body_handler]
+          connection.setopt_handler :WRITEFUNCTION, CallHandler
+          connection.setopt_handler :FILE,          @response_body_handler
+        end
+      end
+
+      connection.setopt :URL,            FFI::MemoryPointer.from_string(url)
+
+      # Other common options (blame streamly guy)
+      connection.setopt :FOLLOWLOCATION, 1
+      connection.setopt :MAXREDIRS,      3
+
+      # This should be an option
+      connection.setopt :SSL_VERIFYPEER, 0
+      connection.setopt :SSL_VERIFYHOST, 0
+
+      connection.setopt :ERRORBUFFER,    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
+    
+    def request_headers
+      @request_headers ||= FFI::MemoryPointer.from_string("")
+    end
+=begin
+
+=end
+    def execute
+      connection.perform
+      return response_body_handler
+    end
+    
+    def self.execute(url, method=:get, options={})
+      new(url, method, options).execute
+    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/spec/curl_ffi/multi_spec.rb

@@ -26,7 +26,7 @@ describe CurlFFI::Multi do
       end
 
       it "should return CurlFFI::Message objects when messages are available" do
-        @easy.setopt(CurlFFI::OPTION[:URL], "http://google.de")
+        @easy.setopt(CurlFFI::OPTION[:URL], "http://www.google.de/")
         @multi.add_handle(@easy)
 
         @multi.perform while @multi.running != 0
@@ -42,7 +42,7 @@ describe CurlFFI::Multi do
       end
 
       it "should return an array of CurlFFI::Message objects when messages are available" do
-        @easy.setopt(CurlFFI::OPTION[:URL], "http://google.de")
+        @easy.setopt(CurlFFI::OPTION[:URL], "http://www.google.de/")
         @multi.add_handle(@easy)
 
         @multi.perform while @multi.running != 0
@@ -60,7 +60,7 @@ describe CurlFFI::Multi do
       end
 
       it "should return the timeout till the next call to #perform" do
-        @easy.setopt(CurlFFI::OPTION[:URL], "http://google.de")
+        @easy.setopt(CurlFFI::OPTION[:URL], "http://www.google.de/")
         @multi.add_handle(@easy)
 
         @multi.timeout.should == 1
@@ -71,7 +71,7 @@ describe CurlFFI::Multi do
 
     describe "#perform" do
       before :each do
-        @easy.setopt(CurlFFI::OPTION[:URL], "http://google.de")
+        @easy.setopt(CurlFFI::OPTION[:URL], "http://www.google.de/")
         @multi.add_handle(@easy)
       end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Arthur Schreiber
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-06 00:00:00 -07:00
+date: 2010-11-08 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,6 +67,8 @@ files:
 - lib/curl_ffi/easy.rb
 - lib/curl_ffi/multi.rb
 - lib/curl_ffi/version.rb
+- lib/streamly.rb
+- lib/streamly/request.rb
 - spec/curl_ffi/easy_spec.rb
 - spec/curl_ffi/multi_spec.rb
 - spec/spec_helper.rb