restfulie 0.7.2 → 0.8.0

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

@@ -1,77 +0,0 @@
-module Restfulie::Common::Builder::Rules; end
-
-# Set of rules that can be used to describe a resource in a tokamak view.
-class Restfulie::Common::Builder::Rules::Base
-  attr_accessor :blocks
-  attr_accessor :links
-  attr_reader :namespaces
-
-  def initialize(blocks = [], &block)
-    @links  = Restfulie::Common::Builder::Rules::Links.new
-    @blocks = (block_given? ? [block] : []) + blocks
-    @namespaces = []
-  end
-
-  def apply(*args)
-    @blocks.each do |block|
-      params = ([self] + args)[0..block.arity-1]
-      block.call(*params)
-    end
-  end
-
-  # Use to register a namespace
-  #
-  #==Example:
-  #
-  #  namespace(@album , "http://example.com")
-  #  namespace(:albums, "http://example.com")
-  #  namespace(:albums, "http://example.com", :eager_load => false)
-  #  namespace(:albums, "http://example.com", :eager_load => { :title => 'A title' })
-  #
-  def namespace(ns, uri = nil, options = {}, &block)
-    object = nil
-    
-    if !ns.kind_of?(String) && !ns.kind_of?(Symbol)
-      object = ns
-      ns = object.class.to_s.demodulize.downcase.pluralize.to_sym
-      options[:eager_load] = true unless options.key?(:eager_load)
-    end
-    
-    unless [true, false, nil].include?(options[:eager_load])
-      object = options[:eager_load]
-      options[:eager_load] = true
-    end
-    
-    namespace = find_or_new_namespace(ns, uri)
-    eager_load(object, namespace) if options[:eager_load]
-    
-    yield(namespace) if block_given?
-    namespace
-  end
-
-  def metaclass
-    (class << self; self; end)
-  end
-
-private
-  # Load attributes of the object to passed hash.
-  # If object respond to attributes, attributes is merge, unless merge instance variables
-  def eager_load(object, ns)
-    if object.kind_of?(Hash)
-      ns.merge!(object.symbolize_keys)
-    elsif object.respond_to?(:attributes)
-      ns.merge!(object.attributes.symbolize_keys)
-    else
-      object.instance_variables.each do |var|
-        ns[var.gsub(/^@/, '').to_sym] = object.instance_variable_get(var)
-      end
-    end
-  end
-
-  # Search a namespace or create a new
-  def find_or_new_namespace(name, uri)
-    namespace = @namespaces.find { |n| n.namespace == name } || (@namespaces << Restfulie::Common::Builder::Rules::Namespace.new(name, uri)).last
-    namespace.uri = uri unless uri.nil?
-    namespace
-  end
-end

data/lib/restfulie/common/builder.rb

@@ -1,17 +0,0 @@
-#initialize namespace
-module Restfulie::Common::Builder; end
-
-%w(
-  helpers
-  builder_base
-  marshalling
-  rules/rules_base
-  rules/link
-  rules/links
-  rules/namespace
-  rules/member_rule
-  rules/collection_rule
-  rules/custom_attributes
-).each do |file|
-  require File.join(File.dirname(__FILE__), 'builder', file)
-end

data/lib/vendor/atom/configuration.rb

@@ -1,24 +0,0 @@
-# Copyright (c) 2008 The Kaphan Foundation
-#
-# For licensing information see LICENSE.txt.
-#
-# Please visit http://www.peerworks.org/contact for further information.
-#
-
-module Atom
-  class Configuration
-    def self.auth_hmac_enabled?
-      unless defined?(@auth_hmac_enabled)
-        begin
-          gem 'auth-hmac'
-          require 'auth-hmac'
-          @auth_hmac_enabled = true
-        rescue
-          @auth_hmac_enabled = false
-        end
-      else
-        @auth_hmac_enabled
-      end
-    end
-  end
-end

data/lib/vendor/atom/pub.rb

@@ -1,250 +0,0 @@
-# Copyright (c) 2008 The Kaphan Foundation
-#
-# For licensing information see LICENSE.txt.
-#
-# Please visit http://www.peerworks.org/contact for further information.
-#
-
-require 'vendor/atom'
-require 'vendor/atom/configuration'
-require 'vendor/atom/xml/parser'
-require 'vendor/atom/version'
-require 'xml/libxml'
-require 'uri'
-require 'net/http'
-
-module Atom
-  module Pub
-    class NotSupported < StandardError; end
-    class ProtocolError < StandardError
-      attr_reader :response
-      def initialize(response)
-        @response = response
-      end
-      
-      def to_s
-        "Invalid response: #{@response}"
-      end
-    end
-    
-    class Service
-      include Atom::Xml::Parseable
-      namespace Atom::Pub::NAMESPACE
-      elements :workspaces
-      loadable! do |reader, message, severity, base, line|
-        if severity == XML::Reader::SEVERITY_ERROR
-          raise ArgumentError, "#{message} at #{line}"
-        end
-      end
-      
-      def initialize(xml = nil)
-        @workspaces = []
-
-        if xml
-          begin
-            if next_node_is?(xml, 'service', Atom::Pub::NAMESPACE)
-              xml.read
-              parse(xml)
-            else
-              raise ArgumentError, "XML document was missing atom:service"        
-            end
-          ensure
-            xml.close
-          end
-        end
-        
-        yield(self) if block_given?        
-      end
-    end
-    
-    class Categories < DelegateClass(Array)
-      include Atom::Xml::Parseable
-      elements :categories, :class => Atom::Category
-      attribute :href, :fixed
-      
-      def initialize(o)
-        super([])
-        parse(o, :once => true)
-        o.read
-        parse(o)
-      end
-
-      remove_method :categories
-      def categories; self; end
-      
-      # True true if fixed was 'yes' or 'true'
-      def fixed?
-        !self.fixed.nil? && %w(yes true).include?(self.fixed.downcase)
-      end
-    end
-    
-    class Workspace
-      include Atom::Xml::Parseable
-      element :title, :class => Content, :namespace => Atom::NAMESPACE
-      elements :collections
-      
-      def initialize(o = nil)
-        @collections = []
-        
-        case o
-        when XML::Reader
-          o.read
-          parse(o)
-        when Hash
-          o.each do |k, v|
-            self.send("#{k}=".to_sym, v)
-          end
-        end
-        
-        yield(self) if block_given?
-      end
-    end
-    
-    class Collection
-      include Atom::Xml::Parseable
-      attribute :href
-      element :title, :class => Content, :namespace => Atom::NAMESPACE
-      element :categories, :class => Categories
-      elements :accepts, :content_only => true
-      
-      def initialize(o = nil)
-        @accepts = []
-        case o
-        when XML::Reader
-          # do it once to get the attributes
-          parse(o, :once => true)
-          # now step into the element and the sub tree
-          o.read
-          parse(o)
-        when Hash
-          o.each do |k, v|
-            self.send("#{k}=", v)
-          end  
-        end
-        
-        yield(self) if block_given?
-      end
-      
-      def feed(opts = {})
-        if href
-          Atom::Feed.load_feed(URI.parse(href), opts)
-        end
-      end
-      
-      def publish(entry, opts = {})
-        uri = URI.parse(href)
-        response = nil
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          request = Net::HTTP::Post.new(uri.request_uri, headers)
-          if opts[:user] && opts[:pass]
-            request.basic_auth(opts[:user], opts[:pass])
-          elsif opts[:hmac_access_id] && opts[:hmac_secret_key]
-            if Atom::Configuration.auth_hmac_enabled?
-              AuthHMAC.sign!(request, opts[:hmac_access_id], opts[:hmac_secret_key])
-            else
-              raise ArgumentError, "AuthHMAC credentials provides by auth-hmac gem is not installed"
-            end
-          end
-          response = http.request(request, entry.to_xml.to_s)
-        end
-        
-        case response
-        when Net::HTTPCreated
-          published = begin
-            Atom::Entry.load_entry(response.body)
-          rescue ArgumentError
-            entry
-          end
-        
-          if response['Location']
-            if published.edit_link
-              published.edit_link.href = response['Location']
-            else
-              published.links << Atom::Link.new(:rel => 'edit', :href => response['Location'])
-            end
-          end
-        
-          published
-        else
-          raise Atom::Pub::ProtocolError, response
-        end
-      end
-      
-      private
-      def headers
-        {'Accept' => 'application/atom+xml',
-         'Content-Type' => 'application/atom+xml;type=entry',
-         'User-Agent' => "rAtom #{Atom::VERSION::STRING}"
-         }
-      end
-    end
-  end
-  
-  class Entry    
-    def save!(opts = {})
-      if edit = edit_link
-        uri = URI.parse(edit.href)
-        response = nil
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          request = Net::HTTP::Put.new(uri.request_uri, headers)
-          if opts[:user] && opts[:pass]
-            request.basic_auth(opts[:user], opts[:pass])
-          elsif opts[:hmac_access_id] && opts[:hmac_secret_key]
-            if Atom::Configuration.auth_hmac_enabled?
-              AuthHMAC.sign!(request, opts[:hmac_access_id], opts[:hmac_secret_key])
-            else
-              raise ArgumentError, "AuthHMAC credentials provides by auth-hmac gem is not installed"
-            end
-          end
-          
-          response = http.request(request, self.to_xml)
-        end
-        
-        case response
-        when Net::HTTPSuccess
-        else
-          raise Atom::Pub::ProtocolError, response
-        end
-      else
-        raise Atom::Pub::NotSupported, "Entry does not have an edit link"
-      end
-    end
-    
-    def destroy!(opts = {})
-      if edit = edit_link
-        uri = URI.parse(edit.href)
-        response = nil
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          request = Net::HTTP::Delete.new(uri.request_uri, {'Accept' => 'application/atom+xml', 'User-Agent' => "rAtom #{Atom::VERSION::STRING}"})
-          if opts[:user] && opts[:pass]
-            request.basic_auth(opts[:user], opts[:pass])
-          elsif opts[:hmac_access_id] && opts[:hmac_secret_key]
-            if Atom::Configuration.auth_hmac_enabled?
-              AuthHMAC.sign!(request, opts[:hmac_access_id], opts[:hmac_secret_key])
-            else
-              raise ArgumentError, "AuthHMAC credentials provides by auth-hmac gem is not installed"
-            end
-          end
-          
-          response = http.request(request)
-        end
-        
-        case response
-        when Net::HTTPSuccess
-        else
-          raise Atom::Pub::ProtocolError, response
-        end
-      else
-        raise Atom::Pub::NotSupported, "Entry does not have an edit link"
-      end
-    end
-    
-    private
-    def headers
-      {'Accept' => 'application/atom+xml',
-       'Content-Type' => 'application/atom+xml;type=entry',
-       'User-Agent' => "rAtom #{Atom::VERSION::STRING}"
-       }
-    end    
-  end
-end