frenchy 0.0.9 → 0.2.1

data/lib/frenchy/model.rb

@@ -1,20 +1,21 @@
 module Frenchy
   module Model
     def self.included(base)
-      base.class_eval do
-        cattr_accessor :fields, :defaults
+      base.extend(ClassMethods)
 
+      base.class_eval do
         self.fields = {}
         self.defaults = {}
       end
 
-      base.extend(ClassMethods)
     end
 
     # Create a new instance of this model with the given attributes
     def initialize(attrs={})
+      attrs.stringify_keys!
+
       self.class.defaults.merge((attrs || {}).reject {|k,v| v.nil? }).each do |k,v|
-        if self.class.fields[k.to_sym]
+        if self.class.fields[k]
           send("#{k}=", v)
         end
       end
@@ -22,7 +23,7 @@ module Frenchy
 
     # Return a hash of field name as string and value pairs
     def attributes
-      Hash[self.class.fields.map {|k,_| [k.to_s, send(k)]}]
+      Hash[self.class.fields.map {|k,_| [k, send(k)]}]
     end
 
     # Return a string representing the value of the model instance
@@ -38,21 +39,17 @@ module Frenchy
 
     protected
 
-    def set(name, value, options={})
+    def set(name, value)
       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
+      # Class accessors
+      def fields; @fields; end
+      def defaults; @defaults; end
+      def fields=(value); @fields = value; end
+      def defaults=(value); @defaults = value; end
 
       protected
 
@@ -65,8 +62,11 @@ module Frenchy
 
       # Macro to add a field
       def field(name, options={})
-        type = (options[:type] || :string).to_sym
-        aliases = (options[:aliases] || [])
+        name = name.to_s
+        options.stringify_keys!
+
+        type = (options["type"] || "string").to_s
+        aliases = (options["aliases"] || [])
 
         aliases.each do |a|
           define_method("#{a}") do
@@ -75,54 +75,78 @@ module Frenchy
         end
 
         case type
-        when :string
+        when "string"
+          # Convert value to a String.
           define_method("#{name}=") do |v|
-            set(name, v.to_s, options)
+            set(name, String(v))
           end
-        when :integer
+
+        when "integer"
+          # Convert value to an Integer.
           define_method("#{name}=") do |v|
-            set(name, Integer(v), options)
+            set(name, Integer(v))
           end
-        when :float
+
+        when "float"
+          # Convert value to a Float.
           define_method("#{name}=") do |v|
-            set(name, Float(v), options)
+            set(name, Float(v))
           end
-        when :bool
+
+        when "bool"
+          # Accept truthy values as true.
           define_method("#{name}=") do |v|
-            set(name, ["true", 1, true].include?(v), options)
+            set(name, ["true", "1", 1, true].include?(v))
           end
+
+          # Alias a predicate method.
           define_method("#{name}?") do
             send(name)
           end
-        when :time
+
+        when "time"
+          # Convert value to a Time or DateTime. Numbers are treated as unix timestamps,
+          # other values are parsed with DateTime.parse.
           define_method("#{name}=") do |v|
             if v.is_a?(Fixnum)
-              set(name, Time.at(v).to_datetime, options)
+              set(name, Time.at(v).to_datetime)
             else
-              set(name, DateTime.parse(v), options)
+              set(name, DateTime.parse(v))
             end
           end
-        when :array
-          options[:default] ||= []
+
+        when "array"
+          # Arrays always have a default of []
+          options["default"] ||= []
+
+          # Convert value to an Array.
           define_method("#{name}=") do |v|
-            set(name, Array(v), options)
+            set(name, Array(v))
           end
-        when :hash
-          options[:default] ||= {}
+
+        when "hash"
+          # Hashes always have a default of {}
+          options["default"] ||= {}
+
+          # Convert value to a Hash
           define_method("#{name}=") do |v|
-            set(name, Hash[v], options)
+            set(name, Hash[v])
           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
+          # Unknown types have their type constantized and initialized with the value. This
+          # allows us to support things like other Frenchy::Model classes, ActiveRecord models, etc.
+          klass = (options["class_name"] || type.camelize).constantize
 
-          if options[:many]
-            options[:default] ||= []
+          # Fields with many values have a default of [] (unless previously set above)
+          if options["many"]
+            options["default"] ||= []
           end
 
+          # Convert value using the constantized class. Fields with many values are mapped to a
+          # Frenchy::Collection containing mapped values.
           define_method("#{name}=") do |v|
-            if options[:many]
+            if options["many"]
               set(name, Frenchy::Collection.new(Array(v).map {|vv| klass.new(vv)}))
             else
               if v.is_a?(Hash)
@@ -134,13 +158,16 @@ module Frenchy
           end
         end
 
-        self.fields[name.to_sym] = options
+        # Store a reference to the field
+        self.fields[name] = options
 
-        if options[:default]
-          self.defaults[name.to_sym] = options[:default]
+        # Store a default value if present
+        if options["default"]
+          self.defaults[name] = options["default"]
         end
 
-        attr_reader name.to_sym
+        # Create an accessor for the field
+        attr_reader name
       end
     end
   end

data/lib/frenchy/request.rb

@@ -1,20 +1,21 @@
-require "frenchy"
-require "frenchy/client"
-require "active_support/notifications"
+begin
+  require "active_support"
+rescue LoadError
+end
 
 module Frenchy
   class Request
-    # Create a new request with given parameters
-    def initialize(service, method, path, params={}, options={})
-      params.stringify_keys!
+    attr_accessor :service, :method, :path, :params, :extras
 
+    # Create a new request with given parameters
+    def initialize(service, method, path, params={}, extras={})
       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."
+          raise Frenchy::Error, "The required parameter '#{k}' was not specified."
         end
 
         params.delete(k)
@@ -25,14 +26,22 @@ module Frenchy
       @method = method
       @path = path
       @params = params
-      @options = options
+      @extras = extras
     end
 
     # Issue the request and return the value
     def value
-      ActiveSupport::Notifications.instrument("request.frenchy", {service: @service, method: @method, path: @path, params: @params}.merge(@options)) do
-        client = Frenchy.find_service(@service)
-        client.send(@method, @path, @params)
+      Frenchy.find_service(@service).send(@method, @path, @params)
+    end
+
+    # Requests are instrumented if ActiveSupport is available.
+    if defined?(ActiveSupport::Notifications)
+      alias_method :value_without_instrumentation, :value
+
+      def value
+        ActiveSupport::Notifications.instrument("request.frenchy", {service: @service, method: @method, path: @path, params: @params}.merge(@extras)) do
+          value_without_instrumentation
+        end
       end
     end
   end

data/lib/frenchy/resource.rb

@@ -1,6 +1,3 @@
-require "frenchy"
-require "frenchy/request"
-
 module Frenchy
   module Resource
     def self.included(base)
@@ -10,83 +7,89 @@ module Frenchy
     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)
+        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))
+        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))
+        find_with_endpoint(["many", "default"], {"ids" => ids.join(",")}.merge(params))
       end
 
       # Call with a specific endpoint and params
       def find_with_endpoint(endpoints, params={})
+        params.stringify_keys!
         name, endpoint = resolve_endpoints(endpoints)
-        method = (endpoint[:method] || :get).to_sym
-        options = {model: self.name.underscore, endpoint: name.to_s}
+        method = endpoint["method"] || "get"
+        extras = {"model" => self.name, "endpoint" => name}
 
-        response = Frenchy::Request.new(@service, method, endpoint[:path], params, options).value
-        digest_response(response)
+        response = Frenchy::Request.new(@service, method, endpoint["path"], params, extras).value
+        digest_response(response, endpoint)
       end
 
       # Call with arbitrary method and path
       def find_with_path(method, path, params={})
-        options = {model: self.name.underscore, endpoint: "path"}
-        response = Frenchy::Request.new(@service, method.to_sym, path, params, options).value
-        digest_response(response)
+        params.stringify_keys!
+        extras = {"model" => self.name, "endpoint" => "path"}
+        response = Frenchy::Request.new(@service, method.to_s, path.to_s, params, extras).value
+        digest_response(response, endpoint)
       end
 
       private
 
       # Converts a response into model data
-      def digest_response(response)
+      def digest_response(response, endpoint)
+        if endpoint["nesting"]
+          Array(endpoint["nesting"]).map(&:to_s).each do |key|
+            response = response.fetch(key)
+          end
+        end
+
         if response.is_a?(Array)
-          Frenchy::Collection.new(Array(response).map {|v| from_hash(v) })
+          Frenchy::Collection.new(Array(response).map {|v| new(v) })
         else
-          from_hash(response)
+          new(response)
         end
       end
 
       # Choose the first available endpoint
       def resolve_endpoints(endpoints)
-        Array(endpoints).map(&:to_sym).each do |sym|
-          if ep = @endpoints[sym]
-            return sym, ep
+        Array(endpoints).map(&:to_s).each do |s|
+          if ep = @endpoints[s]
+            return s, ep
           end
         end
 
-        raise(Frenchy::ConfigurationError, "Resource does not contain any endpoints: #{endpoints.join(", ")}")
+        raise(Frenchy::Error, "Resource does not contain any endpoints: #{Array(endpoints).join(", ")}")
       end
 
       # Macro to set the location pattern for this request
       def resource(options={})
-        options.symbolize_keys!
+        options.stringify_keys!
 
-        @service = options.delete(:service) || raise(Frenchy::ConfigurationError, "Resource must specify a service")
+        @service = options.delete("service").to_s || raise(Frenchy::Error, "Resource must specify a service")
 
-        if endpoints = options.delete(:endpoints)
+        if endpoints = options.delete("endpoints")
           @endpoints = validate_endpoints(endpoints)
-        elsif endpoint = options.delete(:endpoint)
-          @endpoints = validate_endpoints({default: endpoint})
+        elsif endpoint = options.delete("endpoint")
+          @endpoints = validate_endpoints({"default" => endpoint})
         else
-          raise(Frenchy::ConfigurationError, "Resource must specify one or more endpoint")
+          @endpoints = {}
         end
-
-        @many = options.delete(:many) || false
       end
 
       def validate_endpoints(endpoints={})
-        endpoints.symbolize_keys!
+        endpoints.stringify_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]
+          v.stringify_keys!
+          raise(Frenchy::Error, "Endpoint #{k} does not specify a path") unless v["path"]
+          [k, v]
         end]
       end
     end

data/lib/frenchy/veneer.rb

@@ -1,29 +1,33 @@
-require "frenchy"
-require "active_model/naming"
+begin
+  require "active_model"
+rescue LoadError
+end
 
-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)
+if defined?(ActiveModel)
+  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
-    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
+      module ClassMethods
+        # Macro to establish a veneer for a given model
+        def veneer(options={})
+          options.stringify_keys!
+          @model = options.delete("model") || raise(Frenchy::Error, "Veneer must specify a model")
+          extend ActiveModel::Naming
 
-        class_eval do
-          def self.model_name
-            ActiveModel::Name.new(self, nil, @model.to_s.camelize)
+          class_eval do
+            def self.model_name
+              ActiveModel::Name.new(self, nil, @model.to_s.camelize)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/frenchy/version.rb

@@ -1,3 +1,3 @@
 module Frenchy
-  VERSION = "0.0.9"
+  VERSION = "0.2.1"
 end

data/spec/lib/frenchy/client_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Frenchy::Client do
+  describe "#initialize" do
+    it "uses expected defaults" do
+      client = Frenchy::Client.new
+      expect(client.host).to eql("http://127.0.0.1:8080")
+      expect(client.timeout).to eql(30)
+      expect(client.retries).to eql(0)
+    end
+
+    it "accepts an options hash" do
+      client = Frenchy::Client.new({"host" => "http://127.0.0.1:1234", "timeout" => 15, "retries" => 3})
+      expect(client.host).to eql("http://127.0.0.1:1234")
+      expect(client.timeout).to eql(15)
+      expect(client.retries).to eql(3)
+    end
+
+    it "accepts an options hash (symbols)" do
+      client = Frenchy::Client.new(host: "http://127.0.0.1:1234", timeout: 15, retries: 3)
+      expect(client.host).to eql("http://127.0.0.1:1234")
+      expect(client.timeout).to eql(15)
+      expect(client.retries).to eql(3)
+    end
+  end
+
+  ["patch", "post", "put", "delete"].each do |method|
+    describe "##{method}" do
+      it "returns a successful response containing the request json data" do
+        client = Frenchy::Client.new("host" => "http://httpbin.org")
+        data = {"data" => "abcd", "number" => 1, "nested" => {"more" => "data"}}
+        expect = JSON.generate(data)
+        result = client.send(method, "/#{method}", data)
+        expect(result).to be_an_instance_of(Hash)
+        expect(result["data"]).to eql(expect)
+      end
+    end
+  end
+
+  describe "#perform" do
+    it "returns a hash for successful json response" do
+      client = Frenchy::Client.new("host" => "http://httpbin.org")
+      result = client.get("/ip", {})
+      expect(result).to be_an_instance_of(Hash)
+      expect(result.keys).to eql(["origin"])
+    end
+
+    it "raises an invalid response error for non-json response" do
+      client = Frenchy::Client.new("host" => "http://httpbin.org")
+      expect{client.get("/html", {})}.to raise_error(Frenchy::InvalidResponse)
+    end
+
+    it "raises a not found error for 404 responses" do
+      client = Frenchy::Client.new("host" => "http://httpbin.org")
+      expect{client.get("/status/404", {})}.to raise_error(Frenchy::NotFound)
+    end
+
+    it "raises a service unavailable error for 500+ responses" do
+      client = Frenchy::Client.new("host" => "http://httpbin.org")
+      expect{client.get("/status/500", {})}.to raise_error(Frenchy::ServiceUnavailable)
+    end
+  end
+end