grendel-ruby 0.1.1

data/lib/grendel/document.rb

@@ -0,0 +1,27 @@
+module Grendel
+  class Document
+    attr_accessor :user, :name, :uri, :data, :content_type
+    
+    def initialize(user, params)
+      params.symbolize_keys!
+      @user = user
+      @client = user.client
+      @name = params[:name]
+      @data = params[:data]
+      @content_type = params[:content_type]
+      @uri = params[:uri] ? 
+        URI.parse(params[:uri]).path :
+        "/documents/" + @name # escape this?
+    end
+    
+    # delete this document from Grendel
+    def delete
+      @user.delete(@uri)
+    end
+        
+    # send link operations to the Link class
+    def links
+      LinkManager.new(self)
+    end    
+  end
+end

data/lib/grendel/document_manager.rb

@@ -0,0 +1,47 @@
+module Grendel
+  class DocumentManager    
+
+    def initialize(user)
+      @user = user
+      @base_uri = "/documents"
+    end
+    
+    # list all documents
+    def list
+      response = @user.get(@base_uri)
+      response["documents"].map {|d| Document.new(@user, d) }
+    end
+    
+    # retreive a document
+    def find(name)
+      response = @user.get(@base_uri + "/" + name)
+      params = {
+        :name => name,
+        :data => response.body,
+        :content_type => response.headers['content-type'].first
+      }
+      Document.new(@user, params)
+    end
+    
+    # store a document, creating a new one if it doesn't exist, or replacing the existing one if it does
+    def store(name, data, content_type = nil)
+      # if the content type isn't provided, guess it or set it to a default
+      unless content_type
+        if mime_type = MIME::Types.type_for(name).first
+          content_type = mime_type.content_type
+        else
+          content_type = 'application/octet-stream'
+        end
+      end
+      
+      response = @user.put(@base_uri + "/" + name, data, :raw_data => true, :headers => {'Content-Type' => content_type})
+      Document.new(@user, :name => name, :data => data, :content_type => content_type)
+    end
+    
+    # delete the specified document from Grendel
+    def delete(name)
+      @user.delete(@base_uri + "/" + name)
+    end
+
+  end
+end

data/lib/grendel/link.rb

@@ -0,0 +1,15 @@
+module Grendel
+  class Link
+    attr_accessor :document, :user, :uri
+    
+    def initialize(document, user, params = {})
+      params.symbolize_keys!
+      @document = document
+      @user = user
+      @uri = params[:uri] ? 
+        URI.parse(params[:uri]).path :
+        "/links/" + @user.id # escape this?
+    end
+        
+  end
+end

data/lib/grendel/link_manager.rb

@@ -0,0 +1,30 @@
+module Grendel
+  class LinkManager
+
+    def initialize(document)
+       @document = document
+       @base_uri = @document.uri + "/links"
+    end
+
+    # return links to this document
+    def list
+      response = @document.user.get(@base_uri)
+      response["links"].map do |link| 
+        Link.new(@document, User.new(@document.user.client, link["user"]), :uri => link["uri"])
+      end
+    end
+    
+    # add a link to a user and return a Link object
+    def add(user_id)
+      # REVIEW: 2010-02-23 <brad@wesabe.com> -- what does Grendel return if the link already exists?
+      @document.user.put(@base_uri + "/" + user_id)
+      Link.new(@document, User.new(@document.user.client, :id => user_id))
+    end
+
+    # remove a link to a user
+    def remove(user_id)
+      # REVIEW: 2010-02-23 <brad@wesabe.com> -- what does Grendel return if the link didn't exist?
+      @document.user.delete(@base_uri + "/" + user_id)
+    end
+  end
+end

data/lib/grendel/linked_document.rb

@@ -0,0 +1,30 @@
+module Grendel
+  class LinkedDocument < Document
+    attr_accessor :linked_user, :owner
+    
+    # create a new linked document
+    # user - linked user
+    # params:
+    # :name => document name
+    # :uri => linked document uri
+    # :owner => {
+    #   :id => owner id
+    #   :uri => owner uri
+    # }
+    def initialize(linked_user, params)
+      params.symbolize_keys!
+      @owner = User.new(linked_user.client, params[:owner])
+      super(@owner, params)
+      @linked_user = linked_user
+      @name = params[:name]
+      @uri = params[:uri] ? 
+        URI.parse(params[:uri]).path :
+        ["/linked-documents", @owner.id, name].join("/")
+    end
+    
+    # delete this linked document
+    def delete
+      @linked_user.delete(@uri)
+    end
+  end
+end

data/lib/grendel/linked_document_manager.rb

@@ -0,0 +1,31 @@
+module Grendel
+  class LinkedDocumentManager
+    def initialize(user)
+      @user = user
+      @base_uri = "/linked-documents"
+    end
+    
+    # list this user's linked documents. Returns an array of LinkedDocument objects
+    def list
+      response = @user.get(@base_uri)
+      response["linked-documents"].map {|ld| LinkedDocument.new(@user, ld) }
+    end
+    
+    # retreive a linked document
+    def find(owner_id, name)
+      response = @user.get([@base_uri, owner_id, name].join("/"))
+      params = {
+        :name => name,
+        :data => response.body,
+        :content_type => response.headers['content-type'].first,
+        :owner => { :id => owner_id }
+      }
+      LinkedDocument.new(@user, params)
+    end
+    
+    # delete the linked document
+    def delete(owner_id, name)
+      @user.delete([@base_uri, owner_id, name].join("/"))
+    end
+  end
+end

data/lib/grendel/user.rb

@@ -0,0 +1,68 @@
+module Grendel
+  class User
+    attr_accessor :id, :password, :uri
+    attr_reader :client, :modified_at, :created_at, :keys
+    
+    # create a new Grendel::User object
+    # params:
+    #  id
+    #  uri
+    #  password
+    def initialize(client, params)
+      params.symbolize_keys!
+      @client = client
+      @id = params[:id]
+      @uri = params[:uri] ? 
+        URI.parse(params[:uri]).path :
+        "/users/" + @id # escape this?
+      @password = params[:password]
+      @modified_at = DateTime.parse(params[:"modified-at"]) if params[:"modified-at"]
+      @created_at = DateTime.parse(params[:"created-at"]) if params[:"created-at"]
+      @keys = params[:keys]
+    end
+
+    # return user's creds in the form required by HTTParty
+    def auth
+      {:basic_auth => {:username => id, :password => password}}
+    end
+
+    #
+    # methods to do authenticated client calls with the user's base_uri
+    #
+    def get(uri = "", options = {})
+      options.merge!(auth)
+      @client.get(@uri + uri, options)
+    end
+    
+    def post(uri = "", data = {}, options = {})
+      options.merge!(auth)
+      @client.post(@uri + uri, data, options)
+    end
+    
+    def put(uri = "", data = {}, options = {})
+      options.merge!(auth)
+      @client.put(@uri + uri, data, options)
+    end
+
+    def delete(uri = "", options = {})
+      options.merge!(auth)
+      @client.delete(@uri + uri, options)
+    end
+    
+    # change the user's password
+    def change_password(new_password)
+      put("", {:password => new_password})
+      @password = new_password
+    end
+    
+    # send documents calls to the DocumentManager
+    def documents
+      DocumentManager.new(self)
+    end
+    
+    # send linked documents calls to the LinkedDocumentManager
+    def linked_documents
+      LinkedDocumentManager.new(self)
+    end
+  end
+end

data/lib/grendel/user_manager.rb

@@ -0,0 +1,31 @@
+module Grendel
+  class UserManager
+    
+    def initialize(client)
+      @client = client
+    end
+
+    # return all Grendel users as Grendel::User objects    
+    def list
+      response = @client.get("/users")
+      response["users"].map {|u| User.new(@client, u) }
+    end
+    
+    # retrieve a user, optionally setting the password
+    def find(id, password = nil)
+      response = @client.get("/users/#{id}") # need to escape this
+      user = User.new(@client, response)
+      user.password = password
+      return user
+    end
+    
+    # create a new user
+    def create(id, password)
+      params = {:id => id, :password => password}
+      response = @client.post("/users", params)
+      # TODO: strip protocol and host from uri
+      User.new(@client, params.merge(:uri => response.headers['location'].first))
+    end
+    
+  end
+end

data/spec/grendel/client_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Grendel::Client" do
+  before do
+    @client = Grendel::Client.new("http://example.com")
+  end
+  
+  describe "new method" do
+    it "should set the base_uri" do
+      @client.base_uri.should == "http://example.com"
+    end
+  end
+  
+  describe "users method" do
+    it "should return a Grendel::UserManager" do
+      @client.users.class.should be(Grendel::UserManager)
+    end
+  end
+end

data/spec/grendel/document_manager_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Grendel::DocumentManager" do
+  before do
+    @client = Grendel::Client.new("http://grendel")
+    @user_id = "alice"
+    @password = "s3kret"
+    @user = Grendel::User.new(@client, :id => @user_id, :password => @password)
+    @base_uri = "#{@user_id}:#{@password}@grendel/users/#{@user_id}/documents"
+  end
+  
+  describe "list" do
+    before do
+      stub_json_request(:get, @base_uri, %{{
+          "documents":[
+            {"name":"document1.txt",
+             "uri":"http://grendel/users/#{@user_id}/documents/document1.txt"},
+            {"name":"document2.txt",
+             "uri":"http://grendel/users/#{@user_id}/documents/document2.txt"}
+          ]}})
+    end
+    
+    it "should return an array of all documents" do
+      docs = @user.documents.list
+      docs.length.should == 2
+      docs[0].name.should == "document1.txt"
+      docs[0].uri.should == "/users/#{@user_id}/documents/document1.txt"
+      docs[1].name.should == "document2.txt"
+      docs[1].uri.should == "/users/#{@user_id}/documents/document2.txt"
+    end
+  end
+
+  describe "find" do
+    before do
+      stub_json_request(:get, @base_uri + "/document1.txt", "yay for me", :content_type => "text/plain")
+      stub_json_request(:get, @base_uri + "/notfound.txt", "", :status => "404 Not Found")
+    end
+    
+    it "should return the document" do
+      doc = @user.documents.find("document1.txt")
+      doc.name.should == "document1.txt"
+      doc.content_type.should == "text/plain"
+      doc.data.should == "yay for me"
+    end
+    
+    it "should raise an exception if the document is not found" do
+      lambda {
+        @user.documents.find("notfound.txt")
+      }.should raise_error(Grendel::Client::HTTPException) {|error| error.message.should match("404")} # change to should == "404 Not Found" once WebMock supports status messages
+    end
+  end
+
+  describe "store" do
+    describe "a successful request" do
+      before do
+        stub_json_request(:put, @base_uri + "/new_document.txt", "", :status => "204 No Content")
+      end
+    
+      it "should send a properly-formatted request" do
+        @user.documents.store("new_document.txt", "top secret stuff", "text/plain")
+        params = { "id" => @user_id, "password" => @password }
+        request(:put, @base_uri + "/new_document.txt").
+          with(:body => "top secret stuff", :headers => {"Content-Type" => "text/plain"}).
+          should have_been_made.once
+      end
+    
+      it "should guess the content type if not provided" do
+        @user.documents.store("new_document.txt", "top secret stuff")
+        params = { "id" => @user_id, "password" => @password }
+        request(:put, @base_uri + "/new_document.txt").
+          with(:body => "top secret stuff", :headers => {"Content-Type" => "text/plain"}).
+          should have_been_made.once
+      end
+
+      it "should default the content type to 'application/octet-stream' if unknown" do
+        stub_json_request(:put, @base_uri + "/new_document.-wtf-", "", :status => "204 No Content")
+        @user.documents.store("new_document.-wtf-", "top secret stuff")
+        params = { "id" => @user_id, "password" => @password }
+        request(:put, @base_uri + "/new_document.-wtf-").
+          with(:body => "top secret stuff", :headers => {"Content-Type" => "application/octet-stream"}).
+          should have_been_made.once
+      end
+      
+      it "should return a document" do
+        doc = @user.documents.store("new_document.txt", "top secret stuff")
+        doc.name.should == "new_document.txt"
+        doc.data.should == "top secret stuff"
+        doc.content_type.should == "text/plain"
+      end
+    end
+  end
+  
+  describe "delete" do
+    before do
+      stub_json_request(:delete, @base_uri + "/document.txt", "", :status => "204 No Content")
+      @document = Grendel::Document.new(@user, :name => "document.txt")
+    end
+
+    it "should send a properly-formatted request" do
+      @user.documents.delete("document.txt")
+      request(:delete, @base_uri + "/document.txt").should have_been_made.once
+    end
+  end
+end

data/spec/grendel/document_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Grendel::Document" do
+  before do
+    @client = Grendel::Client.new("http://grendel")
+    @user_id = "alice"
+    @password = "s3kret"
+    @user = Grendel::User.new(@client, :id => @user_id, :password => @password)
+    @base_uri = "#{@user_id}:#{@password}@grendel/users/#{@user_id}/documents"
+  end
+
+  describe "delete" do
+    before do
+      stub_json_request(:delete, @base_uri + "/document.txt", "", :status => "204 No Content")
+      @document = Grendel::Document.new(@user, :name => "document.txt")
+    end
+
+    it "should send a properly-formatted request" do
+      @document.delete
+      request(:delete, @base_uri + "/document.txt").should have_been_made.once
+    end
+  end
+end

data/spec/grendel/link_manager_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+# - get a list of documents a user has linked to them
+# docs = user.linked_documents.list
+# - retrieve a linked document
+# doc = user.linked_documents.find("owner_user_id", "document.txt")
+# - delete a linked document
+# user.linked_documents.delete("owner_user_id", "document.txt")
+
+describe "Grendel::LinkManager" do
+  before do
+    @client = Grendel::Client.new("http://grendel")
+    @user_id = "alice"
+    @password = "s3kret"
+    @user = Grendel::User.new(@client, :id => @user_id, :password => @password)
+    @document = Grendel::Document.new(@user, :name => "document1.txt")
+    @uri = "#{@user_id}:#{@password}@grendel/users/#{@user_id}/documents/#{@document.name}/links"
+  end
+
+  describe "list" do
+    before do
+      stub_json_request(:get, @uri, %{{
+        "links":[
+          {
+            "user":{
+              "id":"bob",
+              "uri":"http://grendel/users/bob"
+            },
+            "uri":"http://grendel/users/alice/documents/document1.txt/links/bob"
+          },
+          {
+            "user":{
+              "id":"carol",
+              "uri":"http://grendel/users/carol"
+            },
+            "uri":"http://grendel/users/alice/documents/document1.txt/links/carol"
+          }]
+      }})
+    end
+    
+    it "should list users with links to this document" do
+      links = @document.links.list
+      links.length.should == 2
+      links[0].user.id.should == "bob"
+      links[0].uri.should == "/users/alice/documents/document1.txt/links/bob"
+      links[1].user.id.should == "carol"
+      links[1].uri.should == "/users/alice/documents/document1.txt/links/carol"
+    end
+  end
+
+  describe "add" do
+    before do
+      @other_user_id = "bob"
+      stub_json_request(:put, @uri + "/" + @other_user_id, "")
+    end
+    
+    it "should send a properly-formatted request" do
+      @document.links.add(@other_user_id)
+      request(:put, @uri + "/" + @other_user_id).should have_been_made.once
+    end
+    
+    it "should return a Link object" do
+      link = @document.links.add(@other_user_id)
+      link.document.should == @document
+      link.user.id.should == @other_user_id
+    end
+  end
+  
+  describe "remove" do
+    before do
+      @other_user_id = "bob"
+      stub_json_request(:delete, @uri + "/" + @other_user_id, "")
+    end
+
+    it "should send a properly-formatted request" do
+      @document.links.remove(@other_user_id)
+      request(:delete, @uri + "/" + @other_user_id).should have_been_made.once
+    end    
+  end
+end