curl_ffi 0.0.5 → 0.0.6

data/lib/bindings.rb

@@ -28,10 +28,6 @@ module CurlFFI
   INFO_DOUBLE           = 0x300000
   INFO_SLIST            = 0x400000
 
-
-
-
-
   CODE = enum :code, [
     :OK,                        0,
     :UNSUPPORTED_PROTOCOL,      1,
@@ -997,4 +993,9 @@ module CurlFFI
 
   attach_function :slist_append, :curl_slist_append, [:pointer, :string], :pointer
   attach_function :slist_free_all, :curl_slist_free_all, [:pointer], :void
+
+  class CurlSlist < FFI::Struct
+    layout  :data, :string,
+            :next, :pointer
+  end
 end

data/lib/curl_ffi/version.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Arthur Schreiber
@@ -67,8 +67,6 @@ 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

data/lib/streamly/request.rb

@@ -1,136 +0,0 @@
-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/lib/streamly.rb

@@ -1,124 +0,0 @@
-$:.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