leadlight 0.0.2

data/lib/leadlight/blank.rb

@@ -0,0 +1,15 @@
+module Leadlight
+  class Blank
+    def blank?
+      true
+    end
+
+    def empty?
+      true
+    end
+
+    def present?
+      false
+    end
+  end
+end

data/lib/leadlight/codec.rb

@@ -0,0 +1,63 @@
+module Leadlight
+  class Codec
+    Strategy ||= Struct.new(:name, :encoder, :decoder, :patterns)
+
+    def self.strategies
+      @strategies ||= []
+    end
+
+    def self.strategy(name, encoder, decoder, patterns)
+      strategies << Strategy.new(name, encoder, decoder, Array(patterns))
+    end
+
+    strategies.clear
+
+    strategy :text,             
+             ->(rep, options)         {rep.to_s},
+             ->(entity_body, options) {entity_body},
+             %r{^text/plain}
+
+    strategy :json, 
+             MultiJson.method(:encode),
+             MultiJson.method(:decode), 
+             [%r{^application/json}, %r{\+json$}]
+
+    def decode(content_type, entity_body, options={})
+      transcode(:decode, content_type, entity_body, options)
+    end
+
+    def encode(content_type, representation, options={})
+      transcode(:encode, content_type, representation, options)
+    end
+
+    private
+
+    def transcode(direction, content_type, input, options)
+      fallback = unknown_type_handler(content_type)
+      strategy = fetch_strategy(content_type, &fallback)
+      transcoder = case direction
+                   when :encode then strategy.encoder
+                   when :decode then strategy.decoder
+                   else raise ArgumentError, "Should never get here"
+                   end
+      transcoder.(input, options)
+    end
+
+    def strategies
+      self.class.strategies
+    end
+
+    def fetch_strategy(content_type, &fallback)
+      content_type = content_type.to_s.strip.split.first
+      strategies.detect(fallback) { |strategy|
+        strategy.patterns.any?{|pattern| pattern === content_type}
+      }
+    end
+
+    def unknown_type_handler(content_type)
+      -> do
+        raise ArgumentError, "Unrecognized content type #{content_type.inspect}"
+      end
+    end
+  end
+end

data/lib/leadlight/enumerable_representation.rb

@@ -0,0 +1,24 @@
+module Leadlight
+  module EnumerableRepresentation
+    Tint = Tint.new('EnumerableRepresentation') do
+      match_class(Enumerable)
+      extend(EnumerableRepresentation)
+    end
+
+    def each(call_super=false,&block)
+      if call_super
+        return super(&block)
+      end
+
+      page = self
+      loop do
+        page.each(true, &block)
+        if (next_link = page.link('next'){nil})
+          page = next_link.follow
+        else
+          break
+        end
+      end
+    end
+  end
+end

data/lib/leadlight/errors.rb

@@ -0,0 +1,14 @@
+module Leadlight
+  class Error < StandardError; end
+  class CredentialsRequiredError < Error; end
+  class HttpError < Error
+    attr_reader :response
+    def initialize(response)
+      @response = response
+      super("HTTP Error #{response.status}")
+    end
+  end
+  class ClientError < HttpError; end
+  class ResourceNotFound < ClientError; end
+  class ServerError < HttpError; end
+end

data/lib/leadlight/hyperlinkable.rb

@@ -0,0 +1,126 @@
+require 'addressable/uri'
+require 'addressable/template'
+require 'link_header'
+require 'leadlight/link'
+require 'leadlight/link_template'
+require 'forwardable'
+require 'fattr'
+
+module Leadlight
+  module Hyperlinkable
+    def self.extended(representation)
+      super(representation)
+      representation.add_link(representation.__response__.env[:url],
+                              'self', 'self', rev: 'self')
+      representation.add_links_from_headers
+    end
+
+    def links(key=:none)
+      if :none == key
+        @__links__ ||= LinkSet.new
+      else
+        links[key]
+      end
+    end
+
+    def link(key, &fallback)
+      result = links.at(key, &fallback)
+    end
+
+    def add_link(url, rel=nil, title=rel, options={})
+      link = Link.new(__service__, url, rel, title, options)
+      define_link_helper(rel) if rel
+      links << link
+    end
+
+    def add_link_template(template, rel=nil, title=rel, options={})
+      link = LinkTemplate.new(__service__, template, rel, title, options)
+      define_link_helper(rel) if rel
+      links << link
+    end
+
+    def add_link_set(rel=nil, helper_name=rel)
+      default_link_attributes = {
+        rel: rel
+      }
+      yield.each do |link_attributes|
+        attributes = default_link_attributes.merge(link_attributes)
+        define_link_set_helper(rel, helper_name) if helper_name
+        links << Link.new(__service__, 
+                          attributes[:href], 
+                          attributes[:rel], 
+                          attributes[:title], 
+                          attributes)
+      end
+    end
+
+    def add_links_from_headers
+      raw_link_header = __response__.env[:response_headers]['Link']
+      link_header = LinkHeader.parse(raw_link_header.to_s)
+      link_header.links.each do |link|
+        add_link(link.href, link['rel'], link['rel'])
+      end
+    end
+
+    private
+
+    class LinkSet
+      extend Forwardable
+      include Enumerable
+      fattr(:links) { Set.new }
+
+      def_delegators :links, :<<, :push, :size, :length, :empty?, :each, 
+                             :initialize
+
+      # Match links on rel or title
+      def [](key)
+        self.class.new(select(&link_matcher(key)))
+      end
+
+      # Matches only one link
+      def at(key, &fallback)
+        fallback ||= -> do raise KeyError, "No link matches #{key.inspect}" end
+        detect(fallback, &link_matcher(key))
+      end
+
+      private
+
+      def link_matcher(key)
+        ->(link) {
+          key === link.rel   || 
+          key === link.title ||
+          link.aliases.any?{|a| key === a}
+        }
+      end
+    end
+
+    def __link_helper_module__
+      @__link_helper_module__ ||=
+        begin
+          mod = Module.new
+          self.extend(mod)
+          mod
+        end
+    end
+
+    def define_link_helper(name)
+      __link_helper_module__.module_eval do
+        define_method(name) do |*args|
+          link(name).follow(*args) do |result|
+            return result
+          end
+        end
+      end
+    end
+
+    def define_link_set_helper(rel, name)
+      __link_helper_module__.module_eval do
+        define_method(name) do |key, *args|
+          links(rel).at(key).follow(*args) do |result|
+            return result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leadlight/link.rb

@@ -0,0 +1,35 @@
+module Leadlight
+  class Link
+    HTTP_METHODS = [
+      :options, :head, :get, :get_representation!, :post, :put, :delete, :patch
+    ]
+
+    attr_reader :service
+    attr_reader :rel
+    attr_reader :rev
+    attr_reader :title
+    attr_reader :href
+    attr_reader :aliases
+
+    def initialize(service, href, rel=nil, title=rel, options={})
+      @service = service
+      @href    = Addressable::URI.parse(href)
+      @rel     = rel.to_s
+      @title   = title.to_s
+      @rev     = options[:rev]
+      @aliases = Array(options[:aliases])
+    end
+
+    [:options, :head, :get, :get_representation!, :post, :put, :delete, :patch].each do |name|
+      define_method(name) do |*args, &block|
+        service.public_send(name, href, *args, &block)
+      end
+    end
+
+    def follow(*args)
+      get_representation!(*args) do |representation|
+        return representation
+      end
+    end
+  end
+end

data/lib/leadlight/link_template.rb

@@ -0,0 +1,47 @@
+require 'leadlight/link'
+require 'addressable/template'
+
+module Leadlight
+  class LinkTemplate < Link
+
+    def href_template
+      @href_template ||= Addressable::Template.new(href.to_s)
+    end
+
+    HTTP_METHODS.each do |name|
+      define_method(name) do |*args, &block|
+        expanded_href = expand(args)
+        service.public_send(name, expanded_href, *args, &block)
+      end
+    end
+
+    def expand(args)
+      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
+      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
+    end
+
+    private
+
+    def assert_all_variables_mapped(template, mapping)
+      supplied_keys = mapping.keys.map(&:to_s)
+      needed_keys   = template.variables
+      missing_keys  = needed_keys - supplied_keys
+      if !missing_keys.empty?
+        raise ArgumentError,
+              "Missing URI template parameters: #{missing_keys.inspect}"
+      end
+    end
+  end
+end

data/lib/leadlight/representation.rb

@@ -0,0 +1,30 @@
+require 'addressable/uri'
+require 'leadlight/link'
+
+module Leadlight
+  module Representation
+    attr_accessor :__service__
+    attr_accessor :__location__
+    attr_accessor :__response__
+    attr_accessor :__type__
+
+    def initialize_representation(service, location, response)
+      self.__service__ = service
+      self.__location__ = location
+      self.__response__ = response
+      self
+    end
+
+    def apply_all_tints
+      __service__.tints.inject(self, &:extend)
+      __apply_tint__
+      self
+    end
+
+
+    private
+
+    def __apply_tint__
+    end
+  end
+end

data/lib/leadlight/request.rb

@@ -0,0 +1,91 @@
+require 'monitor'
+require 'fattr'
+require 'hookr'
+require 'leadlight/errors'
+
+module Leadlight
+  class Request
+    include HookR::Hooks
+    include MonitorMixin
+
+    fattr(:http_method)
+    fattr(:url)
+    fattr(:connection)
+    fattr(:body)
+    fattr(:params)
+
+    attr_reader :response    
+
+    define_hook :on_prepare_request, :request
+    define_hook :on_complete,        :response
+
+    def initialize(connection, url, method, params={}, body=nil)
+      self.connection  = connection
+      self.url         = url
+      self.http_method = method
+      self.body        = body
+      self.params      = params
+      @completed       = new_cond
+      @state           = :initialized
+      @env             = nil
+      @response        = nil
+      super
+    end
+
+    def completed?
+      :completed == @state
+    end
+
+    def submit
+      connection.run_request(http_method, url, body, {}) do |request|
+        execute_hook(:on_prepare_request, request)
+      end.on_complete do |env|
+        synchronize do
+          @response = Faraday::Response.new(env)
+          execute_hook :on_complete, @response
+          @env = env
+          @state = :completed
+          @completed.broadcast
+        end
+      end
+    end
+
+    def wait
+      synchronize do
+        @completed.wait_until{completed?}
+      end
+      yield(@env.fetch(:leadlight_representation)) if block_given?
+      self
+    end
+
+    def submit_and_wait(&block)
+      submit
+      wait(&block)
+    end
+    alias_method :then, :submit_and_wait
+
+    def raise_on_error
+      on_or_after_complete do |response|
+        case response.status.to_i
+        when 404
+          raise ResourceNotFound, response
+        when (400..499)
+          raise ClientError, response
+        when (500..599)
+          raise ServerError, response
+        end
+      end
+      self
+    end
+
+    def on_or_after_complete(&block)
+      synchronize do
+        if completed?
+          block.call(response)
+        else
+          on_complete(&block)
+        end
+      end
+    end
+  end
+end