emmy-http 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ee8be3827495aa336fb2971686ad1cbfa901e53
-  data.tar.gz: 72d47e9269d8dd829ecb9926260fda5189a91659
+  metadata.gz: 0971c78d06be99618226ee14b9eb60c57c5cf535
+  data.tar.gz: b6a4c6026afbaab8215cea42689bae329b119555
 SHA512:
-  metadata.gz: b22d65f1c793b2ce8b12b16ef64080f65713d7d4b93b7f25eb53d794b41d5c558639422b7ee0d883e72412f96bd79b9fffdcbc4fdc346e686fe4396062d0d84b
-  data.tar.gz: aba78e417ac83c315bbf118e5e5b990394fdc49979853ded65a37d18d6b9adca5f641762444e3eaab76d87d1b752558d4c6ebda6221d162cd0b133566c5481a3
+  metadata.gz: 33f5fc5aafa7d59ba0865dbdd3f2ca2c3c45325bdcfd30244b1c4e8e4170252ae67895f99e2ee061a97a8388a3ffd8a3b7e5583bb59e208f166403cb41586fc0
+  data.tar.gz: 6b499296b451a6bac10b39c872c5bd0bae17cd1cf4faf42c8cdbd96677b20fecbc6cccc66ba6fadb1879389ab0d7e1adbf7a16c883239deab79ead719ec9700d

data/Gemfile

@@ -2,5 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in emmy-http.gemspec
 gemspec
-
-gem 'emmy-machine'

data/emmy-http.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = EmmyHttp::VERSION
   spec.authors       = ["inre"]
   spec.email         = ["inre.storm@gmail.com"]
-  spec.summary       = %q{EmmyHttp is a  }
+  spec.summary       = %q{EmmyHttp - EventMachine's HTTP Client}
   #spec.description   = %q{TODO: Write a longer description. Optional.}
   spec.homepage      = ""
   spec.license       = "MIT"
@@ -18,7 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  #spec.add_dependency "emmy-machine", "~> 0.1"
+  spec.add_dependency "event_object", "~> 0.9.1"
+  spec.add_dependency "emmy-machine", "~> 0.1.7"
   spec.add_dependency "fibre", "~> 0.9.3"
   spec.add_dependency "util_pack", "~> 0.1"
   spec.add_dependency "model_pack", "~> 0.9.6"

data/lib/emmy_http/model.rb

@@ -1,20 +1,130 @@
 #
 # class Google
-#   include EmmyHttp::Model
-#   adapter EmmyExtends::EmHttpRequest
-#   default EmmyHttp::Request.new(
-#     type: "post",
+#   include  EmmyHttp::Model
+#   adapter  EmmyExtends::EmHttpRequest
+#   defaults {
 #     headers: {
 #       'Content-Type' => 'application/json'
 #     }
-#   )
+#   }
+#
+#   post ''
 # end
 #
 # google = Google.new(url: 'http://google.com')
 # response = google.sync
 
+#
+# module DigitalOcean
+#   using EventObject
+#   API_TOKEN = "b7d03a6947b217efb6f3ec3bd3504582"
+#
+#   class DigitalOcean::Error < StandardError; end
+#
+#   class Request
+#     include EmmyHttp::Model
+#     adapter EmmyHttp::Client::Adapter
+#     header 'Content-Type' => 'application/json'
+#     header "Authorization: Bearer #{API_TOKEN}"
+#
+#     events :success, :error
+#
+#     def sync
+#       connect
+#
+#       Fiber.sync do |f|
+#         on :success do |content|
+#           f.resume content
+#         end
+#
+#         on :error do |message|
+#           raise DigitalOcean::Error, message
+#         end
+#       end
+#     end
+#
+#     def request
+#       op = super(
+#
+#       ).op
+#
+#       op.on :success do |response, operation, conn|
+#         success!(response.content)
+#       end
+#
+#       op.on :error do |message, operation, conn|
+#         error!(message)
+#       end
+#     end
+#   end
+#
+#
+#   class Droplets < Request
+#     get  list: '/v2/droplets'
+#     post new:  '/v2/droplets'
+#     get  get:  '/v2/:id'
+#
+#
+#   end
+# end
+require 'singleton'
+
 module EmmyHttp
   module Model
+    using EventObject
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.include Singleton
+      base.include InstanceMethods
+    end
+
+    module InstanceMethods
+      def request
+        @request ||= EmmyHttp::Request.new
+      end
+    end
+
+    module ClassMethods
+      def request(a=nil)
+        instance.request.tap { |req| req.update_attributes(a) if a }
+      end
+
+      def adapter(name)
+        request.adapter = name
+      end
+
+      def url(uri)
+        request.url = uri
+      end
+
+      def defaults(attributes)
+        request.update_attributes(attributes)
+      end
+
+      def headers(head)
+        request.headers.merge!(head)
+      end
+
+      def raise_error(flag)
+        request.raise_error = flag
+      end
+
+      alias header headers
+
+      EmmyHttp::HTTP_METHODS.each do |name|
+        define_method name do |path, as: nil|
+          cdef as.to_s do |*a|
+            instance.var(as.to_s, request.copy.tap { |r| r.update_attributes(path: path) })
+          end
+
+          cdef "#{as}!" do |*a, &b|
+            send(as, *a, &b)
+          end
+        end
+      end
+    end
 
+    #<<<
   end
 end

data/lib/emmy_http/operation.rb

@@ -20,6 +20,10 @@ module EmmyHttp
       @connection ||= EmmyMachine.connect(*self)
     end
 
+    def reconnect
+      EmmyMachine.reconnect(*self)
+    end
+
     def sync
       Fiber.sync do |fiber|
         # create connection
@@ -42,7 +46,11 @@ module EmmyHttp
 
         on :error do |error, operation, conn|
           # return error as exception
-          fiber.leave ConnectionError, error.to_s
+          if request.raise_error?
+            fiber.leave ConnectionError, error.to_s
+          else
+            fiber.resume nil
+          end
         end
       end
     end

data/lib/emmy_http/refines.rb

@@ -0,0 +1,11 @@
+module EmmyHttp
+  refine Kernel do
+    def request(*a, &b)
+      EmmyHttp.request(*a, &b)
+    end
+
+    def request!(*a, &b)
+      EmmyHttp.request!(*a, &b)
+    end
+  end
+end

data/lib/emmy_http/request.rb

@@ -1,24 +1,28 @@
 module EmmyHttp
   class Request
     include ModelPack::Document
-    extend Forwardable
+    using EventObject
 
     #def_delegator :operation, :sync, :init, :head, :success, :error, :init!, :head!, :success!, :error!, :to_a
 
-    attribute :type, default: "get" # word *method* reserved in ruby
+    attribute :type, default: "GET" # word *method* reserved in ruby
     attribute :url,
         writer: ->(url) { url.is_a?(URI) ? url : URI.parse(url) },
         serialize: ->(value) { value.to_s }
     dictionary :headers
 
+    attribute :path    # replace url.path
     attribute :query   # replace url.query
+
     # POST, PUT
     attribute :body    # string, json hash
     attribute :form    # hash form
+    attribute :json    # serializable hash/object to json
     attribute :file    # path
 
     attribute :keep_alive, predicate: true
     attribute :redirects, default: 6
+    attribute :raise_error, predicate: true, default: true
 
     object :timeouts, class_name: Timeouts, default: Timeouts
     object :ssl, class_name: SSL
@@ -27,23 +31,24 @@ module EmmyHttp
     attribute :adapter,
         writer:    ->(class_name) { class_name.is_a?(String) ? constantize(class_name) : class_name },
         serialize: ->(value) { value.to_s }
-=begin
-    attribute :response_class,
-        writer:    ->(class_name) { class_name.is_a?(String) ? constantize(class_name) : class_name },
-        serialize: ->(value) { value.to_s }
 
-    def initialize
-      @response_class = Response
-    end
-=end
     def operation
-      @operation ||= EmmyHttp::Operation.new(self, adapter)
+      @operation ||= EmmyHttp::Operation.new(self, adapter.new)
     end
 
+    alias op operation
+
     def sync
       operation.sync
     end
 
+    EmmyHttp::HTTP_METHODS.each do |name|
+      self.def name do |a={}|
+        update_attributes(a.is_a?(String) ? {url: a} : a)
+        self
+      end
+    end
+
     # FIXME: move to model_pack
     def ssl?
       !!ssl
@@ -51,6 +56,10 @@ module EmmyHttp
 
     private
 
+    def error(message)
+      raise RequestError, message
+    end
+
     def constantize(class_name)
       return nil unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ class_name
       Object.module_eval("::#{$1}", __FILE__, __LINE__)

data/lib/emmy_http/response.rb

@@ -3,26 +3,30 @@ module EmmyHttp
     using EventObject
     include ModelPack::Document
 
-    attribute  :status
+    attribute  :status,  default: 0
     dictionary :headers, writer: -> (head) { EmmyHttp::Utils.convert_headers(head) }
-    attribute  :body
+    attribute  :body,    default: ''
+    attribute  :finished, predicate: true#, hidden: true
 
-    events :data
+    events :data, :done
 
     def initialize
       on :data do |chunk|
         body << chunk
       end
-
-      reset
     end
 
-    def reset
+    def clear
       @status  = 0
       @headers = {}
       @body    = ''
     end
 
+    def finish
+      @finished = true
+      done!
+    end
+
     def chunked_encoding?
       headers['Transfer-Encoding'] =~ /chunked/i
     end
@@ -35,12 +39,33 @@ module EmmyHttp
       headers['Content-Encoding'] =~ /gzip|compressed|deflate/i
     end
 
+    def content_length?
+      headers['Content-Length'] =~ /\A\d+\z/
+    end
+
+    def content_length
+      content_length? ? headers['Content-Length'].to_i : nil
+    end
+
+    def content_type
+      headers['Content-Type'] =~ /\A([^;]*)/; $1
+    end
+
     def location
       headers['Location']
     end
 
-    def content_length
-      headers['Content-Length'].to_i
+    def content
+      @content ||= case content_type
+        when 'application/json'
+          begin
+            JSON.parse(body)
+          rescue JSON::ParserError => e
+            raise ParserError, e.to_s
+          end
+      else
+        nil
+      end
     end
 
     def redirection?

data/lib/emmy_http/utils.rb

@@ -3,7 +3,7 @@ module EmmyHttp
     extend self
 
     # CONTENT_TYPE becomes Content-Type
-  def convert_headers(headers)
+    def convert_headers(headers)
       headers.inject({}) { |h, (k, v)|
         h[k.split(/[_-]/).map { |w| w.downcase.capitalize }.join('-')] = v; h
       }

data/lib/emmy_http/version.rb

@@ -1,3 +1,3 @@
 module EmmyHttp
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/emmy_http.rb

@@ -3,8 +3,13 @@ require "emmy_http/version"
 require "forwardable"
 
 module EmmyHttp
-  class ConnectionError < StandardError; end
-  class TimeoutError < ConnectionError; end
+  class HttpError < StandardError; end
+  class ParserError < HttpError; end
+  class RequestError < HttpError; end
+  class ConnectionError < HttpError; end
+  class TimeoutError < HttpError; end
+
+  HTTP_METHODS = %w(get head delete put post patch options)
 
   autoload :Adapter,   "emmy_http/adapter"
   autoload :Timeouts,  "emmy_http/client/timeouts"
@@ -15,4 +20,15 @@ module EmmyHttp
   autoload :Response,  "emmy_http/response"
   autoload :Timeout,   "emmy_http/timeout"
   autoload :Utils,     "emmy_http/utils"
+  autoload :Model,     "emmy_http/model"
+
+  extend self
+
+  def request(*a)
+    EmmyHttp::Request.new(*a).tap { |req| yield(req) if block_given? }
+  end
+
+  def request!(*a)
+    request(*a, &b).operation
+  end
 end

data/spec/emmy_http/model_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "fakes"
+using Fibre::Synchrony
+
+describe EmmyHttp::Model do
+
+  before do
+    stub_const("EmmyMachine", FakeEventMachine)
+  end
+
+  class HTTPBin
+    include EmmyHttp::Model
+    adapter FakeAdapter
+    url "http://httpbin.org"
+    header "Content-Type" => "application/json"
+
+    get '/get',   as: :get_request
+    post '/post', as: :post_request
+  end
+
+  around do |example|
+    EmmyMachine.run_block &example
+  end
+
+  it "have requests from model" do
+    res = {
+      get_response: HTTPBin.get_request!,
+      post_response: HTTPBin.post_request!(form: {a: 5, b: 6})
+    }.sync
+
+    expect(res[:get_response].status).to be(200)
+    expect(res[:post_response].status).to be(200)
+  end
+end

data/spec/emmy_http_spec.rb

@@ -1,95 +1,67 @@
 require "spec_helper"
+require "fakes"
 using EventObject
+using Fibre::Synchrony
 
 describe EmmyHttp do
-  Connection = EmmyMachine::Connection
-
-  module FakeEventMachine
-    extend EmmyMachine::ClassMethods
-
-    def connect(adapter, init)
-      conn = Class.new
-      conn.extend Connection
-      init.call
-      adapter.connected(conn)
-      conn
-    end
-
-    extend self
-  end
-
-  class FakeAdapter
-    attr_accessor :delegate
-    include EmmyHttp::Adapter
-
-    def initialize_connection
-      self.delegate.init! delegate
-    end
-
-    def connected(conn)
-      # replace request with timer
-      EventMachine.add_timer(0) do
-        response = EmmyHttp::Response.new
-        response.headers = {'CONTENT_TYPE' => 'text/html'}
-        response.status  = 200
-        self.delegate.head!(response, delegate, conn)
-        response.body = "OK"
-        self.delegate.success!(delegate.response, delegate, conn)
-      end
-    end
-
-    def to_a
-      [self, method(:initialize_connection)]
-    end
-  end
+  include EmmyHttp
 
   before do
     stub_const("EmmyMachine", FakeEventMachine)
   end
 
   around do |example|
-    EventMachine.run do
-      EmmyMachine.fiber_block &example
-    end
+    EmmyMachine.run_block &example
+  end
+
+  it "do http request with fake adapter" do
+    request = EmmyHttp::Request.new(
+      type: 'get',
+      url: 'http://google.com'
+    )
+    operation = EmmyHttp::Operation.new(request, FakeAdapter.new)
+    response = operation.sync
+
+    expect(response.status).to be 200
+    expect(response.headers).to include("Content-Type")
+    expect(response.body).to eq "OK"
   end
 
-  it "should do http request with fake adapter" do
-    begin
-      request = EmmyHttp::Request.new(
-        type: 'get',
-        url: 'http://google.com'
-      )
-      operation = EmmyHttp::Operation.new(request, FakeAdapter.new)
-      response = operation.sync
-    ensure
-      EventMachine.stop
-    end
+  it "do http request with short syntax" do
+    response = request(adapter: FakeAdapter, raise_error: false).get('http://google.com').sync
 
+    expect(response).to_not be nil
     expect(response.status).to be 200
     expect(response.headers).to include("Content-Type")
     expect(response.body).to eq "OK"
   end
 
+  it "do async requests" do
+    req = request(adapter: FakeAdapter, raise_error: false)
+    responses = {
+      a: [req.copy.get('http://google.com').op, req.copy.get('http://google.com').op],
+      b: req.copy.get('http://google.com')
+    }.sync!
+
+    expect(responses[:a][0].status).to be 200
+    expect(responses[:a][1].status).to be 200
+    expect(responses[:b].status).to be 200
+  end
+
   it "should wait a couple seconds" do
-    begin
-      timeout = EmmyHttp::Timeout.new(2)
-      res = timeout.sync
-    ensure
-      EventMachine.stop
-    end
+    timeout = EmmyHttp::Timeout.new(2)
+    res = timeout.sync
+
     expect(res).to be true
   end
 
   it "should serialize request" do
-    begin
-      request = EmmyHttp::Request.new(
-        type: 'get',
-        url: 'http://google.com'
-      )
-      request_hash = request.serializable_hash
-    ensure
-      EventMachine.stop
-    end
+    request = EmmyHttp::Request.new(
+      type: 'get',
+      url: 'http://google.com'
+    )
+    request_hash = request.serializable_hash
+
     expect(request_hash).to include(type: 'get', url: 'http://google.com')
   end
 end

data/spec/fakes.rb

@@ -0,0 +1,40 @@
+Connection = EmmyMachine::Connection
+
+module FakeEventMachine
+  extend EmmyMachine::ClassMethods
+
+  def connect(adapter, init)
+    conn = Class.new
+    conn.extend Connection
+    init.call
+    adapter.connected(conn)
+    conn
+  end
+
+  extend self
+end
+
+class FakeAdapter
+  attr_accessor :delegate
+  include EmmyHttp::Adapter
+
+  def initialize_connection
+    self.delegate.init! delegate
+  end
+
+  def connected(conn)
+    # replace request with timer
+    EventMachine.add_timer(0) do
+      response = EmmyHttp::Response.new
+      response.headers = {'Content-Type' => 'text/html'}
+      response.status  = 200
+      self.delegate.head!(response, delegate, conn)
+      response.body = "OK"
+      self.delegate.success!(delegate.response, delegate, conn)
+    end
+  end
+
+  def to_a
+    [self, method(:initialize_connection)]
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: emmy-http
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - inre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-14 00:00:00.000000000 Z
+date: 2015-04-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: emmy-machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
 - !ruby/object:Gem::Dependency
   name: fibre
   requirement: !ruby/object:Gem::Requirement
@@ -114,16 +142,16 @@ files:
 - lib/emmy_http/client/timeouts.rb
 - lib/emmy_http/model.rb
 - lib/emmy_http/operation.rb
+- lib/emmy_http/refines.rb
 - lib/emmy_http/request.rb
 - lib/emmy_http/response.rb
-- lib/emmy_http/server/options.rb
 - lib/emmy_http/timeout.rb
 - lib/emmy_http/utils.rb
 - lib/emmy_http/version.rb
-- pkg/emmy-http-0.1.0.gem
-- pkg/emmy-http-0.1.1.gem
+- spec/emmy_http/model_spec.rb
 - spec/emmy_http/response_spec.rb
 - spec/emmy_http_spec.rb
+- spec/fakes.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -148,8 +176,10 @@ rubyforge_project:
 rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
-summary: EmmyHttp is a
+summary: EmmyHttp - EventMachine's HTTP Client
 test_files:
+- spec/emmy_http/model_spec.rb
 - spec/emmy_http/response_spec.rb
 - spec/emmy_http_spec.rb
+- spec/fakes.rb
 - spec/spec_helper.rb

data/lib/emmy_http/server/options.rb

@@ -1,19 +0,0 @@
-module EmmyHttp
-  class Server::Options
-    include ModelPack::Document
-
-    attribute :chdir,         default: Dir.pwd
-    attribute :environment,   default: 'development'
-    atrribute :address,       default: '0.0.0.0'
-    attribute :port,          default: 3434
-    attribute :timeout,       default: 30
-    attribute :pid,           default: File.join(Dir.pwd, "tmp/pids/server.log")
-    attribute :log,           default: File.join(Dir.pwd, "log/server.log")
-    attribute :max_conns,     default: 1024
-    attribute :max_persistent_conns, default: 100
-    attribute :require        default: []
-    attribute :wait           default: 30
-    attribute :fiberpool_size, default: 20
-    attribute :daemonize,     default: false
-  end
-end