leadlight 0.0.5 → 0.0.6

data/lib/leadlight/lib_ext/faraday/middleware.rb

@@ -0,0 +1,7 @@
+module Faraday
+  class Middleware
+    def self.adapter?
+      false
+    end
+  end
+end

data/lib/leadlight/link.rb

@@ -1,8 +1,16 @@
+require 'addressable/uri'
+require 'addressable/template'
+require 'leadlight/param_hash'
+
 module Leadlight
   class Link
-    HTTP_METHODS = [
-      :options, :head, :get, :get_representation!, :post, :put, :delete, :patch
+    include ::Leadlight
+
+    HTTP_METHODS_WITH_BODY    = [:post, :put, :patch]
+    HTTP_METHODS_WITHOUT_BODY = [
+      :options, :head, :get, :get_representation!, :delete
     ]
+    HTTP_METHODS = HTTP_METHODS_WITHOUT_BODY + HTTP_METHODS_WITH_BODY
 
     attr_reader :service
     attr_reader :rel
@@ -10,19 +18,42 @@ module Leadlight
     attr_reader :title
     attr_reader :href
     attr_reader :aliases
+    attr_reader :options
+
+    # Expansion params have no effect on the Link. They exist to keep
+    # a record of how this particular Link instance was constructed,
+    # if it was constructed via expansion.
+    attr_reader :expansion_params
 
     def initialize(service, href, rel=nil, title=rel, options={})
+      @options = options
       @service = service
       @href    = Addressable::URI.parse(href)
       @rel     = rel.to_s
       @title   = title.to_s
       @rev     = options[:rev]
       @aliases = Array(options[:aliases])
+      self.expansion_params = options.fetch(:expansion_params) { {} }
+    end
+
+    HTTP_METHODS_WITHOUT_BODY.each do |name|
+      define_method(name) do |*args, &block|
+        request_options = args.last.is_a?(Hash) ? args.pop : {}
+        request_options[:link] = self
+        service.public_send(name, href, nil, *args, request_options, &block)
+      end
     end
 
-    [:options, :head, :get, :get_representation!, :post, :put, :delete, :patch].each do |name|
+    HTTP_METHODS_WITH_BODY.each do |name|
       define_method(name) do |*args, &block|
-        service.public_send(name, href, *args, &block)
+        request_options = if args.size > 1 && args.last.is_a?(Hash)
+                            args.pop
+                          else
+                            {}
+                          end
+        body = args.shift
+        request_options[:link] = self
+        service.public_send(name, href, body, *args, request_options, &block)
       end
     end
 
@@ -31,5 +62,61 @@ module Leadlight
         return representation
       end
     end
+
+    def expand(expansion_params=nil)
+      if expansion_params
+        dup_with_new_href(expand_uri_with_params(href.dup, expansion_params), expansion_params)
+      else
+        self
+      end
+    end
+
+    def [](*args)
+      expand(*args)
+    end
+
+    def to_s
+      "Link(#{rel}:#{href}#{inspect_expansion_params})"
+    end
+
+    def params
+      extracted_params.merge(expansion_params)
+    end
+
+    protected
+
+    attr_writer :href
+
+    def expansion_params=(new_params)
+      @expansion_params = new_params.each_with_object({}){|(k,v),h|
+        h[k.to_s] = v.to_s
+      }
+    end
+
+    private
+
+    def expand_uri_with_params(uri, uri_params)
+      uri.query_values = ParamHash(uri_params) if uri_params.any?
+      uri.normalize
+    end
+
+    def dup_with_new_href(uri, expansion_params={})
+      self.dup.tap do |link|
+        link.href = uri
+        link.expansion_params = expansion_params
+      end
+    end
+
+    def inspect_expansion_params
+      if expansion_params.empty?
+        ""
+      else
+        " [#{expansion_params.inspect}]"
+      end
+    end
+
+    def extracted_params
+      href.query_values || {}
+    end
   end
 end

data/lib/leadlight/link_template.rb

@@ -1,8 +1,12 @@
+require 'forwardable'
 require 'leadlight/link'
 require 'addressable/template'
 
 module Leadlight
   class LinkTemplate < Link
+    extend Forwardable
+
+    def_delegators :href_template, :variables
 
     def href_template
       @href_template ||= Addressable::Template.new(href.to_s)
@@ -10,26 +14,30 @@ module Leadlight
 
     HTTP_METHODS.each do |name|
       define_method(name) do |*args, &block|
-        expanded_href = expand(args)
-        service.public_send(name, expanded_href, *args, &block)
+        expanded_href = expand(*args).href
+        service.public_send(name, expanded_href, &block)
       end
     end
 
-    def expand(args)
+    def expand(*args)
+      return self if args.empty?
       mapping = args.last.is_a?(Hash) ? args.pop : {}
       mapping = mapping.inject({}) { |result, (k,v)| result.merge!(k.to_s => v) }
       mapping = href_template.variables.inject(mapping) do |mapping, var|
         mapping.merge!(var => args.shift) unless args.empty?
         mapping
       end
+      full_mapping = mapping.dup
       extra_keys = (mapping.keys.map(&:to_s) - href_template.variables)
       extra_params = extra_keys.inject({}) do |params, key|
         params[key] = mapping.delete(key)
         params
       end
       assert_all_variables_mapped(href_template, mapping)
-      args.push extra_params unless extra_params.empty?
-      href_template.expand(mapping).to_s
+      uri          = href_template.expand(mapping)
+      expanded_uri = expand_uri_with_params(uri, extra_params)
+      Link.new(service, expanded_uri, rel, title,
+               rev: rev, aliases: aliases, expansion_params: full_mapping)
     end
 
     private

data/lib/leadlight/null_link.rb

@@ -0,0 +1,21 @@
+require 'addressable/uri'
+
+module Leadlight
+  class NullLink
+    include Addressable
+    attr_reader :href
+
+    def initialize(href)
+      @href = href
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        href == other.href
+    end
+
+    def params
+      URI.parse(href).query_values || {}
+    end
+  end
+end

data/lib/leadlight/param_hash.rb

@@ -0,0 +1,42 @@
+require 'delegate'
+
+module Leadlight
+  def ParamHash(hash)
+    case hash
+    when ParamHash then hash
+    else ParamHash.new(hash)
+    end
+  end
+  module_function :ParamHash
+
+  class ParamHash < DelegateClass(Hash)
+    def initialize(hash)
+      super(transform_hash(Hash[hash], :deep => true) {|h,k,v|
+              h[k] = transform_value(v)
+            })
+    end
+
+    private
+
+    def transform_hash(original, options={}, &block)
+      original.inject({}){|result, (key,value)|
+        value = if (options[:deep] && Hash === value)
+                  transform_hash(value, options, &block)
+                else
+                  value
+                end
+        block.call(result,key,value)
+        result
+      }
+    end
+
+    def transform_value(value)
+      case value
+      when ParamHash then value
+      when Hash      then self.class.new(value)
+      when Array     then value.map(&:to_s)
+      else value.to_s
+      end
+    end
+  end
+end

data/lib/leadlight/representation.rb

@@ -1,17 +1,25 @@
+require 'forwardable'
 require 'addressable/uri'
+require 'fattr'
 require 'leadlight/link'
 require 'leadlight/errors'
 
 module Leadlight
   module Representation
+    extend Forwardable
+
     attr_accessor :__service__
     attr_accessor :__location__
     attr_accessor :__response__
+    attr_accessor :__request__
+
+    #fattr(:__captures__) { {} }
 
-    def initialize_representation(service, location, response)
-      self.__service__ = service
+    def initialize_representation(service, location, response, request)
+      self.__service__  = service
       self.__location__ = location
       self.__response__ = response
+      self.__request__  = request
       self
     end
 
@@ -27,7 +35,7 @@ module Leadlight
       when 404 then ResourceNotFound
       when (400..499) then ClientError
       when (500..599) then ServerError
-      end.new(__response__, exception_message)
+      end.new(__request__, exception_message)
     end
 
     def exception_message
@@ -40,6 +48,18 @@ module Leadlight
       }
     end
 
+    def __link__
+      __request__.link
+    end
+
+    def __request_params__
+      __request__.params
+    end
+
+    def __captures__
+      @__captures__ ||= {}
+    end
+
     private
 
     def __apply_tint__

data/lib/leadlight/request.rb

@@ -1,3 +1,4 @@
+require 'ostruct'
 require 'monitor'
 require 'fattr'
 require 'forwardable'
@@ -8,6 +9,7 @@ require 'leadlight/hyperlinkable'
 require 'leadlight/representation'
 require 'leadlight/type_map'
 require 'leadlight/header_helpers'
+require 'leadlight/null_link'
 
 module Leadlight
   class Request
@@ -20,29 +22,29 @@ module Leadlight
     fattr(:url)
     fattr(:connection)
     fattr(:body)
-    fattr(:params)
     fattr(:service)
     fattr(:codec)
     fattr(:type_map) { service.type_map || TypeMap.new }
 
-    attr_reader :response    
+    attr_reader :response, :options, :link
 
     define_hook :on_prepare_request, :request
     define_hook :on_complete,        :response
 
     def_delegator :service, :service_options
 
-    def initialize(service, connection, url, method, params={}, body=nil)
+    def initialize(service, connection, url, method, body=nil, options={})
+      @options         = options
       self.connection  = connection
       self.url         = url
       self.http_method = method
       self.body        = body
-      self.params      = params
       self.service     = service
       @completed       = new_cond
       @state           = :initialized
       @env             = nil
       @response        = nil
+      @link            = options.fetch(:link) { NullLink.new(url) }
       super()
     end
 
@@ -54,10 +56,11 @@ module Leadlight
       entity = type_map.to_entity_body(body)
       entity_body = entity.body
       content_type = entity.content_type
-      connection.run_request(http_method, url, entity_body, {}) do |request|
-        request.params.update(params) unless params.empty?
+      connection.run_request(http_method, url.to_s, entity_body, {}) do
+        |request|
+
         request.headers['Content-Type'] = content_type if content_type
-        request.options[:leadlight_request] = self        
+        request.options[:leadlight_request] = self
         execute_hook(:on_prepare_request, request)
       end.on_complete do |env|
         synchronize do
@@ -109,23 +112,52 @@ module Leadlight
       end
     end
 
-    def represent(env)      
+    def represent(env)
       content_type = env[:response_headers]['Content-Type']
       content_type = clean_content_type(content_type)
       representation = type_map.to_native(content_type, env[:body])
-      location = Addressable::URI.parse(env[:response_headers].fetch('location'){ env[:url] })
       representation.
         extend(Representation).
-        initialize_representation(env[:leadlight_service], location, env[:response]).
+        initialize_representation(env[:leadlight_service], location(env), env[:response], self).
         extend(Hyperlinkable).
         apply_all_tints
     end
 
+    def params
+      link_params.merge(request_params)
+    end
+
+    def location(env=@env)
+      env ||= {}
+      url = env.fetch(:response_headers){{}}.fetch('location'){ env.fetch(:url){ self.url } }
+      Addressable::URI.parse(url)
+    end
+
     private
 
+    fattr(:faraday_request) {
+      env.fetch(:request) { OpenStruct.new(params: {}) }
+    }
+
+    def env
+      if completed?
+        @env
+      else
+        {}
+      end
+    end
+
     def representation
       raise "No representation until complete" unless completed?
       @env.fetch(:leadlight_representation)
     end
+
+    def request_params
+      faraday_request.params
+    end
+
+    def link_params
+      link.params
+    end
   end
 end

data/lib/leadlight/service.rb

@@ -1,6 +1,7 @@
 require 'fattr'
 require 'forwardable'
 require 'leadlight/request'
+require 'leadlight/connection_builder'
 
 module Leadlight
   module Service
@@ -13,7 +14,8 @@ module Leadlight
     fattr(:type_map) { TypeMap.new }
 
     def_delegators :codec, :encode, :decode
-    def_delegators 'self.class', :types, :type_for_name, :request_class
+    def_delegators 'self.class', :types, :type_for_name, :request_class, :http_adapter
+    def_delegators :Leadlight, :common_connection_stack
 
     def initialize(service_options={})
       @service_options = service_options
@@ -31,12 +33,12 @@ module Leadlight
     end
 
     def connection
-      @connection ||= Faraday.new(url: self.url) do |builder|
-        builder.use Leadlight::ServiceMiddleware, service: self
-        instance_exec(builder, &connection_stack)
-        builder.use Faraday::Response::Logger, logger
-        instance_exec(builder, &Leadlight.common_connection_stack)
-      end
+      @connection ||= ConnectionBuilder.new do |cxn|
+        cxn.url          url
+        cxn.service      self
+        cxn.common_stack common_connection_stack
+        cxn.adapter      http_adapter
+      end.call
     end
 
     [:options, :head, :get, :post, :put, :delete, :patch].each do |name|
@@ -53,8 +55,8 @@ module Leadlight
 
     private
 
-    def perform_request(url, http_method, params={}, body=nil, &representation_handler)
-      req = request_class.new(self, connection, url, http_method, params, body)
+    def perform_request(url, http_method, body=nil, options={}, &representation_handler)
+      req = request_class.new(self, connection, url, http_method, body, options)
       if representation_handler
         req.submit_and_wait(&representation_handler)
       end