frenchy 0.0.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfc53ad6ae8399ce20c1088d4d8af731e38c3ebd
-  data.tar.gz: da03a49221e8e7c5aff1509fe8805788c1349670
+  metadata.gz: 896b7777033ce445d2e9bd558356457c5ff7b1f8
+  data.tar.gz: 35332a7b5006236a816ba18d060fa9fbb34a4789
 SHA512:
-  metadata.gz: ed5d78ec4022471cf35a7eac83ca2c91f154c168e72eb039aeeb4e4ef82e8e9512318492e433cb61656e1f80792a0e27987ab9c5ba9a139f965936d53ec994d9
-  data.tar.gz: c0d155f5886853a2f4a8204d8a37c778903ecf395be03fc2e08989cb946b990091a2ebe66eff024d8ff0ceb80317126769fc6fe7edc641a7cbef871f4698d59a
+  metadata.gz: 096edcd0e10872db18fda625db3fc1690fc05d22feb06b323fed80e3b599c1f12f8396d1d4ae473ce5c53bf63e859b23d92953b1ae3a397df00cea71088a41ac
+  data.tar.gz: 38c76d3f9714798bc3582de8fd64d95d56c5175ad660f0f5d7ae74e752c8873d39147ea6cb5073cfd57ce77fb437cd83bcb4b709665086d4884649c6ff3a9920

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.2

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch("spec/spec_helper.rb")  { "spec" }
+end
+

data/README.md

@@ -1,6 +1,8 @@
 # Frenchy
 
-Frenchy is a thing for turning HTTP JSON API endpoints into Rails-ish model objects. It deals with making requests, converting responses, type conversion, struct nesting, model decorating and instrumentation.
+[![Gem Version](https://badge.fury.io/rb/frenchy.png)](https://rubygems.org/gems/frenchy) [![Build Status](https://travis-ci.org/jcoene/frenchy.png)](https://travis-ci.org/jcoene/frenchy) [![Coverage Status](https://coveralls.io/repos/jcoene/frenchy/badge.png?branch=master)](https://coveralls.io/r/jcoene/frenchy)
+
+Frenchy is an opinionated modeling framework for consuming HTTP+JSON API endpoints as ActiveModel-like objects. It deals with making requests, converting responses, type conversion, struct nesting, model decorating and instrumentation. Frenchy is used in production at [Dotabuff](http://dotabuff.com) serving millions of requests per day.
 
 ## Installation
 
@@ -10,11 +12,11 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 ## Usage
 
-Frenchy supports multiple back-end services, you should register them in an initializer:
+Frenchy supports multiple back-end services. If you're using Rails, register them in an initializer:
 
 ```ruby
 # config/initializer/frenchy.rb
@@ -34,7 +36,7 @@ class Player
   # Declare which service the model belongs to and specify your named API endpoints
   resource service: "dodgeball", endpoints: {
     one:  { path: "/v1/players/:id" },
-    many: { path: "/v1/players", many: true },
+    many: { path: "/v1/players",                many: true },
     team: { path: "/v1/teams/:team_id/players", many: true }
   }
 
@@ -43,23 +45,23 @@ class Player
 
   # Define fields which create named attributes and deal with typecasting.
   # Valid built-in types: string, integer, float, bool, time, array, hash
-  field :id, type: "integer"
-  field :name, type: "string"
-  field :win_rate, type: "float"
-  field :free_agent, type: "bool"
+  field :id,          type: "integer"
+  field :name,        type: "string"
+  field :win_rate,    type: "float"
+  field :free_agent,  type: "bool"
 
   # You can also supply types of any class that can be instantiated by sending
   # a hash of attributes to the "new" class method. If you specify the "many"
   # option, we'll expect that the server returns an array and will properly treat
   # the response as a collection.
-  field :nicknames, type: "nickname", many: true
+  field :nicknames,   type: "nickname",   many: true
 end
 
 class Nickname
   include Frenchy::Model
 
-  field :name, type: "string"
-  field :insulting, type: "bool"
+  field :name,        type: "string"
+  field :insulting,   type: "bool"
 end
 
 # GET /v1/players/1

data/Rakefile

@@ -1 +1,8 @@
+#!/usr/bin/env rake
+
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: "spec"

data/frenchie.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Frenchy::VERSION
   spec.authors       = ["Jason Coene"]
   spec.email         = ["jcoene@gmail.com"]
-  spec.description   = %q{Frenchy's got the goods}
-  spec.summary       = %q{Frenchy's got the goods}
+  spec.description   = %q{Opinionated JSON API modeling framework for Ruby.}
+  spec.summary       = %q{Opinionated JSON API modeling framework for Ruby.}
   spec.homepage      = "https://github.com/jcoene/frenchy"
   spec.license       = "MIT"
 
@@ -18,12 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activemodel"
-  spec.add_dependency "activesupport"
-  spec.add_dependency "http"
   spec.add_dependency "json"
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency  "coveralls"
+  spec.add_development_dependency "activesupport", ">= 3.0"
+  spec.add_development_dependency "activemodel", ">= 3.0"
 end

data/lib/frenchy.rb

@@ -1,5 +1,8 @@
+require "frenchy/core_ext"
+
 require "frenchy/client"
 require "frenchy/collection"
+require "frenchy/error"
 require "frenchy/instrumentation"
 require "frenchy/model"
 require "frenchy/request"
@@ -8,23 +11,15 @@ require "frenchy/veneer"
 require "frenchy/version"
 
 module Frenchy
-  class Error < ::StandardError; end
-  class NotFound < Error; end
-  class ServerError < Error; end
-  class InvalidResponse < Error; end
-  class InvalidRequest < Error; end
-  class ConfigurationError < Error; end
+  class_eval do
+    @services = {}
+  end
 
   def self.register_service(name, options={})
-    @services ||= {}
-    @services[name.to_sym] = Frenchy::Client.new(options)
+    @services[name.to_s] = Frenchy::Client.new(options)
   end
 
   def self.find_service(name)
-    if @services.nil?
-      raise(Frenchy::ConfigurationError, "No services have been configured")
-    end
-
-    @services[name.to_sym] || raise(Frenchy::ConfigurationError, "No service '#{name}' registered")
+    @services[name.to_s] || raise(Frenchy::Error, "No service '#{name}' registered")
   end
 end

data/lib/frenchy/client.rb

@@ -1,88 +1,116 @@
-require "frenchy"
-require "http"
+require "net/http"
 require "json"
 
 module Frenchy
   class Client
+    attr_accessor :host, :timeout, :retries
+
     # Create a new client instance
     def initialize(options={})
-      options.symbolize_keys!
+      options.stringify_keys!
 
-      @host = options.delete(:host) || "http://127.0.0.1:8080"
-      @timeout = options.delete(:timeout) || 60
-      @retries = options.delete(:retries) || 0
+      @host = options.delete("host") || "http://127.0.0.1:8080"
+      @timeout = options.delete("timeout") || 30
+      @retries = options.delete("retries") || 0
+      @backoff_delay = options.delete("backoff_delay") || 1.0
     end
 
-    # Issue a get request with the given path and query parameters
+    # Issue a get request with the given path and query parameters. Get
+    # requests can be retried.
     def get(path, params)
       try = 0
-      error = nil
+      err = nil
 
       while try <= @retries
+        sleep (@backoff_delay * (try*try)) if try > 0
+
         begin
-          return perform(:get, path, params)
-        rescue Frenchy::ServerError, Frenchy::InvalidResponse => error
-          sleep (0.35 * (try*try))
+          return perform("GET", path, params)
+        rescue Frenchy::Error => err
           try += 1
         end
       end
 
-      raise error
+      raise err
     end
 
     # Issue a non-retryable request with the given path and query parameters
-    def patch(path, params); perform(:patch, path, params); end
-    def post(path, params); perform(:post, path, params); end
-    def put(path, params); perform(:put, path, params); end
-    def delete(path, params); perform(:delete, path, params); end
+    ["PATCH", "POST", "PUT", "DELETE"].each do |method|
+      define_method(method.downcase) do |path, params|
+        perform(method, path, params)
+      end
+    end
 
     private
 
     def perform(method, path, params)
-      url = "#{@host}#{path}"
-
-      request = {
-        method: method.to_s.upcase,
-        url: url,
-        params: params
-      }
-
+      uri = URI(@host)
+      body = nil
       headers = {
         "User-Agent" => "Frenchy/#{Frenchy::VERSION}",
-        "Accept" => "application/json",
+        "Accept"     => "application/json",
       }
 
-      body = nil
+      # Set the URI path
+      uri.path = path
 
-      case method
-      when :patch, :post, :put
-        headers["Content-Type"] = "application/json"
-        body = JSON.generate(params)
-        params = nil
+      # Set request parameters
+      if params.any?
+        case method
+        when "GET"
+          # Get method uses params as query string
+          uri.query = URI.encode_www_form(params)
+        else
+          # Other methods post a JSON body
+          headers["Content-Type"] = "application/json"
+          body = JSON.generate(params)
+        end
       end
 
-      response = begin
-        HTTP.accept(:json).send(method, url, headers: headers, params: params, body: body).response
-      rescue => exception
-        raise Frenchy::ServerError, {request: request, error: exception}
+      # Create a new HTTP connection
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.scheme == "https"
+      http.read_timeout = @timeout
+      http.open_timeout = @timeout
+
+      # Create a new HTTP request
+      req = Net::HTTPGenericRequest.new(
+        method.to_s.upcase,       # method
+        body != nil,              # request has body?
+        true,                     # response has body?
+        uri.request_uri,          # request uri
+        headers,                  # request headers
+      )
+
+      # Set the request body if present
+      req.body = body if body != nil
+
+      # Create a request info string for inspection
+      reqinfo = "#{method} #{uri.to_s}"
+
+      # Perform the request
+      begin
+        resp = http.request(req)
+      rescue => ex
+        raise Frenchy::ServerError.new(ex, reqinfo, nil)
       end
 
-      case response.code
-      when 200, 400
+      # Return based on response
+      case resp.code.to_i
+      when 200...399
+        # Positive responses are expected to return JSON
         begin
-          JSON.parse(response.body)
-        rescue => e
-          raise Frenchy::InvalidResponse, {request: request, error: exception, status: response.status, body: response.body}
+          JSON.parse(resp.body)
+        rescue => ex
+          raise Frenchy::InvalidResponse.new(ex, reqinfo, resp)
         end
       when 404
-        body = JSON.parse(response.body) rescue response.body
-        raise Frenchy::NotFound, {request: request, status: response.status, body: body}
+        # Explicitly handle not found errors
+        raise Frenchy::NotFound.new(nil, reqinfo, resp)
       else
-        body = JSON.parse(response.body) rescue response.body
-        raise Frenchy::ServerError, {request: request, status: response.status, body: body}
+        # All other responses are treated as a server error
+        raise Frenchy::ServiceUnavailable.new(nil, reqinfo, resp)
       end
     end
-
-    public
   end
 end

data/lib/frenchy/collection.rb

@@ -10,7 +10,7 @@ module Frenchy
     def decorate(options={})
       return self if none?
 
-      decorator_class.decorate_collection(self)
+      decorator_class.decorate_collection(self, options)
     end
 
     # Compatbility for associations in draper

data/lib/frenchy/core_ext.rb

@@ -0,0 +1,34 @@
+class Hash
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end unless {}.respond_to?(:stringify_keys!)
+end
+
+class String
+  def camelize
+    dup.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end unless "".respond_to?(:camelize)
+
+  def constantize
+    names = self.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+
+    constant
+  end unless "".respond_to?(:constantize)
+
+  def underscore
+    dup.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end unless "".respond_to?(:underscore)
+end

data/lib/frenchy/error.rb

@@ -0,0 +1,31 @@
+module Frenchy
+  class Error < ::StandardError; end
+
+  class RequestError < Error
+    attr_reader :message, :request, :response
+
+    def initialize(message=nil, request=nil, response=nil)
+      @request, @response = request, response
+
+      if message
+        @message = message.respond_to?(:message) ? message.message : message
+      elsif response.respond_to?(:code)
+        @message = "The server responded with status #{response.code}"
+        @message += "\n\n#{response.body.to_s}" if response.body.to_s != ""
+      else
+        @message = "An unknown error has occured"
+      end
+
+      @message += "\n\n#{request}" if request
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  class NotFound < RequestError; end
+  class InvalidResponse < RequestError; end
+  class ServerError < RequestError; end
+  class ServiceUnavailable < ServerError; end
+end

data/lib/frenchy/instrumentation.rb

@@ -1,58 +1,62 @@
-require "active_support/concern"
-require "active_support/log_subscriber"
-
-module Frenchy
-  module Instrumentation
-    class LogSubscriber < ActiveSupport::LogSubscriber
-      def start_processing(event)
-        Thread.current[:frenchy_runtime] = 0.0
-      end
+begin
+  require "active_support"
+rescue LoadError
+end
+
+if defined?(ActiveSupport)
+  module Frenchy
+    module Instrumentation
+      class LogSubscriber < ActiveSupport::LogSubscriber
+        def start_processing(event)
+          Thread.current[:frenchy_runtime] = 0.0
+        end
 
-      def request(event)
-        Thread.current[:frenchy_runtime] ||= 0.0
-        Thread.current[:frenchy_runtime] += event.duration
-        if logger.debug?
-          name = "%s (%.2fms)" % [event.payload[:service].capitalize, event.duration]
-          output = "  #{color(name, YELLOW, true)} #{event.payload[:method].to_s.upcase} #{event.payload[:path]}"
-          if event.payload[:params].any?
-            output += "?"
-            output += event.payload[:params].map {|k,v| "#{k}=#{v}" }.join("&")
+        def request(event)
+          Thread.current[:frenchy_runtime] ||= 0.0
+          Thread.current[:frenchy_runtime] += event.duration
+          if logger.debug?
+            name = "%s (%.2fms)" % [event.payload[:service].capitalize, event.duration]
+            output = "  #{color(name, YELLOW, true)} #{event.payload[:method].to_s.upcase} #{event.payload[:path]}"
+            if event.payload[:params].any?
+              output += "?"
+              output += event.payload[:params].map {|k,v| "#{k}=#{v}" }.join("&")
+            end
+            debug output
           end
-          debug output
         end
-      end
 
-      def self.runtime
-        Thread.current[:frenchy_runtime] || 0.0
+        def self.runtime
+          Thread.current[:frenchy_runtime] || 0.0
+        end
       end
-    end
 
-    module ControllerRuntime
-      extend ActiveSupport::Concern
+      module ControllerRuntime
+        extend ActiveSupport::Concern
 
-      protected
+        protected
 
-      def append_info_to_payload(payload)
-        super
-        payload[:frenchy_runtime] = Frenchy::Instrumentation::LogSubscriber.runtime
-      end
+        def append_info_to_payload(payload)
+          super
+          payload[:frenchy_runtime] = Frenchy::Instrumentation::LogSubscriber.runtime
+        end
 
-      module ClassMethods
-        def log_process_action(payload)
-          messages = super
-          if runtime = payload[:frenchy_runtime]
-            messages << "Frenchy: %.1fms" % runtime.to_f
+        module ClassMethods
+          def log_process_action(payload)
+            messages = super
+            if runtime = payload[:frenchy_runtime]
+              messages << "Frenchy: %.1fms" % runtime.to_f
+            end
+            messages
           end
-          messages
         end
       end
     end
   end
-end
 
-Frenchy::Instrumentation::LogSubscriber.attach_to(:action_controller)
-Frenchy::Instrumentation::LogSubscriber.attach_to(:frenchy)
+  Frenchy::Instrumentation::LogSubscriber.attach_to(:action_controller)
+  Frenchy::Instrumentation::LogSubscriber.attach_to(:frenchy)
 
-ActiveSupport.on_load(:action_controller) do
-  include Frenchy::Instrumentation::ControllerRuntime
+  ActiveSupport.on_load(:action_controller) do
+    include Frenchy::Instrumentation::ControllerRuntime
+  end
 end