restfulie 0.6.0 → 0.7.0

data/lib/restfulie/client/http/marshal.rb

@@ -0,0 +1,147 @@
+#Request builder for marshalled data that unmarshalls content after receiving it.
+module Restfulie::Client::HTTP
+
+  module ResponseHolder
+    attr_accessor :response
+    
+    def respond_to?(symbol)
+      respond_to_rel?(symbol.to_s) || super(symbol)
+    end
+    
+    private
+    # whether this response contains specific relations
+    def respond_to_rel?(rel)
+      links.any? { |link| link.rel==rel }
+    end
+    
+  end
+
+  module RequestMarshaller
+    include ::Restfulie::Client::HTTP::RequestBuilder
+    
+    # accepts a series of media types by default
+    def initialize
+      @acceptable_mediatypes = "application/atom+xml"
+    end
+
+    @@representations = {
+      'application/atom+xml' => ::Restfulie::Common::Representation::Atom,
+      'application/xml' => ::Restfulie::Common::Representation::XmlD
+    }
+    def self.register_representation(media_type,representation)
+      @@representations[media_type] = representation
+    end
+
+    def self.content_type_for(media_type)
+      content_type = media_type.split(';')[0] # [/(.*?);/, 1]
+      type = @@representations[content_type]
+      type ? type.new : nil
+    end
+
+    def accepts(media_types)
+      @acceptable_mediatypes = media_types
+      @default_representation = @@representations[media_types]
+      raise "Undefined representation for #{media_types}" unless @default_representation
+      super
+    end
+
+    def raw
+      @raw = true
+      self
+    end
+
+    #Executes super and unmarshalls it
+    def request!(method, path, *args)
+      representation = do_conneg_and_choose_representation(method, path, *args)
+      if representation
+        if has_payload?(method, path, *args)
+          payload = get_payload(method, path, *args)
+          rel = self.respond_to?(:rel) ? self.rel : ""
+          payload = representation.marshal(payload, rel)
+          args = set_marshalled_payload(method, path, payload, *args)
+        end
+        args = add_representation_headers(method, path, representation, *args)
+      end
+      response = super(method, path, *args) 
+      parse_response(response, representation)
+    end
+
+    private
+    
+    # parses the http response.
+    # first checks if its a 201, redirecting to the resource location.
+    # otherwise check if its a raw request, returning the content itself.
+    # finally, tries to parse the content with a mediatype handler or returns the response itself.
+    def parse_response(response, representation)
+      if response.code == 201
+        location = response.headers['location']
+        Restfulie.at(location).accepts(@acceptable_mediatypes).get!
+      elsif @raw
+        response
+      elsif !response.body.empty?
+        representation = RequestMarshaller.content_type_for(response.headers['content-type']) || Restfulie::Common::Representation::Generic.new
+        unmarshalled = representation.unmarshal(response.body)
+        unmarshalled.extend(ResponseHolder)
+        unmarshalled.response = response
+        unmarshalled
+      else
+        response
+      end
+    end
+    
+    def content_type_for(media_type)
+      @@representations[media_type.split(';')[0]].new # [/(.*?);/, 1]
+    end
+
+    def do_conneg_and_choose_representation(method, path, *args)
+      #TODO make a request to server (conneg)
+      representation = @default_representation || @default_representation = @@representations['application/atom+xml']
+      representation.new
+    end
+
+    def has_payload?(method, path, *args)
+      [:put,:post].include?(method)
+    end
+
+    def get_payload(method, path, *args)
+      args.extract_options! #remove header
+      args.shift #payload
+    end
+
+    def set_marshalled_payload(method, path, payload, *args)
+      headers = args.extract_options!
+      args.shift #old payload
+      args << payload << headers
+      args
+    end
+
+    def add_representation_headers(method, path, representation, *args)
+      headers = args.extract_options!
+      args << representation.headers[method] 
+      args
+    end
+
+  end
+
+  #=This class includes RequestBuilder module.
+  class RequestMarshallerExecutor
+    include RequestMarshaller
+
+    # * <tt> host (e.g. 'http://restfulie.com') </tt>
+    # * <tt> default_headers  (e.g. {'Cache-control' => 'no-cache'} ) </tt>
+    def initialize(host, default_headers = {})
+      self.host=host
+      self.default_headers=default_headers
+    end
+
+    def at(path)
+      @path = path
+      self
+    end
+    def path
+      @path
+    end
+  end
+
+end
+

data/lib/restfulie/client/http.rb

@@ -0,0 +1,13 @@
+module Restfulie::Client::HTTP#:nodoc:
+end
+
+%w(
+  error
+  adapter
+  cache
+  marshal
+  atom_ext
+).each do |file|
+  require "restfulie/client/http/#{file}"
+end
+

data/lib/restfulie/client.rb

@@ -1,60 +1,12 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
+require 'restfulie/common'
 
-require 'restfulie/logger'
+module Restfulie::Client; end
 
-require 'net/http'
-require 'uri'
-require 'vendor/jeokkarak/jeokkarak'
-
-require 'restfulie/media_type'
-require 'restfulie/client/atom_media_type'
-require 'restfulie/client/base'
-require 'restfulie/client/entry_point'
-require 'restfulie/client/helper'
-require 'restfulie/client/instance'
-require 'restfulie/client/request_execution'
-require 'restfulie/client/state'
-require 'restfulie/client/cache'
-require 'restfulie/unmarshalling'
-
-module Restfulie
-  
-  class << self
-    attr_accessor :cache_provider
-  end
-  
-  # Extends your class to support restfulie-client side's code.
-  # This will extends Restfulie::Client::Base methods as class methods,
-  # Restfulie::Client::Instance as instance methods and Restfulie::Unmarshalling as class methods.
-  def uses_restfulie
-    extend Restfulie::Client::Base
-    include Restfulie::Client::Instance
-    extend Restfulie::Unmarshalling
-  end
-  
-end
-
-Object.extend Restfulie
-
-include ActiveSupport::CoreExtensions::Hash
-
-class Hashi::CustomHash
-    uses_restfulie
+%w(
+  http
+  configuration
+  base
+).each do |file|
+  require "restfulie/client/#{file}"
 end
 
-Restfulie.cache_provider = Restfulie::BasicCache.new

data/lib/restfulie/common/builder/builder_base.rb

@@ -0,0 +1,58 @@
+class Restfulie::Common::Builder::Base
+  attr_accessor :rules_blocks
+  attr_accessor :object
+  
+  # TODO: Configurable
+  OPTIONS_DEFAULT = {
+    :eagerload => true,
+    :default_rule => true
+  }
+
+  def initialize(object, rules_blocks = [], options = {})
+    @options = OPTIONS_DEFAULT.merge(options)
+    @object  = object
+    @rules_blocks = rules_blocks
+  end
+
+  # Remove to_json from ActiveSupport in the class
+  # I want my own to_json
+  undef_method :to_json if respond_to?(:to_json)
+
+  def respond_to?(symbol, include_private = false)
+    !marshalling_class(symbol).nil? || super
+  end
+
+  def method_missing(symbol, *args)
+    unless (marshalling = marshalling_class(symbol)).nil?
+      return builder(marshalling, *args)
+    end
+    super
+  end
+
+private
+
+  def builder(marshalling, options = {})
+    @object.class.ancestors.include?(Enumerable) ? builder_collection(marshalling, options) : builder_member(marshalling, options)
+  end
+
+  def builder_member(marshalling, options = {})
+    marshalling.new(@object, rules_blocks).builder_member(@options.merge(options))
+  end
+
+  def builder_collection(marshalling, options = {})
+    marshalling.new(@object, rules_blocks).builder_collection(@options.merge(options))
+  end
+
+  def marshalling_class(method)
+    if marshalling_name = method.to_s.match(/to_(.*)/)
+      marshalling = marshalling_name[1].downcase.capitalize.to_sym
+      if Restfulie::Common::Builder::Marshalling.const_defined?(marshalling)
+        begin
+          Restfulie::Common::Builder::Marshalling.const_get(marshalling) 
+        rescue NameError
+          raise Restfulie::Common::Error::UndefinedMarshallingError.new("Marshalling #{marshalling} not found.")
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/builder/helpers.rb

@@ -0,0 +1,22 @@
+module Restfulie::Common::Builder::Helpers
+
+  def describe_member(member, options = {}, &block)
+    create_builder(member, options, &block)
+  end
+  
+  def describe_collection(collection, options = {}, &block)
+    create_builder(collection, options, &block)
+  end
+  
+  # Helper to create objects link
+  def link(*args)
+    Restfulie::Common::Builder::Rules::Link.new(*args)
+  end
+  
+private
+
+  def create_builder(object, options, &block)
+    Restfulie::Common::Builder::Base.new(object, block_given? ? [block] : [], options)
+  end
+
+end

data/lib/restfulie/common/builder/marshalling/atom.rb

@@ -0,0 +1,197 @@
+class Restfulie::Common::Builder::Marshalling::Atom < Restfulie::Common::Builder::Marshalling::Base
+  include ActionController::UrlWriter
+  include Restfulie::Common::Builder::Helpers
+  include Restfulie::Common::Error
+  
+  ATOM_ATTRIBUTES = [
+    :title, :id, :updated, # Required
+    :author, :links, # Recommended
+    :category, :contributor, :rights # Optional
+  ]
+  
+  ATOM_ATTRIBUTES_ENTRY = ATOM_ATTRIBUTES + [
+    :content, :summary, # Required
+    :published, :source # Optional
+  ]
+  
+  ATOM_ATTRIBUTES_FEED = ATOM_ATTRIBUTES + [
+    :generator, :icon, :logo, :subtitle # Optional
+  ]
+  
+  ATTRIBUTES_ALREADY_IN_ATOM_SPEC = [
+    "id", "created_at", "updated_at", "title"
+  ]
+
+  def initialize(object, rules)
+    @object = object
+    @rules   = rules
+  end
+
+  def builder_collection(options = {})
+    builder_feed(@object, @rules, options).to_xml
+  end
+
+  def builder_member(options = {})
+    builder_entry(@object, @rules, options).to_xml
+  end
+
+private
+
+  def builder_feed(objects, rules_blocks, options = {})
+    rule = Restfulie::Common::Builder::CollectionRule.new(rules_blocks)
+
+    rule.blocks.unshift(default_collection_rule) if options[:default_rule]
+    rule.metaclass.send(:attr_accessor, *ATOM_ATTRIBUTES_FEED)
+    rule.apply(objects, options)
+
+    atom = ::Atom::Feed.new do |feed|
+      # Set values
+      (ATOM_ATTRIBUTES_FEED - [:links]).each do |field|
+        feed.send("#{field}=".to_sym, rule.send(field)) unless rule.send(field).nil?
+      end
+
+      # Namespaces
+      builder_namespaces(rule.namespaces, feed)
+
+      # Transitions
+      rule.links.each do |link|
+        atom_link = {:rel => link.rel, :href => link.href, :type => (link.type || 'application/atom+xml')}
+        feed.links << ::Atom::Link.new(atom_link) unless atom_link[:href].nil?
+      end
+
+      # Entries
+      options.delete(:values)
+      member_options = options.merge(rule.members_options || {})
+      objects.each do |member|
+        feed.entries << builder_entry(member, rule.members_blocks || [], member_options)
+      end
+    end
+  end
+  
+  # TODO: Validate of the required fields
+  def default_collection_rule
+    Proc.new do |collection_rule, objects, options|
+      # Passed values
+      (options[:values] || {}).each { |key, value| collection_rule.send("#{key}=".to_sym, value)}
+      
+      # Default values
+      collection_rule.id        ||= options[:self]
+      collection_rule.title     ||= "#{objects.first.class.to_s.pluralize.demodulize} feed"
+      collection_rule.updated   ||= updated_collection(objects)
+
+      # Transitions
+      collection_rule.links << link(:rel => :self, :href => options[:self]) unless options[:self].nil?
+    end
+  end
+
+  def builder_entry(object, rules_blocks, options = {})
+    rule    = Restfulie::Common::Builder::MemberRule.new(rules_blocks)
+    options = namespace_enhance(options)
+    
+    rule.blocks.unshift(default_member_rule) if options[:default_rule]
+    rule.metaclass.send(:attr_accessor, *ATOM_ATTRIBUTES_ENTRY)
+    rule.apply(object, options)
+
+    atom = ::Atom::Entry.new do |entry|
+      # Set values
+      (ATOM_ATTRIBUTES_ENTRY - [:links]).each do |field|
+        entry.send("#{field}=".to_sym, rule.send(field)) unless rule.send(field).nil?
+      end
+
+      # Namespaces
+      builder_namespaces(rule.namespaces, entry)
+      
+      # Transitions
+      rule.links.each do |link|
+        atom_link = {:rel => link.rel, :href => link.href, :type => link.type}
+
+        # Self
+        if link.href.nil?
+          if link.rel == "self"
+            path = object
+          else
+            association = object.class.reflect_on_all_associations.find { |a| a.name.to_s == link.rel }
+            path = (association.macro == :has_many) ? [object, association.name] : object.send(association.name) unless association.nil? 
+          end
+          atom_link[:href] = polymorphic_url(path, :host => host) rescue nil
+          atom_link[:type] = link.type || 'application/atom+xml'
+        end
+
+        entry.links << ::Atom::Link.new(atom_link) unless atom_link[:href].nil?
+      end
+    end
+  end
+
+  def default_member_rule
+    Proc.new do |member_rule, object, options|
+      # Passed values
+      (options[:values] || {}).each { |key, value| set_attribute(member_rule, key, value) }
+
+      # Default values
+      member_rule.id      ||= polymorphic_url(object, :host => host) rescue nil
+      member_rule.title   ||= object.respond_to?(:title) && !object.title.nil? ? object.title : "Entry about #{object.class.to_s.demodulize}"
+      member_rule.updated ||= object.updated_at if object.respond_to?(:updated_at)
+
+      # Namespace
+      unless options[:namespace].nil?
+        member_rule.namespace(object, options[:namespace][:uri], options[:namespace])
+      end
+    end
+  end
+
+  def updated_collection(objects)
+    objects.map { |item| item.updated_at if item.respond_to?(:updated_at) }.compact.max || Time.now
+  end
+
+  def builder_namespaces(namespaces, atom)
+    kclass = atom.class
+    namespaces.each do |ns|
+      register_namespace(ns.namespace, ns.uri, kclass)
+      ns.each do |key, value|
+        unless ATTRIBUTES_ALREADY_IN_ATOM_SPEC.include?(key.to_s)
+          register_element(ns.namespace, key, kclass)
+          atom.send("#{ns.namespace}_#{key}=".to_sym, value)
+        end
+      end
+    end
+  end
+
+  def host
+    # TODO: If we split restfulie into 2 separate gems, we may need not to use Restfulie::Server
+    #       inside Restfulie::Common
+    Restfulie::Server::Configuration.host
+  end
+
+  def register_namespace(namespace, uri, klass)
+    klass.add_extension_namespace(namespace, uri) unless klass.known_namespaces.include? uri
+  end
+
+  def register_element(namespace, attribute, klass)
+    attribute = "#{namespace}:#{attribute}"
+    klass.element(attribute) if element_unregistered?(attribute, klass)
+  end
+
+  def element_unregistered?(element, klass)
+    klass.element_specs.select { |k,v|  v.name == element }.empty?
+  end
+  
+  # TODO : Move error handling to class rule, maybe?
+  def set_attribute(rule, attribute, value)
+    begin
+      rule.send("#{attribute}=".to_sym, value)
+    rescue NoMethodError
+      raise AtomMarshallingError.new("Attribute #{attribute} unsupported in Atom #{rule_type_name(rule)}.")
+    end
+  end
+  
+  def rule_type_name(rule)
+    rule.kind_of?(Restfulie::Common::Builder::MemberRule) ? 'Entry' : 'Feed'
+  end
+  
+  def namespace_enhance(options)
+    if !options[:namespace].nil? && options[:namespace].kind_of?(String)
+      options[:namespace] = { :uri => options[:namespace], :eager_load => true }
+    end
+    options
+  end
+end

data/lib/restfulie/common/builder/marshalling/base.rb

@@ -0,0 +1,12 @@
+class Restfulie::Common::Builder::Marshalling::Base
+  def initialize(*args)
+  end
+  
+  def builder_member(options = {})
+    "#{self.class.to_s.demodulize} Marshalling not implemented"
+  end
+  
+  def builder_collection(options = {})
+    "#{self.class.to_s.demodulize} Marshalling not implemented"
+  end
+end

data/lib/restfulie/common/builder/marshalling/json.rb

@@ -0,0 +1,2 @@
+class Restfulie::Common::Builder::Marshalling::Json < Restfulie::Common::Builder::Marshalling::Base
+end

data/lib/restfulie/common/builder/marshalling.rb

@@ -0,0 +1,16 @@
+module Restfulie::Common::Builder::Marshalling
+  class << self
+    def add_autoload_path(path)
+      if File.directory?(path)
+        Dir["#{path}/*.rb"].each do |file|
+          marshalling_class = File.basename(file, ".rb").downcase.classify.to_sym
+          self.autoload(marshalling_class, file) if !self.const_defined?(marshalling_class) && self.autoload?(marshalling_class).nil?
+        end
+      else
+        raise Restfulie::Common::Error::MarshallingError.new("#{path} is not a path.")
+      end
+    end
+  end
+
+  self.add_autoload_path(File.join(File.dirname(__FILE__), 'marshalling'))
+end

data/lib/restfulie/common/builder/rules/collection_rule.rb

@@ -0,0 +1,10 @@
+class Restfulie::Common::Builder::CollectionRule < Restfulie::Common::Builder::Rules::Base
+  attr_reader :members_blocks
+  attr_reader :members_options
+  
+  def describe_members(options = {}, &block)
+    @members_blocks  = block_given? ? [block] : []
+    @members_options = options
+  end
+  
+end

data/lib/restfulie/common/builder/rules/link.rb

@@ -0,0 +1,20 @@
+class Restfulie::Common::Builder::Rules::Link
+  # Required
+  attr_accessor :href
+
+  # Optional
+  attr_accessor :rel, :type
+  attr_accessor :hreflang, :title, :length
+
+  # TODO: Inline resource and collection support
+  def initialize(options = {})
+    options = { :rel => options } unless options.kind_of?(Hash)
+    options.each do |k, i|
+      self.send("#{k}=".to_sym, i)
+    end
+  end
+
+  def rel=(value)
+    @rel = value.kind_of?(String) ? value : value.to_s
+  end
+end

data/lib/restfulie/common/builder/rules/links.rb

@@ -0,0 +1,9 @@
+class Restfulie::Common::Builder::Rules::Links < Array
+  alias_method :old_delete, :delete
+
+  def delete(item)
+    item = item.to_s if item.kind_of?(Symbol) 
+    deleted = old_delete(item)
+    deleted.nil? ? old_delete(find { |i| i.rel == item }) : deleted
+  end
+end

data/lib/restfulie/common/builder/rules/member_rule.rb

@@ -0,0 +1,8 @@
+class Restfulie::Common::Builder::MemberRule < Restfulie::Common::Builder::Rules::Base
+  
+  # Recommended
+  # attr_accessor :content, :summary # Not implemented
+  
+  # Optional
+  # attr_accessor :source # Not implemented
+end

data/lib/restfulie/common/builder/rules/namespace.rb

@@ -0,0 +1,25 @@
+class Restfulie::Common::Builder::Rules::Namespace < Hash
+  attr_reader :namespace
+  attr_reader :uri
+
+  def initialize(ns, uri, *args)
+    @namespace = ns.to_sym
+    self.uri = uri
+    super(*args)
+  end
+  
+  def uri=(value)
+    raise Restfulie::Common::Error::NameSpaceError.new('Namespace can not be blank uri.') if value.blank?
+    @uri = value
+  end
+
+  def method_missing(symbol, *args)
+    if ((key = symbol.to_s.match(/(.*)=/)) && args.size >= 1)
+      self[key[1].to_sym] = args.first
+    elsif(keys.include?(symbol))
+      self[symbol]
+    else
+      super
+    end
+  end
+end