restfulie 0.7.2 → 0.8.0

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

@@ -1,73 +0,0 @@
-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) || 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 self.marshalling_classes(media_type)
-      {"application/atom+xml" => Restfulie::Common::Builder::Marshalling::Atom,
-        "application/xml" => Restfulie::Common::Builder::Marshalling::Xml::Marshaller,
-        "application/json" => Restfulie::Common::Builder::Marshalling::Json,
-        "atom" => Restfulie::Common::Builder::Marshalling::Atom, # test only
-        "xml" => Restfulie::Common::Builder::Marshalling::Xml::Marshaller # test only
-        }[media_type.downcase]
-  end
-
-  def marshalling_class(method)
-    if (marshalling_name = method.to_s.match(/to_(.*)/))
-      marshalling = marshalling_name[1].downcase
-      Restfulie::Common::Builder::Base.marshalling_classes(marshalling)
-    end
-  end
-  
-  def marshalling_class!(method)
-    if marshalling_name = method.to_s.match(/to_(.*)/)
-      marshalling = marshalling_name[1].downcase
-      if (marshaller = Restfulie::Common::Builder::Base.marshalling_classes(marshalling))
-        marshaller
-      else
-        raise Restfulie::Common::Error::UndefinedMarshallingError.new("Marshalling #{marshalling} not found.")
-      end
-    end
-  end
-
-end

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

@@ -1,22 +0,0 @@
-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

@@ -1,197 +0,0 @@
-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] && 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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,183 +0,0 @@
-# support xml serialization for custom attributes
-module Restfulie::Common::Builder::Rules::CustomAttributes
-  
-  def to_xml(writer)
-    custom_attributes.each do |key, value|
-      writer.tag!(key, value)
-    end
-  end
-  
-end
-
-module Restfulie::Common::Builder::Marshalling::Xml
-end
-
-# Xml collection rule answering to to_xml and allowing any custom element to be inserted
-# All links will be automatically inserted.
-class Restfulie::Common::Builder::Marshalling::Xml::CollectionRule < Restfulie::Common::Builder::CollectionRule
-  
-  include Restfulie::Common::Builder::Rules::CustomAttributes
-
-  def to_xml(writer)
-    super(writer)
-    links.each do |link|
-      writer.link(:rel => link.rel, :href => link.href, :type => (link.type || 'application/xml')) if link.href
-    end
-  end
-
-end
-
-# Xml member rule answering to to_xml and allowing any custom element to be inserted.
-# All links will be automatically inserted.
-class Restfulie::Common::Builder::Marshalling::Xml::MemberRule < Restfulie::Common::Builder::MemberRule
-
-  include ActionController::UrlWriter
-  include Restfulie::Common::Builder::Rules::CustomAttributes
-
-  def to_xml(object, writer)
-    super(writer)
-    # Transitions
-    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/xml'
-      end
-      writer.link(:rel => atom_link[:rel], :href => atom_link[:href], :type => (link.type || 'application/xml')) if atom_link[:href]
-
-    end
-  end
-
-  private
-  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
-
-end
-
-class Restfulie::Common::Builder::Marshalling::Xml::Marshaller < Restfulie::Common::Builder::Marshalling::Base
-  include ActionController::UrlWriter
-  include Restfulie::Common::Builder::Helpers
-  include Restfulie::Common::Error
-  
-  def initialize(object, rules)
-    @object = object
-    @rules   = rules
-  end
-
-  def builder_collection(options = {})
-    builder_feed(@object, @rules, options)
-  end
-
-  def builder_member(options = {})
-    options[:indent]   ||= 2
-    options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    options[:skip_types] = true
-    builder_entry(@object, options[:builder], @object.class.name.underscore, @rules, options)
-  end
-
-private
-
-  def builder_feed(objects, rules_blocks, options = {})
-    rule = Restfulie::Common::Builder::Marshalling::Xml::CollectionRule.new(rules_blocks)
-
-    rule.blocks.unshift(default_collection_rule) if options[:default_rule]
-    rule.apply(objects, options)
-    
-    # setup code from Rails to_xml
-
-     options[:root]     ||= objects.all? { |e| e.is_a?(objects.first.class) && objects.first.class.to_s != "Hash" } ? objects.first.class.to_s.underscore.pluralize : "records"
-     options[:children] ||= options[:root].singularize
-     options[:indent]   ||= 2
-     options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-     root     = options.delete(:root).to_s
-     children = options.delete(:children)
-
-     if !options.has_key?(:dasherize) || options[:dasherize]
-       root = root.dasherize
-     end
-
-     options[:builder].instruct! unless options.delete(:skip_instruct)
-
-     opts = options.merge({ :root => children })
-
-     writer = options[:builder]
-
-     # Entries
-     options.delete(:values)
-     member_options = options.merge(rule.members_options || {})
-     member_options[:skip_instruct] = true
-     start_with_namespace(rule.namespaces, writer, root, options[:skip_types] ? {} : {}) do
-       rule.to_xml(writer)
-       yield writer if block_given?
-       
-       objects.each { |e| 
-         builder_entry(e, writer, children, rule.members_blocks || [], member_options)
-       }
-     end
-     
-  end
-  
-  def start_with_namespace(namespaces, writer, root, condition, &block)
-    spaces = condition.dup
-    namespaces.each do |ns|
-      ns.each do |key, value|
-        spaces["xmlns:#{ns.namespace}"] = ns.uri
-      end if ns.uri
-    end
-    result = writer.tag!(root, spaces) do |inner|
-      namespaces.each do |ns|
-        ns.each do |key, value|
-          tag = ns.namespace ? "#{key}" : "#{ns.namespace}:#{key}"
-          inner.tag! tag, value
-        end
-      end
-      block.call inner
-    end
-  end
-  
-  def default_collection_rule
-    Proc.new do |collection_rule, objects, options|
-    end
-  end
-  
-  def builder_entry(object, xml, children, rules_blocks, options)
-    rule    = Restfulie::Common::Builder::Marshalling::Xml::MemberRule.new(rules_blocks)
-    options = namespace_enhance(options)
-
-    rule.blocks.unshift(default_member_rule) if options[:default_rule]
-    rule.apply(object, options)
-    
-    start_with_namespace(rule.namespaces, xml, children, {}) do |inner_xml|
-      rule.to_xml(object, inner_xml)
-    end
-  end
-
-  def default_member_rule
-    Proc.new do |member_rule, object, options|
-      if options[:namespace]
-        member_rule.namespace(object, options[:namespace][:uri], options[:namespace])
-      else
-        member_rule.namespace(object, nil, options[:namespace] || {})
-      end
-    end
-  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.rb

@@ -1,16 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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/custom_attributes.rb

@@ -1,24 +0,0 @@
-# Rules that allow any type of content shall extend this one and provide valid serialization methods. i.e.: to_xml
-module Restfulie::Common::Builder::Rules::CustomAttributes
-
-  # returns true if it's a valid attribute evaluation or 
-  def method_missing(sym, *args)
-    if sym.to_s.last=="=" && args.size==1
-      custom_attributes[sym.to_s.chop] = args[0]
-    elsif custom_attributes[sym.to_s]
-      custom_attributes[sym.to_s]
-    else
-      super(sym, *args)
-    end
-  end
-  
-  def respond_to?(sym)
-    super(sym) || (sym.to_s.last == "=") || custom_attributes[sym.to_s]
-  end
-  
-  private
-  
-  def custom_attributes
-    @custom_attributes ||= {}
-  end
-end

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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,35 +0,0 @@
-# Representation of a namespace. Allows any type of attribute setting and grabbing, i.e.:
-#
-# collection.namespace(:basket, "http://openbuy.com/basket") do |ns|
-#   ns.price = @basket.cost
-# end
-#
-# or
-#
-# collection.describe_members(:namespaces => "http://localhost:3000/items") do |member, item|
-#   member.links << link( :rel => :self, :href => item_url(item))
-# end
-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)
-    @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