carnivore-http 0.1.4 → 0.1.6

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.1.6
+* Add support for point builder subclassing
+* DRY out message generation to be consistent between http and endpoint
+* Set max size on body and store in temp file if > max size
+
 # v0.1.4
 * Include custom `connect` to start source
 * Pull query from body if found

data/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+# Contributing
+
+## Branches
+
+### `master` branch
+
+The master branch is the current stable released version.
+
+### `develop` branch
+
+The develop branch is the current edge of development.
+
+## Pull requests
+
+* https://github.com/carnivore-rb/carnivore-http/pulls
+
+Please base all pull requests of the `develop` branch. Merges to
+`master` only occur through the `develop` branch. Pull requests
+based on `master` will likely be cherry picked.
+
+## Issues
+
+Need to report an issue? Use the github issues:
+
+* https://github.com/carnivore-rb/carnivore-http/issues

data/Gemfile.lock

@@ -1,48 +1,44 @@
 PATH
   remote: .
   specs:
-    carnivore-http (0.1.3)
+    carnivore-http (0.1.5)
       blockenspiel
       carnivore (>= 0.1.8)
-      reel
-
-PATH
-  remote: ../carnivore
-  specs:
-    carnivore (0.1.11)
-      celluloid
-      mixlib-config
-      multi_json
+      reel (~> 0.5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     blockenspiel (0.4.5)
+    carnivore (0.2.2)
+      celluloid
+      hashie
+      mixlib-config
+      multi_json
     celluloid (0.15.2)
       timers (~> 1.1.0)
     celluloid-io (0.15.0)
       celluloid (>= 0.15.0)
       nio4r (>= 0.5.0)
-    http (0.5.0)
-      http_parser.rb
-    http_parser.rb (0.6.0.beta.2)
-    mixlib-config (2.0.0)
-    multi_json (1.8.2)
-    nio4r (0.5.0)
-    reel (0.4.0)
+    hashie (2.1.1)
+    http (0.6.0)
+      http_parser.rb (~> 0.6.0)
+    http_parser.rb (0.6.0)
+    mixlib-config (2.1.0)
+    multi_json (1.10.0)
+    nio4r (1.0.0)
+    reel (0.5.0)
       celluloid (>= 0.15.1)
       celluloid-io (>= 0.15.0)
-      http (>= 0.5.0)
-      http_parser.rb (>= 0.6.0.beta.2)
-      websocket_parser (>= 0.1.4)
+      http (>= 0.6.0.pre)
+      http_parser.rb (>= 0.6.0)
+      websocket_parser (>= 0.1.6)
     timers (1.1.0)
-    websocket_parser (0.1.4)
-      http
+    websocket_parser (0.1.6)
 
 PLATFORMS
   java
   ruby
 
 DEPENDENCIES
-  carnivore!
   carnivore-http!

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2014 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/carnivore-http.gemspec

@@ -8,9 +8,10 @@ Gem::Specification.new do |s|
   s.email = 'chrisroberts.code@gmail.com'
   s.homepage = 'https://github.com/carnivore-rb/carnivore-http'
   s.description = 'Carnivore HTTP source'
+  s.license = 'Apache 2.0'
   s.require_path = 'lib'
   s.add_dependency 'carnivore', '>= 0.1.8'
-  s.add_dependency 'reel'
+  s.add_dependency 'reel', '~> 0.5.0'
   s.add_dependency 'blockenspiel'
   s.files = Dir['**/*']
 end

data/lib/carnivore-http.rb

@@ -1,5 +1,23 @@
 require 'carnivore-http/version'
 require 'carnivore'
+require 'multi_json'
+
+module Carnivore
+  # HTTP namespace
+  module Http
+    autoload :PointBuilder, 'carnivore-http/point_builder'
+  end
+
+  class Source
+    autoload :Http, 'carnivore-http/http'
+    autoload :HttpEndpoints, 'carnivore-http/http_endpoints'
+  end
+
+  autoload :Utils, 'carnivore-http/utils'
+
+  # Compat for old naming
+  autoload :PointBuilder, 'carnivore-http/point_builder'
+end
 
 Carnivore::Source.provide(:http, 'carnivore-http/http')
 Carnivore::Source.provide(:http_endpoints, 'carnivore-http/http_endpoints')

data/lib/carnivore-http/http.rb

@@ -1,31 +1,45 @@
 require 'reel'
+require 'tempfile'
 require 'carnivore/source'
 require 'carnivore-http/utils'
 
 module Carnivore
   class Source
 
+    # Carnivore HTTP source
     class Http < Source
 
       include Carnivore::Http::Utils::Params
 
+      # @return [Hash] source arguments
       attr_reader :args
 
+      # Setup the source
+      #
+      # @params args [Hash] setup arguments
       def setup(args={})
         @args = default_args(args)
       end
 
-      def default_args(args)
-        {
+      # Default configuration arguments. If hash is provided, it
+      # will be merged into the default arguments.
+      #
+      # @param args [Hash]
+      # @return [Hash]
+      def default_args(args={})
+        Smash.new(
           :bind => '0.0.0.0',
           :port => '3000',
           :auto_respond => true
-        }.merge(args)
+        ).merge(args)
       end
 
-      # Transmit can be one of two things:
-      # 1. Response back to an open connection
-      # 2. Request to a remote source
+      # Tranmit message. The transmission can be a response
+      # back to an open connection, or a request to a remote
+      # source (remote carnivore-http source generally)
+      #
+      # @param message [Object] message to transmit
+      # @param extras [Object] argument list
       def transmit(message, *extra)
         options = extra.detect{|x| x.is_a?(Hash)} || {}
         orig = extra.detect{|x| x.is_a?(Carnivore::Message)}
@@ -52,40 +66,74 @@ module Carnivore
         end
       end
 
+      # Confirm processing of message
+      #
+      # @param message [Carnivore::Message]
+      # @param args [Hash]
+      # @option args [Symbol] :code return code
       def confirm(message, args={})
-        if(args[:response_body] || args[:code])
-          debug "Confirming #{message} with: #{args.inspect}"
-          message[:message][:connection].respond(
-            args[:code] || :ok, args[:response_body] || 'Thanks!'
-          )
-        else
-          debug "Confirming #{message}. No arguments provided so no response taken."
-        end
+        code = args.delete(:code) || :ok
+        args[:response_body] = 'Thanks' if code == :ok && args.empty?
+        debug "Confirming #{message} with: Code: #{code.inspect} Args: #{args.inspect}"
+        message[:message][:request].respond(code, args[:response_body] || args)
       end
 
+      # Process requests
       def process(*process_args)
-        srv = Reel::Server.supervise(args[:bind], args[:port]) do |con|
-          while(req = con.request)
+        srv = Reel::Server::HTTP.supervise(args[:bind], args[:port]) do |con|
+          con.each_request do |req|
             begin
-              msg = format(
-                :request => req,
-                :body => req.body.to_s,
-                :connection => con,
-                :query => parse_query_string(req.query_string)
-              )
+              msg = build_message(con, req)
               callbacks.each do |name|
                 c_name = callback_name(name)
                 debug "Dispatching #{msg} to callback<#{name} (#{c_name})>"
-                callback_supervisor[c_name].async.call(msg)
+                callback_supervisor[c_name].call(msg)
               end
-              con.respond(:ok, 'So long, and thanks for all the fish!') if args[:auto_respond]
+              req.respond(:ok, 'So long, and thanks for all the fish!') if args[:auto_respond]
             rescue => e
-              con.respond(:bad_request, 'Failed to process request')
+              req.respond(:bad_request, "Failed to process request -> #{e}")
             end
           end
         end
       end
 
+      # Size limit for inline body
+      BODY_TO_FILE_SIZE = 1024 * 10 # 10K
+
+      # Build message hash from request
+      #
+      # @param con [Reel::Connection]
+      # @param req [Reel::Request]
+      # @return [Hash]
+      # @note
+      #   if body size is greater than BODY_TO_FILE_SIZE
+      #   the body will be a temp file instead of a string
+      def build_message(con, req)
+        msg = Smash.new(
+          :request => req,
+          :headers => req.headers,
+          :connection => con,
+          :query => parse_query_string(req.query_string)
+        )
+        if(req.headers['Content-Type'] == 'application/json')
+          msg[:query].merge(
+            parse_query_string(
+              req.body.to_s
+            )
+          )
+          msg[:body] = req.body.to_s
+        elsif(req.headers['Content-Length'].to_i > BODY_TO_FILE_SIZE)
+          msg[:body] = Tempfile.new('carnivore-http')
+          while((chunk = req.body.readpartial(2048)))
+            msg[:body] << chunk
+          end
+          msg[:body].rewind
+        else
+          msg[:body] = req.body.to_s
+        end
+        format(msg)
+      end
+
     end
 
   end

data/lib/carnivore-http/http_endpoints.rb

@@ -3,10 +3,17 @@ require 'carnivore-http/point_builder'
 
 module Carnivore
   class Source
+
+    # Carnivore HTTP end points source
     class HttpEndpoints < Http
 
       class << self
 
+        # Register endpoint
+        #
+        # @param args [Hash]
+        # @option args [String] :name
+        # @option args [String] :base_path
         def register(args={})
           args = Hash[*(
               args.map do |k,v|
@@ -21,10 +28,15 @@ module Carnivore
           self
         end
 
+        # @return [Hash] point builders registered
         def builders
           @point_builders ||= {}
         end
 
+        # Load the named builder
+        #
+        # @param name [String] name of builder
+        # @return [self]
         def load_builder(name)
           if(builders[name.to_sym])
             require File.join(builders[name.to_sym], name)
@@ -34,6 +46,9 @@ module Carnivore
           self
         end
 
+        # Setup the builders
+        #
+        # @return [TrueClass]
         def setup!
           only = Carnivore::Config.get(:http_endpoints, :only)
           except = Carnivore::Config.get(:http_endpoints, :except)
@@ -48,40 +63,45 @@ module Carnivore
 
       end
 
+      # @return [Hash] point builders
       attr_reader :points
 
+      # Setup the registered endpoints
+      #
+      # @param args [Hash]
+      # @option args [String, Symbol] :config_key
       def setup(args={})
         super
         @conf_key = (args[:config_key] || :http_endpoints).to_sym
         set_points
       end
 
+      # Start processing
       def connect
         async.process
       end
 
+      # Process requests
       def process(*process_args)
-        srv = Reel::Server.supervise(args[:bind], args[:port]) do |con|
+        srv = Reel::Server::HTTP.supervise(args[:bind], args[:port]) do |con|
           con.each_request do |req|
             begin
-              msg = format(
-                :request => req,
-                :body => req.body.to_s,
-                :connection => con,
-                :query => parse_query_string(req.query_string).merge(parse_query_string(req.body.to_s))
-              )
+              msg = build_message(con, req)
               unless(@points.deliver(msg))
-                con.respond(:ok, 'So long, and thanks for all the fish!')
+                req.respond(:ok, 'So long, and thanks for all the fish!')
               end
             rescue => e
               error "Failed to process message: #{e.class} - #{e}"
               debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-              con.respond(:bad_request, 'Failed to process request')
+              req.respond(:bad_request, 'Failed to process request')
             end
           end
         end
       end
 
+      # Build the endpoints and set
+      #
+      # @return [self]
       def set_points
         @points = PointBuilder.new(
           :only => Carnivore::Config.get(@conf_key, :only),

data/lib/carnivore-http/point_builder.rb

@@ -4,161 +4,274 @@ require 'carnivore/utils'
 require 'celluloid'
 
 module Carnivore
-  class PointBuilder
+  module Http
 
-    class Endpoint
+    # End point builder
+    class PointBuilder
 
-      include Celluloid
-      include Carnivore::Utils::Params
-      include Carnivore::Utils::Logging
+      # End point
+      class Endpoint
 
-      attr_reader :endpoint, :type
+        include Celluloid
+        include Carnivore::Utils::Params
+        include Carnivore::Utils::Logging
 
-      def initialize(type, endpoint, block)
-        @endpoint = endpoint
-        @type = type
-        define_singleton_method(:execute, &block)
-      end
+        # @return [String, Regexp] request path matcher
+        attr_reader :endpoint
+        # @return [Symbol] request type (:get, :put, etc.)
+        attr_reader :type
 
-      def to_s
-        "<Endpoint[#{endpoint}]>"
-      end
+        # Create new endoint
+        #
+        # @param type [Symbol] request type (:get, :put, etc.)
+        # @param endpoint [String, Regexp] request path matcher
+        # @param block [Proc] action to run on match
+        def initialize(type, endpoint, block)
+          @endpoint = endpoint
+          @type = type
+          define_singleton_method(:wrapped_execute, &block)
+        end
 
-      def inspect
-        "<Endpoint[#{endpoint}] type=#{type} objectid=#{self.object_id}>"
-      end
+        # Execute action on match
+        #
+        # @param args [Object] argument list
+        def execute(*args)
+          begin
+            wrapped_execute(*args)
+          rescue => e
+            error "Unexpected error encountered! #{e.class}: #{e}"
+            debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+            abort e
+          end
+        end
 
-    end
+        # @return [String] stringify
+        def to_s
+          "<Endpoint[#{endpoint}]>"
+        end
 
-    include Carnivore::Utils::Params
-    include Celluloid::Logger
-    include Blockenspiel::DSL
+        # @return [String] instance inspection
+        def inspect
+          "<Endpoint[#{endpoint}] type=#{type} objectid=#{self.object_id}>"
+        end
 
-    attr_reader :static, :regex, :only, :except, :endpoint_supervisor
+      end
 
-    def initialize(args)
-      @only = args[:only]
-      @except = args[:except]
-      @static = {}
-      @regex = {}
-      @callback_names = {}
-      @endpoint_supervisor = Carnivore::Supervisor.create!.last
-      load_endpoints!
-    end
+      include Carnivore::Utils::Params
+      include Celluloid::Logger
+      include Blockenspiel::DSL
 
-    [:get, :put, :post, :delete, :head, :options, :trace].each do |name|
-      define_method(name) do |regexp_or_string, args={}, &block|
-        endpoint(name, regexp_or_string, args, &block)
+      # @return [Hash] static path endpoints
+      attr_reader :static
+      # @return [Hash] regex path endpoints
+      attr_reader :regex
+      # @return [Array] only enable endpoints
+      attr_reader :only
+      # @return [Array] do not enable endpoints
+      attr_reader :except
+      # @return [Carnivore::Supervisor] supervisor
+      attr_reader :endpoint_supervisor
+
+      # Create new instance
+      #
+      # @param args [Hash]
+      # @option args [Array] :only
+      # @option args [Array] :except
+      def initialize(args={})
+        @only = args[:only]
+        @except = args[:except]
+        @static = {}
+        @regex = {}
+        @callback_names = {}
+        @endpoint_supervisor = Carnivore::Supervisor.create!.last
+        load_endpoints!
       end
-    end
 
-    dsl_methods false
+      # Request methods
+      # @todo add yardoc method generation
+      [:get, :put, :post, :delete, :head, :options, :trace].each do |name|
+        define_method(name) do |regexp_or_string, args={}, &block|
+          endpoint(name, regexp_or_string, args, &block)
+        end
+      end
 
-    def deliver(msg)
-      type = msg[:message][:request].method.to_s.downcase.to_sym
-      path = msg[:message][:request].url
-      static_points(msg, type, path) || regex_points(msg, type, path)
-    end
+      dsl_methods false
 
-    def static_points(msg, type, path)
-      if(static[type])
-        match = static[type].keys.detect do |point|
-          !path.scan(/^#{Regexp.escape(point)}\/?(\?|$)/).empty?
-        end
-        if(match)
-          if(static[type][match][:async])
-            endpoint_supervisor[callback_name(match, type)].async.execute(msg)
-            true
-          else
-            endpoint_supervisor[callback_name(match, type)].execute(msg)
-            true
-          end
-        end
+      # Deliver message to end points
+      #
+      # @param msg [Carnivore::Message]
+      # @return [Truthy, Falsey]
+      def deliver(msg)
+        type = msg[:message][:request].method.to_s.downcase.to_sym
+        path = msg[:message][:request].url
+        static_points(msg, type, path) || regex_points(msg, type, path)
       end
-    end
 
-    def regex_points(msg, type, path)
-      if(regex[type])
-        match = regex[type].keys.map do |point|
-          unless((res = path.scan(/^(#{point})(\?|$)/)).empty?)
-            res = res.first
-            res.pop # remove empty EOS match
-            [point, res]
+      # Apply message to static endpoints and execute if matching
+      #
+      # @param msg [Carnivore::Message]
+      # @param type [Symbol] request type
+      # @param path [String] request path
+      # @param [Truthy, Falsey] match was detected and executed
+      def static_points(msg, type, path)
+        if(static[type])
+          match = static[type].keys.detect do |point|
+            !path.scan(/^#{Regexp.escape(point)}\/?(\?|$)/).empty?
           end
-        end.compact.first
-        if(match && !match.empty?)
-          if(regex[type][match.first][:async])
-            endpoint_supervisor[callback_name(match.first, type)].async.execute(*([msg] + match.last))
-            true
-          else
-            endpoint_supervisor[callback_name(match.first, type)].execute(*([msg] + match.last))
-            true
+          if(match)
+            if(static[type][match][:async])
+              endpoint_supervisor[callback_name(match, type)].async.execute(msg)
+              true
+            else
+              endpoint_supervisor[callback_name(match, type)].execute(msg)
+              true
+            end
           end
         end
       end
-    end
 
-    def callback_name(point, type)
-      key = "#{point}_#{type}"
-      unless(@callback_names[key])
-        @callback_names[key] = Digest::SHA256.hexdigest(key)
+      # Apply message to regex endpoints and execute if matching
+      #
+      # @param msg [Carnivore::Message]
+      # @param type [Symbol] request type
+      # @param path [String] request path
+      # @param [Truthy, Falsey] match was detected and executed
+      def regex_points(msg, type, path)
+        if(regex[type])
+          match = regex[type].keys.map do |point|
+            unless((res = path.scan(/^(#{point})(\?|$)/)).empty?)
+              res = res.first
+              res.pop # remove empty EOS match
+              [point, res]
+            end
+          end.compact.first
+          if(match && !match.empty?)
+            if(regex[type][match.first][:async])
+              endpoint_supervisor[callback_name(match.first, type)].async.execute(*([msg] + match.last))
+              true
+            else
+              endpoint_supervisor[callback_name(match.first, type)].execute(*([msg] + match.last))
+              true
+            end
+          end
+        end
       end
-      @callback_names[key]
-    end
 
-    def endpoint(request_type, regexp_or_string, args, &block)
-      request_type = request_type.to_sym
-      if(regexp_or_string.is_a?(Regexp))
-        regex[request_type] ||= {}
-        regex[request_type][regexp_or_string] = args
-      else
-        static[request_type] ||= {}
-        static[request_type][regexp_or_string.sub(%r{/$}, '')] = args
+      # Generate internal callback name reference
+      #
+      # @param point [String, Symbol]
+      # @param type [String, Symbol]
+      # @return [String]
+      def callback_name(point, type)
+        key = "#{point}_#{type}"
+        unless(@callback_names[key])
+          @callback_names[key] = Digest::SHA256.hexdigest(key)
+        end
+        @callback_names[key]
       end
-      if(args[:workers] && args[:workers].to_i > 1)
-        endpoint_supervisor.pool(Endpoint,
-          as: callback_name(regexp_or_string, request_type), size: args[:workers].to_i,
-          args: [request_type, regexp_or_string, block]
-        )
-      else
-        endpoint_supervisor.supervise_as(
-          callback_name(regexp_or_string, request_type), Endpoint, request_type, regexp_or_string, block
-        )
+
+      # Build new endpoint and supervise
+      #
+      # @param request_type [Symbol, String] request type (:get, :put, etc.)
+      # @param regexp_or_string [Regexp, String]
+      # @param args [Hash]
+      # @option args [Numeric] :workers number of workers to initialize
+      # @yield action to execute on match
+      def endpoint(request_type, regexp_or_string, args, &block)
+        request_type = request_type.to_sym
+        if(regexp_or_string.is_a?(Regexp))
+          regex[request_type] ||= {}
+          regex[request_type][regexp_or_string] = args
+        else
+          static[request_type] ||= {}
+          static[request_type][regexp_or_string.sub(%r{/$}, '')] = args
+        end
+        if(args[:workers] && args[:workers].to_i > 1)
+          endpoint_supervisor.pool(Endpoint,
+            as: callback_name(regexp_or_string, request_type), size: args[:workers].to_i,
+            args: [request_type, regexp_or_string, block]
+          )
+        else
+          endpoint_supervisor.supervise_as(
+            callback_name(regexp_or_string, request_type), Endpoint, request_type, regexp_or_string, block
+          )
+        end
+        true
       end
-      true
-    end
 
-    def endpoints
-      [static, regex]
-    end
+      # @return [Array] all endpoints
+      def endpoints
+        [static, regex]
+      end
 
-    private
+      private
 
-    def load_endpoints!
-      self.class.storage.each do |name, block|
-        next if only && !only.include?(name.to_s)
-        next if except && except.include?(name.to_s)
-        Blockenspiel.invoke(block, self)
+      # Load all available endpoints
+      #
+      # @note will register all discoverable subclasses
+      def load_endpoints!
+        self.class.compress_offspring.each do |name, block|
+          next if only && !only.include?(name.to_s)
+          next if except && except.include?(name.to_s)
+          Blockenspiel.invoke(block, self)
+        end
+        true
       end
-      true
-    end
 
-    class << self
-      def define(&block)
-        name = File.basename(
-          caller.first.match(%r{.*?:}).to_s.sub(':', '')
-        ).sub('.rb', '')
-        store(name, block)
-      end
+      class << self
 
-      def store(name, block)
-        storage[name.to_sym] = block
-        self
-      end
+        # Store subclass reference in descendants and
+        # setup properly for DSL usage
+        #
+        # @param klass [Class]
+        def inherited(klass)
+          descendants.push(klass)
+          klass.send(:include, Blockenspiel::DSL)
+        end
+
+        # Define new API block
+        #
+        # @yield new API block
+        def define(&block)
+          store(Celluloid.uuid, block)
+        end
+
+        # Store block
+        #
+        # @param name [String, Symbol]
+        # @param block [Proc]
+        def store(name, block)
+          storage[name.to_sym] = block
+          self
+        end
+
+        # @return [Hash] storage for defined blocks
+        def storage
+          @storage ||= {}
+        end
+
+        # @return [Array<Class>] descendant classes
+        def descendants
+          @descendants ||= []
+        end
+
+        # @return [Array<Hash>] all descendant storages (full tree)
+        def offspring_storage
+          descendants.map(&:offspring_storage).flatten.unshift(storage)
+        end
+
+        # @return [Hash] merged storages (full tree)
+        def compress_offspring
+          stores = offspring_storage
+          stores.inject(stores.shift) do |memo, store|
+            memo.merge(store)
+          end
+        end
 
-      def storage
-        @storage ||= {}
       end
     end
   end
 end
+
+# Alias for previous release compatibility
+Carnivore::PointBuilder = Carnivore::Http::PointBuilder

data/lib/carnivore-http/utils.rb

@@ -1,18 +1,27 @@
 module Carnivore
   module Http
+
+    # Helper utilities
     module Utils
+
+      # URL parameter helpers
       module Params
 
         class << self
 
+          # Load cgi library on demand
+          #
+          # @param klass [Class]
           def included(klass)
             require 'cgi'
           end
 
         end
 
-        # string:: HTTP query string
-        # Return Hash of parsed query string
+        # Generate hash of parsed query String
+        #
+        # @param string [String] HTTP query string
+        # @return [Hash]
         def parse_query_string(string)
           unless(string.to_s.empty?)
             args = CGI.parse(string)
@@ -22,8 +31,10 @@ module Carnivore
           end
         end
 
-        # args:: HTTP query string Hash
-        # Return formatted hash with inferred types
+        # Cast hash values when possible
+        #
+        # @param args [Hash]
+        # @return [Hash]
         def format_query_args(args)
           new_args = {}
           args.each do |k, v|
@@ -41,8 +52,10 @@ module Carnivore
           new_args
         end
 
-        # obj:: object
-        # Attempts to return true type
+        # Best attempt to convert to true type
+        #
+        # @param obj [Object] generally string value
+        # @return [Object] result of best attempt
         def format_query_type(obj)
           case obj
           when 'true'

data/lib/carnivore-http/version.rb

@@ -1,7 +1,9 @@
 module Carnivore
   module Http
+    # Custom version class
     class Version < Gem::Version
     end
-    VERSION = Version.new('0.1.4')
+    # Current library version
+    VERSION = Version.new('0.1.6')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carnivore-http
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-10 00:00:00.000000000 Z
+date: 2014-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carnivore
@@ -32,17 +32,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: blockenspiel
   requirement: !ruby/object:Gem::Requirement
@@ -75,11 +75,14 @@ files:
 - test/specs/http.rb
 - Gemfile
 - README.md
+- LICENSE
 - carnivore-http.gemspec
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile.lock
 homepage: https://github.com/carnivore-rb/carnivore-http
-licenses: []
+licenses:
+- Apache 2.0
 post_install_message: 
 rdoc_options: []
 require_paths: