crohr-restfully 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Cyril Rohr
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,22 @@
+= restfully
+
+An attempt at dynamically providing "clever" wrappers on top of RESTful APIs that follow the HATEOAS principle. For it to work, the API must follow certain conventions (to be explained later).
+
+Alpha work, will probably only work against my API of reference :-)
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull).
+* Send me a pull request. Bonus points for topic branches.
+
+== Testing
+
+* rake spec, or
+* run autotest in the project directory.
+
+== Copyright
+
+Copyright (c) 2009 Cyril Rohr. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "restfully"
+    gem.summary = %Q{Experimental code for auto-generation of wrappers on top of RESTful APIs that follow some specific conventions.}
+    gem.description = %Q{Experimental code for auto-generation of wrappers on top of RESTful APIs that follow HATEOAS principles and provide OPTIONS methods and/or Allow headers.}
+    gem.email = "cyril.rohr@gmail.com"
+    gem.homepage = "http://github.com/cryx/restfully"
+    gem.authors = ["Cyril Rohr"]
+    gem.add_dependency "rest-client"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/examples/grid5000.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'pp'
+
+require File.dirname(__FILE__)+'/../lib/restfully'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::INFO
+
+# Restfully.adapter = Restfully::HTTP::RestClientAdapter
+# Restfully.adapter = Patron::Session
+RestClient.log = 'stdout'
+Restfully::Session.new('https://localhost:3443/sid', 'root' => '/versions/current', 'logger' => logger) do |grid, session|
+  grid_stats = {'hardware' => {}, 'system' => {}}
+  grid.sites.each do |site_uid, site|
+    site_stats = site.status.inject({'hardware' => {}, 'system' => {}}) {|accu, (node_uid, node_status)|
+      accu['hardware'][node_status['hardware_state']] = (accu['hardware'][node_status['hardware_state']] || 0) + 1
+      accu['system'][node_status['system_state']] = (accu['system'][node_status['system_state']] || 0) + 1
+      accu
+    }
+    grid_stats['hardware'].merge!(site_stats['hardware']) { |key,oldval,newval| oldval+newval }
+    grid_stats['system'].merge!(site_stats['system']) { |key,oldval,newval| oldval+newval }
+    p [site_uid, site_stats]
+  end
+  p [:total, grid_stats]
+  puts "Getting status of a few nodes in rennes:"
+  pp grid.sites['rennes'].status(:query => {:only => ['paradent-1', 'paradent-10', 'paramount-3']})
+  
+  # TODO: Auto discovery of allowed HTTP methods: create raises an error if not available, otherwise POSTs the given object (and auto-select the content-type)
+  # grid.sites["rennes"].jobs.create({:walltime => 120, :whatever => ''})
+end

data/lib/restfully/collection.rb

@@ -0,0 +1,51 @@
+require 'delegate'
+
+module Restfully
+  class Collection < DelegateClass(Hash)
+    
+    attr_reader :state, :raw, :uri, :session, :title
+    
+    def initialize(uri, session, options = {})
+      @uri = uri
+      @title = options['title']
+      @session = session
+      @raw = options['raw']
+      @state = :unloaded
+      @items = {}
+      super(@items)
+    end
+    
+    def loaded?;    @state == :loaded;    end
+    
+    def load(options = {})
+      options = options.symbolize_keys
+      force_reload = options.delete(:reload) || false
+      path = uri
+      if options.has_key?(:query)
+        path, query_string = uri.split("?")
+        query_string ||= ""
+        query_string.concat(options.delete(:query).to_params)
+        path = "#{path}?#{query_string}"
+        force_reload = true
+      end      
+      if loaded? && force_reload == false
+        self
+      else
+        @raw = session.get(path, options) if raw.nil? || force_reload
+        raw.each do |key, value|
+          next if key == 'links'
+          self_link = (value['links'] || []).map{|link| Link.new(link)}.detect{|link| link.self?}
+          if self_link && self_link.valid?
+            @items.store(key, Resource.new(self_link.href, session, 'raw' => value).load)
+          else
+            session.logger.warn "Resource #{key} does not have a 'self' link. skipped."
+          end
+        end       
+        @state = :loaded
+        self
+      end
+    end
+    
+    
+  end
+end

data/lib/restfully/link.rb

@@ -0,0 +1,35 @@
+module Restfully
+  class Link
+    
+    VALID_RELATIONSHIPS = %w{member parent collection self}
+    RELATIONSHIPS_REQUIRING_TITLE = %w{collection member}
+    
+    attr_reader :rel, :title, :href, :errors
+    
+    def initialize(attributes = {})
+      @rel = attributes['rel']
+      @title = attributes['title']
+      @href = attributes['href']
+      @resolvable = attributes['resolvable'] || false
+      @resolved = attributes['resolved'] || false
+    end
+    
+    def resolvable?; @resolvable == true; end
+    def resolved?; @resolved == true; end
+    def self?; @rel == 'self'; end
+    
+    def valid?
+      @errors = []
+      if href.nil? || href.empty?
+        errors << "href cannot be empty."
+      end
+      unless VALID_RELATIONSHIPS.include?(rel)
+        errors << "#{rel} is not a valid link relationship."
+      end
+      if (!title || title.empty?) && RELATIONSHIPS_REQUIRING_TITLE.include?(rel)
+        errors << "#{rel} #{href} has no title."
+      end
+      errors.empty?
+    end
+  end
+end

data/lib/restfully/parsing.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module Restfully
+  
+  class ParserNotFound < RestfullyError; end
+  
+  module Parsing
+    def parse(object, options = {})
+      content_type = options[:content_type]
+      content_type ||= object.headers[:content_type] if object.respond_to?(:headers)
+      case content_type
+      when /^application\/json/i
+        JSON.parse(object)
+      else
+        raise ParserNotFound, [object, content_type]
+      end
+    end
+  
+    def dump(object, options = {})
+      content_type = options[:content_type]
+      content_type ||= object.headers[:content_type] if object.respond_to?(:headers)
+      case content_type
+      when /^application\/json/i
+        JSON.dump(object)
+      else
+        raise ParserNotFound, [object, content_type]
+      end
+    end
+
+  end
+end

data/lib/restfully/resource.rb

@@ -0,0 +1,97 @@
+require 'delegate'
+
+module Restfully
+  
+  # Suppose that the load method has been called on the resource before trying to access its attributes or associations
+  
+  class Resource < DelegateClass(Hash)
+    undef :type
+    attr_reader :uri, :session, :state, :raw, :uid, :associations
+
+    def initialize(uri, session, options = {})
+      @uri = uri
+      @session = session
+      @parent = options['parent']
+      @raw = options['raw']
+      @state = :unloaded
+      @attributes = {}
+      super(@attributes)
+      @associations = {}
+    end
+    
+    def loaded?;    @state == :loaded;    end
+    
+    def method_missing(method, *args)
+      if association = @associations[method.to_s]
+        session.logger.debug "loading association #{method} with #{args.inspect}"
+        association.load(*args)
+      else
+        super(method, *args)
+      end
+    end
+  
+    def load(options = {})
+      options = options.symbolize_keys
+      force_reload = options.delete(:reload) || false
+      path = uri
+      if options.has_key?(:query)
+        path, query_string = uri.split("?")
+        query_string ||= ""
+        query_string.concat(options.delete(:query).to_params)
+        path = "#{path}?#{query_string}"
+        force_reload = true
+      end
+      if loaded? && force_reload == false
+        self
+      else
+        @raw = session.get(path, options) if raw.nil? || force_reload
+        @associations.clear
+        @attributes.clear
+        (raw['links'] || []).each{|link| define_link(Link.new(link))}
+        raw.each do |key, value|
+          case key
+          when 'links'  then  next
+          when 'uid'   then  @uid = value
+          else
+            case value
+            when Hash
+              @attributes.store(key, SpecialHash.new.replace(value)) unless @associations.has_key?(key)
+            when Array
+              @attributes.store(key, SpecialArray.new(value))
+            else
+              @attributes.store(key, value)
+            end
+          end
+        end
+        @state = :loaded
+        self
+      end
+    end
+    
+    def respond_to?(method, *args)
+      @associations.has_key?(method.to_s) || super(method, *args)
+    end
+    
+    protected
+    def define_link(link)
+      if link.valid?
+        case link.rel
+        when 'collection'
+          raw_included = link.resolved? ? raw[link.title] : nil
+          @associations[link.title] = Collection.new(link.href, session, 
+            'raw' => raw_included,
+            'title' => link.title)
+        when 'member'
+          raw_included = link.resolved? ? raw[link.title] : nil
+          @associations[link.title] = Resource.new(link.href, session, 
+            'raw' => raw_included)
+        when 'self'
+          # uri is supposed to be equal to link['href'] for self relations. so we do nothing
+        end
+      else 
+        session.logger.warn link.errors.join("\n")
+      end
+    end
+    
+  end # class Resource
+end # module Restfully

data/lib/restfully/session.rb

@@ -0,0 +1,59 @@
+require 'uri'
+require 'logger'
+require 'restclient'
+
+module Restfully
+  class Error < StandardError; end
+  class HTTPError < Error; end
+  class NullLogger
+    def method_missing(method, *args)
+      nil
+    end
+  end
+  class Session
+    include Parsing
+    attr_reader :base_url, :logger, :connection, :root
+    
+    # TODO: use CacheableResource
+    def initialize(base_url, options = {})
+      @base_url = base_url
+      @root = options['root'] || '/'
+      @logger = options['logger'] || NullLogger.new 
+      @user = options['user']
+      @password = options['password']
+      # TODO: generalize
+      # @connection = Patron::Session.new
+      # @connection.timeout = 10
+      # @connection.base_url = base_url
+      # @connection.headers['User-Agent'] = 'restfully'
+      # @connection.insecure = true
+      # @connection.username = @user
+      # @connection.password = @password      
+      @connection = RestClient::Resource.new(base_url || '', :user => @user, :password => @password)
+      yield Resource.new(root, self).load, self if block_given?
+    end
+    
+    # TODO: uniformize headers hash (should accept symbols and strings in any capitalization format)
+    # TODO: inspect response headers to determine which methods are available
+    def get(path, headers = {})
+      headers = headers.symbolize_keys
+      headers[:accept] ||= 'application/json'
+      logger.info "GET #{path} #{headers.inspect}"
+      # TODO: should be able to choose HTTP lib to use, so we must provide abstract interface for HTTP handlers
+      api = path.empty? ? connection : connection[path]
+      response = api.get(headers)
+      parse response#, :content_type => response.headers['Content-Type']
+      # response = connection.get(path, headers)
+      # logger.info response.headers
+      # logger.info response.status
+      # if (200..300).include?(response.status)
+        # parse response.body, :content_type => response.headers['Content-Type']
+      # else
+        # TODO: better error management ;-)
+        # raise HTTPError.new("Error: #{response.status}")
+      # end
+    end
+  
+    # TODO: add other HTTP methods
+  end
+end

data/lib/restfully/special_array.rb

@@ -0,0 +1,5 @@
+module Restfully
+  # To be used to provide facilities such as hash-like lookups
+  class SpecialArray < Array
+  end
+end

data/lib/restfully/special_hash.rb

@@ -0,0 +1,5 @@
+module Restfully
+  # To be used later
+  class SpecialHash < Hash
+  end
+end

data/lib/restfully.rb

@@ -0,0 +1,41 @@
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
+end unless defined?(BasicObject)
+
+# monkey patching:
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def to_params
+    params = ''
+
+    each do |k, v|
+      if v.is_a?(Array)
+        params << "#{k}=#{v.join(",")}&"
+      else
+        params << "#{k}=#{v.to_s}&"
+      end
+    end
+
+    params.chop! 
+    params
+  end
+
+end
+
+module Restfully
+  class RestfullyError < StandardError; end
+end
+
+require File.dirname(__FILE__)+'/restfully/parsing'
+require File.dirname(__FILE__)+'/restfully/session'
+require File.dirname(__FILE__)+'/restfully/special_hash'
+require File.dirname(__FILE__)+'/restfully/special_array'
+require File.dirname(__FILE__)+'/restfully/link'
+require File.dirname(__FILE__)+'/restfully/resource'
+require File.dirname(__FILE__)+'/restfully/collection'

data/spec/collection_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+describe Collection do
+
+  it "should have all methods of a hash" do
+    collection = Collection.new("uri", session=mock('session'))
+    collection.size.should == 0
+    collection.store("rennes", resource = mock(Resource))
+    collection.size.should == 1
+    collection.should == {'rennes' => resource}
+    collection.should respond_to(:each)
+    collection.should respond_to(:store)
+    collection.should respond_to(:[])
+    collection.should respond_to(:length)
+  end
+  
+  it "should not load if already loaded and no force_reload" do
+    collection = Collection.new("uri", mock("session"))
+    collection.should_receive(:loaded?).and_return(true)
+    collection.load(:reload => false).should == collection
+  end
+  it "should load when force_reload is true [already loaded]" do
+    collection = Collection.new("uri", session=mock("session", :logger => Logger.new(STDOUT)))
+    collection.should_receive(:loaded?).and_return(true)
+    session.should_receive(:get).and_return({})
+    collection.load(:reload => true).should == collection    
+  end
+  it "should load when force_reload is true [not loaded]" do
+    collection = Collection.new("uri", session=mock("session", :logger => Logger.new(STDOUT)))
+    collection.should_receive(:loaded?).and_return(false)
+    session.should_receive(:get).and_return({})
+    collection.load(:reload => true).should == collection    
+  end
+  it "should force reload when query parameters are given"
+  
+end

data/spec/link_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+describe Link do
+
+  it "should have a rel reader" do
+    link = Link.new
+    link.should_not respond_to(:rel=)
+    link.should respond_to(:rel)
+  end
+  it "should have a href reader" do
+    link = Link.new
+    link.should_not respond_to(:href=)
+    link.should respond_to(:href)
+  end
+  it "should have a title reader" do
+    link = Link.new
+    link.should_not respond_to(:title=)
+    link.should respond_to(:title)
+  end
+  it "should have a errors reader" do
+    link = Link.new
+    link.should_not respond_to(:errors=)
+    link.should respond_to(:errors)
+  end
+  it "should respond to valid?" do
+    link = Link.new
+    link.should respond_to(:valid?)    
+  end
+  it "should respond to resolved?" do
+    link = Link.new
+    link.should respond_to(:resolved?)
+  end
+  it "should respond to resolvable?" do
+    link = Link.new
+    link.should respond_to(:resolvable?)
+  end
+  it "by default, should not be resolvable" do
+    link = Link.new
+    link.should_not be_resolvable
+  end
+  it "by default, should not be resolved" do    
+    link = Link.new
+    link.should_not be_resolved
+  end
+  it "should not be valid if there is no href" do
+    link = Link.new 'rel' => 'collection', 'title' => 'my collection'
+    link.should_not be_valid
+  end
+  it "should not be valid if there is no rel" do
+    link = Link.new 'href' => '/', 'title' => 'my collection'
+    link.should_not be_valid
+  end
+  it "should not be valid if the rel is valid but requires a title that is not given" do
+    link = Link.new 'rel' => 'collection', 'href' => '/'
+    link.should_not be_valid
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+
+describe Resource do
+  before do
+    @logger = Logger.new(STDOUT)
+  end
+  
+  it "should have all methods of a hash" do
+    resource = Resource.new("uri", session=mock('session'))
+    resource.size.should == 0
+    resource['whatever'] = 'thing'
+    resource.size.should == 1
+    resource.should == {'whatever' => 'thing'}
+    resource.should respond_to(:each)
+    resource.should respond_to(:length)
+  end
+  
+  describe "accessors" do
+    it "should have a reader on the session" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:session=)
+      resource.session.should == session
+    end
+    it "should have a reader on the uri" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:uri=)
+      resource.uri.should == "uri"
+    end
+    it "should have a reader on the raw property" do
+      resource = Resource.new("uri", session=mock("session"), 'raw' => {})
+      resource.should_not respond_to(:raw=)
+      resource.raw.should == {}
+    end
+    it "should have a reader on the state property" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:state=)
+      resource.state.should == :unloaded
+    end
+  end
+  
+  
+  describe "loading" do
+  
+    before do
+      @raw = {
+        'links' => [
+          {'rel' => 'self', 'href' => '/sites/rennes/versions/123'},
+          {'rel' => 'member', 'href' => '/versions/123', 'title' => 'grid'},
+          {'rel' => 'invalid_rel', 'href' => '/whatever'},
+          {'rel' => 'member', 'href' => '/sites/rennes/statuses/current', 'title' => 'status'},
+          {'rel' => 'collection', 'href' => '/sites/rennes/versions', 'resolvable' => false, 'title' => 'versions'},
+          {'rel' => 'collection', 'href' => '/sites/rennes/clusters/versions/123', 'resolvable' => true, 'resolved' => true, 'title' => 'clusters'},
+          {'rel' => 'collection', 'href' => '/sites/rennes/environments/versions/123', 'resolvable' => true, 'resolved' => false, 'title' => 'environments'},
+          {'rel' => 'collection', 'href' => '/has/no/title'} 
+        ],
+        'uid' => 'rennes',
+        'whatever' => 'whatever',
+        'an_array' => [1, 2, 3],
+        'clusters' => {
+          '/sites/rennes/clusters/paradent' => {
+            'guid' => '/sites/rennes/clusters/paradent',
+            'links' => [
+              {'rel' => 'self', 'href' => '/sites/rennes/clusters/paradent/versions/123'},
+              {'rel' => 'parent', 'href' => '/sites/rennes/versions/123'},
+              {'rel' => 'collection', 'href' => '/sites/rennes/clusters/paradent/nodes/versions/123', 'title' => 'nodes', 'resolvable' => true, 'resolved' => false},
+              {'rel' => 'collection', 'href' => '/sites/rennes/clusters/paradent/versions', 'resolvable' => false, 'title' => 'versions'},
+              {'rel' => 'member', 'href' => '/sites/rennes/clusters/paradent/statuses/current', 'title' => 'status'}
+            ],
+            'model' => 'XYZ'
+          },
+          '/sites/rennes/clusters/paramount' => {
+            'guid' => '/sites/rennes/clusters/paramount',
+            'links' => [
+              {'rel' => 'self', 'href' => '/sites/rennes/clusters/paramount/versions/123'},
+              {'rel' => 'parent', 'href' => '/sites/rennes/versions/123'},
+              {'rel' => 'collection', 'href' => '/sites/rennes/clusters/paramount/nodes/versions/123', 'title' => 'nodes', 'resolvable' => true, 'resolved' => false},
+              {'rel' => 'collection', 'href' => '/sites/rennes/clusters/paramount/versions', 'resolvable' => false, 'title' => 'versions'},
+              {'rel' => 'member', 'href' => '/sites/rennes/clusters/paramount/statuses/current', 'title' => 'status'}
+            ],
+            'model' => 'XYZ1b'
+          }
+        }
+      }
+    end
+    it "should not be loaded in its initial state" do
+      resource = Resource.new("uri", mock('session'))
+      resource.should_not be_loaded
+    end
+    it "should get the raw representation of the resource via the session if it doesn't have it" do
+      resource = Resource.new("uri", session = mock("session", :logger => Logger.new(STDOUT)))
+      resource.stub!(:define_link) # do not define links
+      resource.raw.should be_nil
+      session.should_receive(:get).with('uri', {}).and_return(@raw)
+      resource.load
+    end
+    it "should correctly define the functions to access simple values" do
+      resource = Resource.new("uri", session = mock("session", :get => @raw, :logger => @logger))
+      resource.stub!(:define_link) # do not define links
+      resource.load
+      resource['whatever'].should == 'whatever'
+      resource.uri.should == 'uri'
+      resource.uid.should == 'rennes'
+      resource['an_array'].should be_a(SpecialArray)
+      resource['an_array'].should == [1,2,3]
+      lambda{resource.clusters}.should raise_error(NoMethodError)
+    end
+    
+    it "should correctly define the functions to access links" do
+      resource = Resource.new("uri", session = mock("session", :get => @raw, :logger => @logger))
+      @logger.should_receive(:warn).with(/collection \/has\/no\/title has no title/)
+      @logger.should_receive(:warn).with(/invalid_rel is not a valid link relationship/)
+      Collection.should_receive(:new).
+        with('/sites/rennes/versions', session, 'raw' => nil, 'title' => 'versions').
+        and_return(versions=mock(Collection))
+      Collection.should_receive(:new).
+        with('/sites/rennes/clusters/versions/123', session, 'raw' => @raw['clusters'], 'title' => 'clusters').
+        and_return(clusters=mock(Collection))
+      Collection.should_receive(:new).
+        with('/sites/rennes/environments/versions/123', session, 'raw' => nil, 'title' => 'environments').
+        and_return(environments=mock(Collection))
+      Resource.should_receive(:new).
+        with('/versions/123', session, 'raw' => nil).
+        and_return(parent=mock(Resource))
+      Resource.should_receive(:new).
+        with('/sites/rennes/statuses/current', session, 'raw' => nil).
+        and_return(status=mock(Resource))
+      # associations should not exist before loading
+      resource.respond_to?(:clusters).should be_false
+      # load the resource so that associations get created
+      resource.load
+      # check that functions exist
+      resource.should respond_to(:clusters)
+      clusters.should_receive(:load).and_return(clusters)
+      resource.clusters.should == clusters
+      resource.should respond_to(:environments)
+      environments.should_receive(:load).and_return(environments)
+      resource.environments.should == environments
+      resource.should respond_to(:versions)
+      versions.should_receive(:load).and_return(versions)
+      resource.versions.should == versions
+      resource.should respond_to(:status)
+      status.should_receive(:load).and_return(status)
+      resource.status.should == status
+      resource.uri.should == 'uri' # self link should not override it
+    end
+  end
+end

data/spec/restfully_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Restfully do
+
+end

data/spec/session_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+describe Session do
+
+  it "should have a logger reader" do
+    session = Session.new('https://api.grid5000.fr')
+    session.should_not respond_to(:logger=)
+    session.should respond_to(:logger)
+  end
+  it "should have a base_url reader" do
+    session = Session.new('https://api.grid5000.fr')
+    session.should_not respond_to(:base_url=)
+    session.base_url.should == 'https://api.grid5000.fr'
+  end
+  
+  it "should log to NullLogger by default" do
+    NullLogger.should_receive(:new)
+    session = Session.new('https://api.grid5000.fr')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'restfully'
+require 'spec'
+require 'spec/autorun'
+
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: crohr-restfully
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Cyril Rohr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-31 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Experimental code for auto-generation of wrappers on top of RESTful APIs that follow HATEOAS principles and provide OPTIONS methods and/or Allow headers.
+email: cyril.rohr@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/grid5000.rb
+- lib/restfully.rb
+- lib/restfully/collection.rb
+- lib/restfully/link.rb
+- lib/restfully/parsing.rb
+- lib/restfully/resource.rb
+- lib/restfully/session.rb
+- lib/restfully/special_array.rb
+- lib/restfully/special_hash.rb
+- spec/collection_spec.rb
+- spec/link_spec.rb
+- spec/resource_spec.rb
+- spec/restfully_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/cryx/restfully
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Experimental code for auto-generation of wrappers on top of RESTful APIs that follow some specific conventions.
+test_files: 
+- spec/collection_spec.rb
+- spec/link_spec.rb
+- spec/resource_spec.rb
+- spec/restfully_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+- examples/grid5000.rb