saddle 0.0.19 → 0.0.21

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmExNjkzOWQ5ZDAzZmFlMGM3MDFmYjMzOTYzMjdiNGIzNWYyNjJkNg==
+    OTdiMWYwODYzZTI0YzdiZGViNWU3MTJhMGFjZmIwMjcxYzcyNmFmMw==
   data.tar.gz: !binary |-
-    NzJhMzhiNjZjZmUyNjY1ZTMyYWIwMTEzMWU5NmNmZDI2MWRiMmQxYQ==
+    MjBiMTU3YWY3YjE2OGYzYzVkN2JmNTQ5OWNmZDhiYTFmZWE4MDhkMA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NzBhOTQ3OGRkNzQyMGQwYmM3YmFlNWZiOGEwOTQ3ZTFiYWNlNTBiMDM3ZmNj
-    NmRhMTk2YjY3MWZiZTk1NjUzNDBlMzE0MTNlNGJiNzgyN2UzZTUwODE0Zjk0
-    YWZkMDhkYjU4OTVlNzQ2YzA4NTNkODQ5YzdlZjZiODA4YmViZGE=
+    MmUzMzE3Y2ExOGM2ZDc1OGQ4M2ZmYTU3ODUxMTE4MTJhNDY4NDY0ZDY2M2Yw
+    ZTM0MDk3YmJlMDYyYWI4ZTFiMDY4YzM5OTBiZWU4NGNiY2VkYzJiYzM3ODI5
+    MDUzYzUxZTNmYjk1Zjk0NDFhNmIzNzhmYWM4NGNkMzlmMTg2ZTA=
   data.tar.gz: !binary |-
-    YTg5ZmIyZmU1OGNhNjJiMGZjMDEyNDJmODEzNTE1MGI0Y2VjNTc3OTllYzA3
-    MmM5MjdiM2YwNjdiNTMzMDJlNzNlMGI3NDFjOGM0MzBmODIwNTQwMzRjYmRk
-    NTExNzZkMjM2YzgzMmIxMTZhOTM3Y2ZlMGYyNThlMTA0ZWE1NDg=
+    NjMxNjBiODUyNjNkZjZmNGMyYTU2MTg2MTVhOWUxOTFmMWRhOTdiNDM2NWY2
+    YjNmMDA5NzM3N2I2Nzc1M2ViNzZiMGQ0YjU0ZWFiNzk0YWQ2ODYzNmZkYjRm
+    ZDg4Mjc1ZWRlYzc2MDU2MjczMmZlMjU4YTFlZTE1OTg5ZWY1YjE=

data/lib/saddle/endpoint.rb

@@ -14,68 +14,94 @@ module Saddle
     attr_reader :requester, :relative_path, :parent
 
     # Each endpoint needs to have a requester in order to ... make ... uh ... requests.
-    def initialize(requester, relative_path=nil, parent=nil)
+    def initialize(requester, relative_path_override=nil, parent=nil)
       @requester = requester
-      @relative_path = relative_path
       @parent = parent
+      @relative_path = relative_path_override || _relative_path()
     end
 
-
     # Provide GET functionality for the implementer class
     def get(action, params={}, options={})
-      request(:get, action, params, options)
+      _request(:get, action, params, options)
     end
 
     # Provide POST functionality for the implementer class
     def post(action, params={}, options={})
-      request(:post, action, params, options)
+      _request(:post, action, params, options)
     end
 
     # Provide PUT functionality for the implementer class
     def put(action, params={}, options={})
-      request(:put, action, params, options)
+      _request(:put, action, params, options)
     end
 
     # Provide DELETE functionality for the implementer class
     def delete(action, params={}, options={})
-      request(:delete, action, params, options)
+      _request(:delete, action, params, options)
+    end
+
+
+    # This will create a resource endpoint, based upon the parameters
+    # of this current node endpoint
+    def create_resource_endpoint(endpoint_class, resource_id)
+      endpoint_class.new(@requester, resource_id, self)
     end
 
-    def request(method, action, params={}, options={})
+
+    # Create an endpoint instance and foist it upon this node
+    # Not private, but not part of the public interface for an endpoint
+    def _build_and_attach_node(endpoint_class, method_name=nil)
+      # Create the new endpoint
+      endpoint_instance = endpoint_class.new(@requester, method_name, self)
+      # Attach the endpoint as an instance variable and method
+      method_name ||= ActiveSupport::Inflector.underscore(
+        ActiveSupport::Inflector.demodulize(
+          endpoint_class.name
+        )
+      )
+      self.instance_variable_set("@#{method_name}", endpoint_instance)
+      self.class.class_eval { define_method(method_name) { endpoint_instance } }
+      endpoint_instance
+    end
+
+
+    protected
+
+    def _request(method, action, params={}, options={})
       # Augment in interesting options
       options[:saddle] = {
-        :client_name => self.client_name,
-        :call_chain => path_array,
+        :client_name => _client_name(),
+        :call_chain => _path_array(),
         :action => action,
       }
-      @requester.send(method, path(action), params, options)
+      @requester.send(method, _path(action), params, options)
     end
 
 
     # Get the url path for this endpoint/action combo
-    def path(action=nil)
-      paths = path_array
+    def _path(action=nil)
+      paths = _path_array()
       paths << action unless action.nil?
       '/' + paths.join('/')
     end
 
-    def path_array
-      endpoint_chain.map(&:relative_path).reject{|p| p.nil?}
+    def _path_array
+      _endpoint_chain().map(&:relative_path).reject{|p| p.nil?}
     end
 
     # Get the parent chain that led to this endpoint
-    def endpoint_chain
+    def _endpoint_chain
       chain = []
       node = self
       while node.is_a?(BaseEndpoint)
         chain << node
         node = node.parent
       end
-      chain.reverse
+      chain.reverse()
     end
 
     # Traverse back until we find the original client
-    def client
+    def _client
       node = self
       while node.is_a?(BaseEndpoint)
         node = node.parent
@@ -84,23 +110,30 @@ module Saddle
     end
 
     # Underscore name of the client
-    def client_name
-      ActiveSupport::Inflector.underscore(self.client.name.split('::')[-2])
+    def _client_name
+      ActiveSupport::Inflector.underscore(self._client.name.split('::')[-2])
     end
 
-
-    # Create an endpoint instance and foist it upon this node
-    def build_and_attach_node(endpoint_class, method_name)
-      endpoint_instance = endpoint_class.new(@requester, method_name, self)
-      self.instance_variable_set("@#{method_name}", endpoint_instance)
-      self.class.class_eval { define_method(method_name) { endpoint_instance } }
-      endpoint_instance
+    # If the parent is not an endpoint, it is a root node
+    def _is_root?
+      !@parent.is_a?(BaseEndpoint)
     end
 
-    # This will create a resource endpoint, based upon the parameters
-    # of this current node endpoint
-    def create_resource_endpoint(endpoint_class, resource_id)
-      endpoint_class.new(@requester, resource_id, self)
+    # Build the default relative path for this endpoint node
+    #   If this is a root node, use nil.
+    #   Otherwise use the underscored version of the class name
+    #
+    # Override this if needed for specific endpoints
+    def _relative_path
+      if _is_root?
+        nil
+      else
+        ActiveSupport::Inflector.underscore(
+          ActiveSupport::Inflector.demodulize(
+            self.class.name
+          )
+        )
+      end
     end
   end
 

data/lib/saddle/method_tree_builder.rb

@@ -36,6 +36,7 @@ module Saddle
         if File.file?(root_endpoint_file)
           # Load it and create our base endpoint
           load(root_endpoint_file)
+          # RootEndpoint is the special class name for a root endpoint
           root_node_class = self.implementation_module::RootEndpoint
         else
           # 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
@@ -57,7 +58,7 @@ module Saddle
         if const.class == Module
           # A module means that it's a branch
           # Build the branch out with a base endpoint
-          branch_node = current_node.build_and_attach_node(
+          branch_node = current_node._build_and_attach_node(
             Saddle::BaseEndpoint,
             ActiveSupport::Inflector.underscore(const_symbol)
           )
@@ -68,10 +69,7 @@ module Saddle
         if const < Saddle::TraversalEndpoint
           # A class means that it's a node
           # Build out this endpoint on the current node
-          current_node.build_and_attach_node(
-            const,
-            ActiveSupport::Inflector.underscore(const_symbol)
-          )
+          current_node._build_and_attach_node(const)
         end
       end
     end
@@ -98,7 +96,7 @@ module Saddle
     end
 
     # If this client was not fully constructed, it may not even have an
-    # implementation root. Allow that behavior and avoid firesystem searching.
+    # implementation root. Allow that behavior to avoid filesystem searching.
     def knows_root?
       defined?(self.implementation_root)
     end

data/lib/saddle/middleware/request/retry.rb

@@ -18,7 +18,7 @@ module Saddle
 
         def call(env)
           retries = env[:request][:num_retries] || 2
-          backoff = env[:request][:retry_backoff] || 0.050 # ms
+          backoff = env[:request][:retry_backoff] || 0.050 # in seconds
           begin
             @app.call(self.class.deep_copy(env))
           rescue => e

data/lib/saddle/options.rb

@@ -7,14 +7,15 @@ module Saddle
     # Construct our default options, based upon the class methods
     def default_options
       {
-        :host => host,
-        :port => port,
-        :use_ssl => use_ssl,
-        :request_style => request_style,
-        :num_retries => num_retries,
-        :timeout => timeout,
+        :host => host(),
+        :port => port(),
+        :path_prefix => path_prefix(),
+        :use_ssl => use_ssl(),
+        :request_style => request_style(),
+        :num_retries => num_retries(),
+        :timeout => timeout(),
         :additional_middlewares => self.additional_middlewares,
-        :stubs => stubs,
+        :stubs => stubs(),
       }
     end
 
@@ -28,6 +29,11 @@ module Saddle
       80
     end
 
+    # A string prefix to prepend to paths as they are build (ie, 'v1')
+    def path_prefix
+      ''
+    end
+
     # Should this client use SSL by default?
     def use_ssl
       false

data/lib/saddle/requester.rb

@@ -34,6 +34,8 @@ module Saddle
       raise ':host must be a string' unless @host.is_a?(String)
       @port = opt[:port] || 80
       raise ':port must be an integer' unless @port.is_a?(Fixnum)
+      @path_prefix = opt[:path_prefix] || ''
+      raise ':path_prefix must be a string' unless @path_prefix.is_a?(String)
       @use_ssl = opt[:use_ssl] || false
       raise ':use_ssl must be true or false' unless (@use_ssl.is_a?(TrueClass) || @use_ssl.is_a?(FalseClass))
       @request_style = opt[:request_style] || :json
@@ -41,9 +43,7 @@ module Saddle
       @num_retries = opt[:num_retries] || 3
       raise ':num_retries must be an integer' unless @num_retries.is_a?(Fixnum)
       @timeout = opt[:timeout]
-      unless @timeout.nil?
-        raise ':timeout must be a number or nil' unless @timeout.is_a?(Numeric)
-      end
+      raise ':timeout must be nil or an integer' unless (@timeout.nil? || @timeout.is_a?(Numeric))
       @additional_middlewares = opt[:additional_middlewares] || []
       raise ':additional_middleware must be an Array' unless @additional_middlewares.is_a?(Array)
       raise 'invalid middleware found' unless @additional_middlewares.all? { |m| m[:klass] < Faraday::Middleware }
@@ -99,7 +99,7 @@ module Saddle
 
     # Construct a base url using this requester's settings
     def base_url
-      "http#{'s' if @use_ssl}://#{@host}:#{@port}"
+      "http#{'s' if @use_ssl}://#{@host}:#{@port}/#{@path_prefix}"
     end
 
     # Build a connection instance, wrapped in the middleware that we want
@@ -113,36 +113,36 @@ module Saddle
         end
 
         # Support default return values upon exception
-        builder.use Saddle::Middleware::Response::DefaultResponse
+        builder.use(Saddle::Middleware::Response::DefaultResponse)
 
         # Apply additional implementation-specific middlewares
         @additional_middlewares.each do |m|
-          builder.use m[:klass], *m[:args]
+          builder.use(m[:klass], *m[:args])
         end
 
         # Hard timeout on the entire request
-        builder.use Saddle::Middleware::RubyTimeout
+        builder.use(Saddle::Middleware::RubyTimeout)
 
         # Request encoding
-        builder.use Saddle::Middleware::Request::JsonEncoded
-        builder.use Saddle::Middleware::Request::UrlEncoded
+        builder.use(Saddle::Middleware::Request::JsonEncoded)
+        builder.use(Saddle::Middleware::Request::UrlEncoded)
 
         # Automatic retries
-        builder.use Saddle::Middleware::Request::Retry
+        builder.use(Saddle::Middleware::Request::Retry)
 
         # Handle parsing out the response if it's JSON
-        builder.use Saddle::Middleware::Response::ParseJson
+        builder.use(Saddle::Middleware::Response::ParseJson)
 
         # Raise exceptions on 4xx and 5xx errors
-        builder.use Faraday::Response::RaiseError
+        builder.use(Faraday::Response::RaiseError)
 
         # Set up our adapter
         if @stubs.nil?
           # Use the default adapter
-          builder.adapter :net_http
+          builder.adapter(:net_http)
         else
           # Use the test adapter
-          builder.adapter :test, @stubs
+          builder.adapter(:test, @stubs)
         end
       end
     end

data/lib/saddle/version.rb

@@ -1,3 +1,3 @@
 module Saddle
-  VERSION = '0.0.19'
+  VERSION = '0.0.21'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saddle
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.21
 platform: ruby
 authors:
 - Mike Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-10 00:00:00.000000000 Z
+date: 2013-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport