frenchy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bfef8fd98c84c71e524f5162592c7a482871a87
+  data.tar.gz: 1420a7aa007282159d99ec13dceeea34479ffbe1
+SHA512:
+  metadata.gz: 05eb4261adeb633381985e6c7e949fb6851d0247fc0c980f446c6bfea4ce34806811e579f1de66cc3f3c43f5c7df09a2446130e78c5ad72cfbbe6c1f3810209d
+  data.tar.gz: 155a63ef8a914acef37dc832d446fb6db131f578527997c87c96367c9826803d692b7a8f5327d555cee8dd2d29cbb14c12575880a6c11124763b0a66a24ed259

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jason Coene
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# 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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "frenchy"
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Frenchy supports multiple back-end services, you should register them in an initializer:
+
+```ruby
+# config/initializer/frenchy.rb
+Frenchy.register_service :dodgeball, host: "http://127.0.0.1:3000"
+```
+
+Let's say we want to track the players on dodgeball team. Players have nicknames returned as a nested response:
+
+```ruby
+class Player
+  # Include Frenchy::Model to get field macros and instance attribute methods
+  include Frenchy::Model
+
+  # Include Frenchy::Resource to get resource macro and class finder methods
+  include Frenchy::Resource
+
+  # 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 },
+    team: { path: "/v1/teams/:team_id/players", many: true }
+  }
+
+  # You can supply a primary key field, which really just uses it for to_param.
+  key :id
+
+  # 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"
+
+  # 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
+end
+
+class Nickname
+  include Frenchy::Model
+
+  field :name, type: "string"
+  field :insulting, type: "bool"
+end
+
+# GET /v1/players/1
+# Expects response '{"id": N, ...}'
+# Returns a single Player object
+p = Player.find(1)
+
+# GET /v1/players/?ids=1,2,3
+# Expects response '[{"id": N, ...}, ...]'
+# Returns multiple Player objects
+Player.find_many([1,2,3])
+
+# GET /v1/teams/3/players?injured=true
+# Expects response '[{"id": N, ...}, ...]'
+# Returns multiple Player objects
+Player.find_with_endpoint(:team, team_id: 3, injured: true)
+```
+
+## Decorators
+
+Frenchy loves decorating! Call the `.decorate` method on your Frenchy models for fun and profit. Under the covers it will find an appropriately named decorator (ex. `PlayerDecorator`) and call `decorate(self)` on it.
+
+You can also call decorate on a collection of Frenchy models (as may be returned if you supply `many: true`).
+
+## Instrumentation
+
+Frenchy knows you like to monitor things, so requests are instrumented. You can do something like this:
+
+```ruby
+# in an initializer...
+
+ActiveSupport::Notifications.subscribe /request.frenchy/ do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+
+  # Generates something along the lines of:
+  # [StatsD] dodgeball.player.one.count:1|c
+  # [StatsD] dodgeball.player.one.runtime:528.78|c
+  label = "#{event.payload[:service]}.#{event.payload[:model]}.#{event.payload[:endpoint]}"
+  StatsD.increment "#{label}.count", 1
+  StatsD.increment "#{label}.runtime", event.duration
+end
+```
+
+Frenchy also provides Rails controller logging and instrumentation just like ActiveRecord:
+
+```
+Dodgeball (14.49ms) GET /v1/players/3
+...
+Completed 200 OK in 56.6ms (Views: 49.9ms | Frenchy: 14.49ms | ActiveRecord: 0.9ms)
+```
+
+## Mascot
+
+![Frenchy](http://i.imgur.com/vQcCQfK.png)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Copyright 2014 Jason Coene. Frenchy is released under the MIT license. See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/frenchie.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "frenchy/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "frenchy"
+  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.homepage      = "https://github.com/jcoene/frenchy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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 "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/frenchy/client.rb

@@ -0,0 +1,60 @@
+require "frenchy"
+require "http"
+require "json"
+
+module Frenchy
+  class Client
+    # Create a new client instance
+    def initialize(options={})
+      options.symbolize_keys!
+
+      @host = options.delete(:host) || "http://127.0.0.1:8080"
+      @timeout = options.delete(:timeout) || 30
+      @retries = options.delete(:retires) || 5
+    end
+
+    # Issue a request with the given path and query parameters
+    def get(path, params)
+      try = 1
+      error = nil
+
+      while try < @retries
+        begin
+          return get_once(path, params)
+        rescue Frenchy::ServerError, Frenchy::InvalidResponse => error
+          sleep (0.35 * (try*try))
+          try += 1
+        end
+      end
+
+      raise error
+    end
+
+    private
+
+    def get_once(path, params)
+      url = "#{@host}#{path}"
+
+      response = begin
+        HTTP.accept(:json).get(url, params: params).response
+      rescue
+        raise Frenchy::ServerError
+      end
+
+      case response.code
+      when 200
+        begin
+          JSON.parse(response.body)
+        rescue
+          raise Frenchy::InvalidResponse
+        end
+      when 404
+        raise Frenchy::NotFound
+      else
+        raise Frenchy::ServerError, response.inspect
+      end
+    end
+
+    public
+  end
+end

data/lib/frenchy/collection.rb

@@ -0,0 +1,14 @@
+module Frenchy
+  class Collection < ::Array
+    # Decorate the collection using the name of the decorator inferred by the first record
+    def decorate
+      decorator_class = "#{first.class.name}Decorator".constantize
+      decorator_class.decorate(self)
+    end
+
+    # Backwards compatibility for old version of draper
+    def nil?
+      none?
+    end
+  end
+end

data/lib/frenchy/instrumentation.rb

@@ -0,0 +1,58 @@
+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
+
+      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)} GET #{event.payload[:path]}"
+          if event.payload[:params].any?
+            output += "?"
+            output += event.payload[:params].map {|k,v| "#{k}=#{v}" }.join("&")
+          end
+          debug output
+        end
+      end
+
+      def self.runtime
+        Thread.current[:frenchy_runtime] || 0.0
+      end
+    end
+
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      protected
+
+      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
+          end
+          messages
+        end
+      end
+    end
+  end
+end
+
+Frenchy::Instrumentation::LogSubscriber.attach_to(:action_controller)
+Frenchy::Instrumentation::LogSubscriber.attach_to(:frenchy)
+
+ActiveSupport.on_load(:action_controller) do
+  include Frenchy::Instrumentation::ControllerRuntime
+end

data/lib/frenchy/model.rb

@@ -0,0 +1,132 @@
+module Frenchy
+  module Model
+    def self.included(base)
+      base.class_eval do
+        cattr_accessor :fields
+
+        self.fields = {}
+      end
+
+      base.extend(ClassMethods)
+    end
+
+    # Create a new instance of this model with the given attributes
+    def initialize(attrs={})
+      attrs.each do |k,v|
+        if self.class.fields[k.to_sym]
+          send("#{k}=", v)
+        end
+      end
+    end
+
+    # Return a hash of field name as string and value pairs
+    def attributes
+      Hash[self.class.fields.map {|k,_| [k.to_s, send(k)]}]
+    end
+
+    # Return a string representing the value of the model instance
+    def inspect
+      "<#{self.class.name} #{attributes.map {|k,v| "#{k}: #{v.inspect}"}.join(", ")}>"
+    end
+
+    # Decorate the model using a decorator inferred by the class
+    def decorate
+      decorator_class = "#{self.class.name}Decorator".constantize
+      decorator_class.decorate(self)
+    end
+
+    protected
+
+    def set(name, value, options={})
+      instance_variable_set("@#{name}", value)
+    end
+
+    module ClassMethods
+      # Create a new instance of the model from a hash
+      def from_hash(hash)
+        new(hash)
+      end
+
+      # Create a new instance of the model from JSON
+      def from_json(json)
+        hash = JSON.parse(json)
+        from_hash(hash)
+      end
+
+      protected
+
+      # Macro to add primary key
+      def key(name)
+        define_method(:to_param) do
+          send(name).to_s
+        end
+      end
+
+      # Macro to add a field
+      def field(name, options={})
+        type = (options[:type] || :string).to_sym
+        aliases = (options[:aliases] || [])
+
+        aliases.each do |a|
+          define_method("#{a}") do
+            send(name)
+          end
+        end
+
+        case type
+        when :string
+          define_method("#{name}=") do |v|
+            set(name, v.to_s, options)
+          end
+        when :integer
+          define_method("#{name}=") do |v|
+            set(name, v.to_i, options)
+          end
+        when :float
+          define_method("#{name}=") do |v|
+            set(name, v.to_f, options)
+          end
+        when :bool
+          define_method("#{name}=") do |v|
+            set(name, ["true", 1, true].include?(v), options)
+          end
+          define_method("#{name}?") do
+            send(name)
+          end
+        when :time
+          define_method("#{name}=") do |v|
+            if v.is_a?(Fixnum)
+              set(name, Time.at(v).to_datetime, options)
+            else
+              set(name, DateTime.parse(v), options)
+            end
+          end
+        when :array
+          define_method("#{name}=") do |v|
+            set(name, Array(v), options)
+          end
+        when :hash
+          define_method("#{name}=") do |v|
+            set(name, Hash[v], options)
+          end
+        else
+          options[:class_name] ||= type.to_s.camelize
+          options[:many] = (name.to_s.singularize != name.to_s) unless options.key?(:many)
+          klass = options[:class_name].constantize
+
+          define_method("#{name}=") do |v|
+            if options[:many]
+              set(name, Frenchy::Collection.new(Array(v).map {|vv| klass.new(vv)}))
+            else
+              set(name, klass.new(v))
+            end
+          end
+        end
+
+        self.fields[name.to_sym] = options
+
+        attr_reader name.to_sym
+      end
+    end
+  end
+end

data/lib/frenchy/request.rb

@@ -0,0 +1,38 @@
+require "frenchy"
+require "frenchy/client"
+require "active_support/notifications"
+
+module Frenchy
+  class Request
+    # Create a new request with given parameters
+    def initialize(service, path, params={}, options={})
+      params.stringify_keys!
+
+      path = path.dup
+      path.scan(/(:[a-z0-9_+]+)/).flatten.uniq.each do |pat|
+        k = pat.sub(":", "")
+        begin
+          v = params.fetch(pat.sub(":", "")).to_s
+        rescue
+          raise Frenchy::InvalidRequest, "The required parameter '#{k}' was not specified."
+        end
+
+        params.delete(k)
+        path.sub!(pat, v)
+      end
+
+      @service = service
+      @path = path
+      @params = params
+      @options = options
+    end
+
+    # Issue the request and return the value
+    def value
+      ActiveSupport::Notifications.instrument("request.frenchy", {service: @service, path: @path, params: @params}.merge(@options)) do
+        client = Frenchy.find_service(@service)
+        client.get(@path, @params)
+      end
+    end
+  end
+end

data/lib/frenchy/resource.rb

@@ -0,0 +1,81 @@
+require "frenchy"
+require "frenchy/request"
+
+module Frenchy
+  module Resource
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Find record(s) using the default endpoint and flexible input
+      def find(params={})
+        params = {id: params.to_s} if [Fixnum, String].any? {|c| params.is_a? c }
+        find_with_endpoint(:default, params)
+      end
+
+      # Find a single record using the "one" (or "default") endpoint and an id
+      def find_one(id, params={})
+        find_with_endpoint([:one, :default], {id: id}.merge(params))
+      end
+
+      # Find multiple record using the "many" (or "default") endpoint and an array of ids
+      def find_many(ids, params={})
+        find_with_endpoint([:many, :default], {ids: ids.join(",")}.merge(params))
+      end
+
+      # Find with a specific endpoint and params
+      def find_with_endpoint(endpoints, params={})
+        name, endpoint = resolve_endpoints(endpoints)
+        options = {model: self.name.underscore, endpoint: name.to_s}
+        response = Frenchy::Request.new(@service, endpoint[:path], params, options).value
+
+        if response.is_a?(Array)
+          Frenchy::Collection.new(Array(response).map {|v| from_hash(v) })
+        else
+          from_hash(response)
+        end
+      end
+
+      private
+
+      # Choose the first available endpoint
+      def resolve_endpoints(endpoints)
+        Array(endpoints).map(&:to_sym).each do |sym|
+          if ep = @endpoints[sym]
+            return sym, ep
+          end
+        end
+
+        raise(Frenchy::ConfigurationError, "Resource does not contain any endpoints: #{endpoints.join(", ")}")
+      end
+
+      # Macro to set the location pattern for this request
+      def resource(options={})
+        options.symbolize_keys!
+
+        @service = options.delete(:service) || raise(Frenchy::ConfigurationError, "Resource must specify a service")
+
+        if endpoints = options.delete(:endpoints)
+          @endpoints = validate_endpoints(endpoints)
+        elsif endpoint = options.delete(:endpoint)
+          @endpoints = validate_endpoints({default: endpoint})
+        else
+          raise(Frenchy::ConfigurationError, "Resource must specify one or more endpoint")
+        end
+
+        @many = options.delete(:many) || false
+      end
+
+      def validate_endpoints(endpoints={})
+        endpoints.symbolize_keys!
+
+        Hash[endpoints.map do |k,v|
+          v.symbolize_keys!
+          raise(Frenchy::ConfigurationError, "Endpoint #{k} does not specify a path") unless v[:path]
+          [k,v]
+        end]
+      end
+    end
+  end
+end

data/lib/frenchy/veneer.rb

@@ -0,0 +1,29 @@
+require "frenchy"
+require "active_model/naming"
+
+module Frenchy
+  # Veneer provides a friendly face on unfriendly models, allowing your Frenchy
+  # models to appear as though they were of another class.
+  module Veneer
+    def self.included(base)
+      if defined?(ActiveModel)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      # Macro to establish a veneer for a given model
+      def veneer(options={})
+        options.symbolize_keys!
+        @model = options.delete(:model) || raise(Frenchy::ConfigurationError, "Veneer must specify a model")
+        extend ActiveModel::Naming
+
+        class_eval do
+          def self.model_name
+            ActiveModel::Name.new(self, nil, @model.to_s.camelize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/frenchy/version.rb

@@ -0,0 +1,3 @@
+module Frenchy
+  VERSION = "0.0.1"
+end

data/lib/frenchy.rb

@@ -0,0 +1,30 @@
+require "frenchy/client"
+require "frenchy/collection"
+require "frenchy/instrumentation"
+require "frenchy/model"
+require "frenchy/request"
+require "frenchy/resource"
+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
+
+  def self.register_service(name, options={})
+    @services ||= {}
+    @services[name.to_sym] = 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 with name #{name} registered:")
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: frenchy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jason Coene
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Frenchy's got the goods
+email:
+- jcoene@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- frenchie.gemspec
+- lib/frenchy.rb
+- lib/frenchy/client.rb
+- lib/frenchy/collection.rb
+- lib/frenchy/instrumentation.rb
+- lib/frenchy/model.rb
+- lib/frenchy/request.rb
+- lib/frenchy/resource.rb
+- lib/frenchy/veneer.rb
+- lib/frenchy/version.rb
+homepage: https://github.com/jcoene/frenchy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Frenchy's got the goods
+test_files: []