octopi 0.1.0 → 0.2.1

data/lib/octopi/error.rb

@@ -2,14 +2,17 @@ module Octopi
 
   class FormatError < StandardError
    def initialize(f)
-     $stderr.puts "Got unexpected format (got #{f.first} for #{f.last})"
+     super("Got unexpected format (got #{f.first} for #{f.last})")
    end
-  end 
+  end
+  
+  class AuthenticationRequired < StandardError
+  end
 
   class APIError < StandardError
-   def initialize(m)
-     $stderr.puts m 
-   end
+  end
+  
+  class InvalidLogin < StandardError
   end
 
   class RetryableAPIError < RuntimeError
@@ -20,4 +23,13 @@ module Octopi
       super @message
     end  
   end
+  
+  class ArgumentMustBeHash < Exception; end
+  
+  
+  class NotFound < Exception
+    def initialize(klass)
+      super "The #{klass.to_s.split("::").last} you were looking for could not be found, or is private."
+    end
+  end
 end

data/lib/octopi/file_object.rb

@@ -1,15 +1,16 @@
 module Octopi
   class FileObject < Base
+    attr_accessor :name, :sha, :mode, :type
+    
     include Resource
     set_resource_name "tree"
-
     resource_path "/tree/show/:id"
 
-    def self.find(user, repo, sha)
-      user = user.login if user.is_a? User
-      repo = repo.name if repo.is_a? Repository
+    def self.find(options={})
+      ensure_hash(options)
+      user, repo, branch, sha = gather_details(options)
       self.validate_args(sha => :sha, user => :user, repo => :repo)
-      super [user,repo,sha] 
+      super [user, repo, sha] 
     end  
   end
 end

data/lib/octopi/gist.rb

@@ -0,0 +1,28 @@
+module Octopi
+  # Gist API is... lacking at the moment.
+  # This class serves only as a reminder to implement it later
+  class Gist < Base
+    include HTTParty
+    attr_accessor :description, :repo, :public, :created_at
+    
+    include Resource
+    set_resource_name "tree"
+    resource_path ":id"
+    
+    def self.base_uri
+      "http://gist.github.com/api/v1/yaml"
+    end
+    
+    def self.find(id)
+      result = get("#{base_uri}/#{id}")
+      # This returns an array of Gists, rather than a single record.
+      new(result["gists"].first)
+    end
+    
+    # def files
+    #   gists_folder = File.join(ENV['HOME'], ".octopi", "gists")
+    #   File.mkdir_p(gists_folder)
+    #   `git clone git://`
+    # end
+  end
+end

data/lib/octopi/issue.rb

@@ -6,7 +6,15 @@ module Octopi
     find_path "/issues/list/:query"
     resource_path "/issues/show/:id"
     
-    attr_accessor :repository
+    
+    attr_accessor :repository, :user, :updated_at, :votes, :number, :title, :body, :closed_at, :labels, :state, :created_at
+    
+    def self.search(options={})
+      ensure_hash(options)
+      options[:state] ||= "open"
+      user, repo = gather_details(options)
+      Api.api.get("/issues/search/#{user}/#{repo}/#{options[:state]}/#{options[:keyword]}")
+    end
     
     # Finds all issues for a given Repository
     #
@@ -22,72 +30,73 @@ module Octopi
     #   find_all("octopi", :user => "fcoury") # user must be provided
     #   find_all(:user => "fcoury", :repo => "octopi") # state defaults to open
     #
-    def self.find_all(*args)
-      repo = args.first
-      user, repo_name, opts = extract_user_repository(*args)
-      state = opts[:state] || "open"
-      state.downcase! if state
-      validate_args(user => :user, repo_name => :repo, state => :state)
+    def self.find_all(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
+      state = (options[:state] || "open").downcase
+      validate_args(user => :user, repo.name => :repo, state => :state)
 
-      issues = super user, repo_name, state
-      issues.each { |i| i.repository = repo } if repo.is_a? Repository
+      issues = super user, repo.name, state
+      issues.each { |i| i.repository = repo }
       issues
     end
   
     # TODO: Make find use hashes like find_all
-    def self.find(*args)
-      if args.length < 2
-        raise "Issue.find needs user, repository and issue number"
-      end
-      
-      number = args.pop.to_i if args.last.respond_to?(:to_i)
-      number = args.pop if args.last.is_a?(Integer)
+    def self.find(options={})
+      ensure_hash(options)
+      # Do not cache issues, as they may change via other means.
+      @cache = false
+      user, repo = gather_details(options)
       
-      raise "Issue.find needs issue number as the last argument" unless number
-      
-      if args.length > 1
-        user, repo = *args
-      else
-        repo = args.pop
-        raise "Issue.find needs at least a Repository object and issue number" unless repo.is_a? Repository
-        user, repo = repo.owner, repo.name
-      end
-      
-      user, repo = extract_names(user, repo)
       validate_args(user => :user, repo => :repo)
-      super user, repo, number
+      issue = super user, repo, options[:number]
+      issue.repository = repo
+      issue
     end
     
-    def self.open(user, repo, params, api = ANONYMOUS_API)
-      user, repo_name = extract_names(user, repo)
-      data = api.post("/issues/open/#{user}/#{repo_name}", params)
-      issue = new(api, data['issue'])
-      issue.repository = repo if repo.is_a? Repository
+    def self.open(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
+      data = Api.api.post("/issues/open/#{user}/#{repo.name}", options[:params])
+      issue = new(data['issue'])
+      issue.repository = repo
       issue
     end
     
-    def reopen(*args)
-      data = @api.post(command_path("reopen"))
+    # Re-opens an issue.
+    def reopen!
+      data = Api.api.post(command_path("reopen"))
+      self.state = 'open'
+      self
     end
     
-    def close(*args)
-      data = @api.post(command_path("close"))
+    def close!
+      data = Api.api.post(command_path("close"))
+      self.state = 'closed'
+      self
     end
     
     def save
-      data = @api.post(command_path("edit"), { :title => self.title, :body => self.body })
+      data = Api.api.post(command_path("edit"), { :title => title, :body => body })
+      self
     end
     
     %w(add remove).each do |oper|
       define_method("#{oper}_label") do |*labels|
         labels.each do |label|
-          @api.post("#{prefix("label/#{oper}")}/#{label}/#{number}")
+          Api.api.post("#{prefix("label/#{oper}")}/#{label}/#{number}", { :cache => false })
+          if oper == "add"
+            self.labels << label
+          else
+            self.labels -= [label]
+          end
         end
       end
     end
 
     def comment(comment)
-      @api.post(command_path("comment"), { :comment => comment })
+      data = Api.api.post(command_path("comment"), { :comment => comment })
+      IssueComment.new(data['comment'])
     end
     
     private

data/lib/octopi/issue_comment.rb

@@ -0,0 +1,7 @@
+module Octopi
+  class IssueComment < Base
+    include Resource
+    attr_accessor :comment, :status
+    
+  end
+end

data/lib/octopi/issue_set.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "issue")
+class Octopi::IssueSet < Array
+  include Octopi
+  attr_accessor :user, :repository
+  
+  def initialize(array)
+    self.user = array.first.user
+    self.repository = array.first.repository
+    super(array)
+  end
+  
+  def find(number)
+    issue = detect { |issue| issue.number == number }
+    raise NotFound, Issue if issue.nil?
+    issue
+  end
+  
+  def search(options={})
+    Issue.search(options.merge(:user => user, :repo => repository))
+  end
+end

data/lib/octopi/key.rb

@@ -2,17 +2,24 @@ module Octopi
   class Key < Base
     include Resource
     
+    attr_accessor :title, :id, :key
+    find_path "/user/keys"
+    
     attr_reader :user
-
-    def initialize(api, data, user = nil)
-      super api, data
-      @user = user
+    
+    def self.find_all
+      Api.api.get("user/keys")
+    end
+    
+    def self.add(options={})
+      ensure_hash(options)
+      Api.api.post("/user/key/add", { :title => options[:title], :key => options[:key], :cache => false })
+      
     end
     
-    def remove!
-      result = @api.post "/user/key/remove", :id => id
+    def remove
+      result = Api.api.post "/user/key/remove", { :id => id, :cache => false }
       keys = result["public_keys"].select { |k| k["title"] == title }
-      keys.empty?
     end
   end
 end

data/lib/octopi/key_set.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "key")
+class KeySet < Array
+  include Octopi
+  def find(title)
+    key = detect { |key| key.title == title }
+    raise NotFound, Key if key.nil?
+    key
+  end
+  
+  def add(options={})
+    ensure_hash(options)
+    Key.add(options)
+  end
+end

data/lib/octopi/plan.rb

@@ -0,0 +1,5 @@
+module Octopi
+  class Plan < Base
+    attr_accessor :name, :collaborators, :space, :private_repos
+  end
+end

data/lib/octopi/repository.rb

@@ -1,6 +1,11 @@
 module Octopi
   class Repository < Base
     include Resource
+    attr_accessor :description, :url, :forks, :name, :homepage, :watchers, 
+                  :owner, :private, :fork, :open_issues, :pledgie, :size,
+                  # And now for the stuff returned by search results
+                  :actions, :score, :language, :followers, :type, :username,
+                  :id, :pushed, :created
     set_resource_name "repository", "repositories"
 
     create_path "/repos/create"
@@ -10,6 +15,10 @@ module Octopi
     
     attr_accessor :private
     
+    def owner=(owner)
+      @owner = User.find(owner)
+    end
+    
     # Returns all branches for the Repository
     #
     # Example:
@@ -17,7 +26,7 @@ module Octopi
     #   repo.branches.each { |r| puts r.name }
     #
     def branches
-      Branch.find(self.owner, self.name,api)
+      Branch.all(:user => self.owner, :repo => self)
     end  
 
     # Returns all tags for the Repository
@@ -27,36 +36,50 @@ module Octopi
     #   repo.tags.each { |t| puts t.name }
     #
     def tags
-      Tag.find(self.owner, self.name)
-    end  
+      Tag.all(:user => self.owner, :repo => self)
+    end 
     
-    def clone_url
-      if private? || api.login == self.owner
-        "git@github.com:#{self.owner}/#{self.name}.git"  
-      else
-        "git://github.com/#{self.owner}/#{self.name}.git"  
+    
+    # Returns all the comments for a Repository
+    def comments
+      # We have to specify xmlns as a prefix as the document is namespaced.
+      # Be wary!
+      path = "http#{'s' if private}://github.com/#{owner}/#{name}/comments.atom"
+      xml = Nokogiri::XML(Net::HTTP.get(URI.parse(path)))
+      entries = xml.xpath("//xmlns:entry")
+      comments = []
+      for entry in entries
+        content = entry.xpath("xmlns:content").text.gsub("&lt;", "<").gsub("&gt;", ">")
+        comments << Comment.new(
+          :id => entry.xpath("xmlns:id"),
+          :published => Time.parse(entry.xpath("xmlns:published").text),
+          :updated => Time.parse(entry.xpath("xmlns:updated").text),
+          :link => entry.xpath("xmlns:link/@href").text,
+          :title => entry.xpath("xmlns:title").text,
+          :content => content,
+          :author => entry.xpath("xmlns:author/xmlns:name").text,
+          :repository => self
+        )
       end
+      comments
     end
-
-    def self.find_by_user(user, api = ANONYMOUS_API)
-      user = user.login if user.is_a? User
-      self.validate_args(user => :user)
-      find_plural(user, :resource, api)
+    
+    def clone_url
+      url = private || Api.api.login == self.owner.login ? "git@github.com:" : "git://github.com/"
+      url += "#{self.owner}/#{self.name}.git"
     end
-
-    def self.find(*args)
-      api = args.last.is_a?(Api) ? args.pop : ANONYMOUS_API
-      repo = args.pop
-      user = args.pop
-      
-      user = user.login if user.is_a? User
-      if repo.is_a? Repository
-        repo = repo.name 
-        user ||= repo.owner 
-      end
+    
+    def self.find(options={})
+      ensure_hash(options)
+      # Lots of people call the same thing differently.
+      # Can't call gather_details here because this method is used by it internally.
+      repo = options[:repo] || options[:repository] || options[:name]
+      user = options[:user].to_s
+    
+      return find_plural(user, :resource) if repo.nil?
       
       self.validate_args(user => :user, repo => :repo)
-      super user, repo, api
+      super user, repo
     end
 
     def self.find_all(*args)
@@ -65,21 +88,16 @@ module Octopi
       super args.join(" ").gsub(/ /,'+')
     end
     
-    def self.open_issue(args)
-      Issue.open(args[:user], args[:repo], args)
-    end
-    
-    def open_issue(args)
-      Issue.open(self.owner, self, args, @api)
+    class << self 
+      alias_method :search, :find_all
     end
     
     def commits(branch = "master")
-      api = self.api || ANONYMOUS_API
-      Commit.find_all(self, {:branch => branch}, api)
+      Commit.find_all(:user => self.owner, :repo => self, :branch => branch)
     end
     
     def issues(state = "open")
-      Issue.find_all(self, :state => state)
+      IssueSet.new(Octopi::Issue.find_all(:user => owner, :repository => self))
     end
    
     def all_issues
@@ -87,24 +105,27 @@ module Octopi
     end
 
     def issue(number)
-      Issue.find(self, number)
+      Issue.find(:user => self.owner, :repo => self, :number => number)
     end
 
     def collaborators
-      property('collaborators', [self.owner,self.name].join('/')).values
+      property('collaborators', [self.owner, self.name].join('/')).values.map { |v| User.find(v) }
     end  
     
-    def self.create(owner, name, opts = {})
-      api = owner.is_a?(User) ? owner.api : ANONYMOUS_API
-      raise APIError, "To create a repository you must be authenticated." if api.read_only?
-      self.validate_args(name => :repo)
-      api.post(path_for(:create), opts.merge(:name => name))
-      self.find(owner, name, api)
+    def self.create(options={})
+      raise AuthenticationRequired, "To create a repository you must be authenticated." if Api.api.read_only?
+      self.validate_args(options[:name] => :repo)
+      new(Api.api.post(path_for(:create), options)["repository"])
+    end
+    
+    def delete!
+      raise APIError, "You must be authenticated as the owner of this repository to delete it" if Api.me.login != owner.login
+      token = Api.api.post(self.class.path_for(:delete), :id => self.name)['delete_token']
+      Api.api.post(self.class.path_for(:delete), :id => self.name, :delete_token => token) unless token.nil?
     end
     
-    def delete
-      token = @api.post(self.class.path_for(:delete), :id => self.name)['delete_token']
-      @api.post(self.class.path_for(:delete), :id => self.name, :delete_token => token) unless token.nil?
+    def to_s
+      name
     end
 
   end