dcuddeback-octopi 0.2.8

data/lib/octopi/issue.rb

@@ -0,0 +1,111 @@
+module Octopi
+  class Issue < Base
+    include Resource
+    STATES = %w{open closed}
+
+    find_path "/issues/list/:query"
+    resource_path "/issues/show/:id"
+    
+    
+    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
+    #
+    # You can provide the user and repo parameters as
+    # String or as User and Repository objects. When repo
+    # is provided as a Repository object, user is superfluous.
+    # 
+    # If no state is given, "open" is assumed.
+    #
+    # Sample usage:
+    #
+    #   find_all(repo, :state => "closed") # repo must be an object
+    #   find_all("octopi", :user => "fcoury") # user must be provided
+    #   find_all(:user => "fcoury", :repo => "octopi") # state defaults to open
+    #
+    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 }
+      issues
+    end
+  
+    # TODO: Make find use hashes like find_all
+    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)
+      
+      validate_args(user => :user, repo => :repo)
+      issue = super user, repo, options[:number]
+      issue.repository = repo
+      issue
+    end
+    
+    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
+    
+    # Re-opens an issue.
+    def reopen!
+      data = Api.api.post(command_path("reopen"))
+      self.state = 'open'
+      self
+    end
+    
+    def close!
+      data = Api.api.post(command_path("close"))
+      self.state = 'closed'
+      self
+    end
+    
+    def save
+      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.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)
+      data = Api.api.post(command_path("comment"), { :comment => comment })
+      IssueComment.new(data['comment'])
+    end
+    
+    private
+    def prefix(command)
+      "/issues/#{command}/#{repository.owner}/#{repository.name}"
+    end
+    
+    def command_path(command)
+      "#{prefix(command)}/#{number}"
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Octopi
+  class Key < Base
+    include Resource
+    
+    attr_accessor :title, :id, :key
+    find_path "/user/keys"
+    
+    attr_reader :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.api.post "/user/key/remove", { :id => id, :cache => false }
+      keys = result["public_keys"].select { |k| k["title"] == title }
+    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

@@ -0,0 +1,136 @@
+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"
+    find_path "/repos/search/:query"
+    resource_path "/repos/show/:id"
+    delete_path "/repos/delete/:id"
+    
+    attr_accessor :private
+    
+    def owner=(owner)
+      @owner = User.find(owner)
+    end
+    
+    # Returns all branches for the Repository
+    #
+    # Example:
+    #   repo = Repository.find("fcoury", "octopi")
+    #   repo.branches.each { |r| puts r.name }
+    #
+    def branches
+      Branch.all(:user => self.owner, :repo => self)
+    end  
+
+    # Returns all tags for the Repository
+    #
+    # Example:
+    #   repo = Repository.find("fcoury", "octopi")
+    #   repo.tags.each { |t| puts t.name }
+    #
+    def tags
+      Tag.all(:user => self.owner, :repo => self)
+    end 
+    
+    
+    # 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 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(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
+    end
+
+    def self.find_all(*args)
+      # FIXME: This should be URI escaped, but have to check how the API
+      # handles escaped characters first.
+      super args.join(" ").gsub(/ /,'+')
+    end
+    
+    class << self 
+      alias_method :search, :find_all
+    end
+    
+    def commits(branch = "master")
+      Commit.find_all(:user => self.owner, :repo => self, :branch => branch)
+    end
+    
+    def issues(state = "open")
+      IssueSet.new(Octopi::Issue.find_all(:user => owner, :repository => self))
+    end
+   
+    def all_issues
+      Issue::STATES.map{|state| self.issues(state)}.flatten
+    end
+
+    def issue(number)
+      Issue.find(:user => self.owner, :repo => self, :number => number)
+    end
+
+    def collaborators
+      property('collaborators', [self.owner, self.name].join('/')).values.map { |v| User.find(v.join) }
+    end  
+    
+    def deploy_keys
+      DeployKey.all(:user => self.owner, :repo => self)
+    end
+
+    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.merge( :cache => false ))["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 to_s
+      name
+    end
+
+  end
+end

data/lib/octopi/repository_set.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "repository")
+class Octopi::RepositorySet < Array
+  include Octopi
+  attr_accessor :user
+  
+  def find(name)
+    Octopi::Repository.find(:user => self.user, :repository => name)
+  end
+end

data/lib/octopi/resource.rb

@@ -0,0 +1,70 @@
+module Octopi
+  module Resource
+    def self.included(base)
+      base.extend ClassMethods
+      base.set_resource_name(base.name)
+      (@@resources||={})[base.resource_name(:singular)] = base
+      (@@resources||={})[base.resource_name(:plural)] = base
+    end
+    
+    def self.for(name)
+      @@resources[name]
+    end
+    
+    module ClassMethods
+      def set_resource_name(singular, plural = "#{singular}s")
+        @resource_name = {:singular => declassify(singular), :plural => declassify(plural)}
+      end
+      
+      def resource_name(key)
+        @resource_name[key]
+      end
+      
+      def create_path(path)
+        (@path_spec||={})[:create] = path
+      end
+      
+      def find_path(path)
+        (@path_spec||={})[:find] = path
+      end
+    
+      def resource_path(path)
+        (@path_spec||={})[:resource] = path
+      end
+  
+      def delete_path(path)
+        (@path_spec||={})[:delete] = path
+      end
+      
+      def find(*args)
+        args = args.join('/') if args.is_a? Array
+        result = Api.api.find(path_for(:resource), @resource_name[:singular], args, self, @cache)
+        key = result.keys.first
+
+        if result[key].is_a? Array
+          result[key].map { |r| new(r) }
+        else
+          Resource.for(key).new(result[key])
+        end
+      end
+
+      def find_all(*s)
+        find_plural(s, :find)
+      end
+      
+      def find_plural(s, path)
+        s = s.join('/') if s.is_a? Array
+        resources = Api.api.find_all(path_for(path), @resource_name[:plural], s, self)
+        resources.map { |item| self.new(item) }
+      end
+      
+      def declassify(s)
+        (s.split('::').last || '').downcase if s
+      end
+    
+      def path_for(type)
+        @path_spec[type]
+      end
+    end
+  end
+end

data/lib/octopi/self.rb

@@ -0,0 +1,33 @@
+module Octopi
+  module Self
+    # Returns a list of Key objects containing all SSH Public Keys this user
+    # currently has. Requires authentication.
+    def keys
+      raise AuthenticationRequired, "To view keys, you must be authenticated" if Api.api.read_only?
+      result = Api.api.get("/user/keys", { :cache => false })
+      return unless result and result["public_keys"]
+      KeySet.new(result["public_keys"].inject([]) { |result, element| result << Key.new(element) })
+    end
+  
+    # Returns a list of Email objects containing the email addresses associated with this user.
+    # Requires authentication.
+    def emails
+      raise AuthenticationRequired, "To view emails, you must be authenticated" if Api.api.read_only?
+      get("/user/emails")['emails']
+    end
+
+    # Start following a user.
+    # Can only be called if you are authenticated.
+    def follow!(login)
+      raise AuthenticationRequired, "To begin following someone, you must be authenticated" if Api.api.read_only?
+      Api.api.post("/user/follow/#{login}")
+    end
+    
+    # Stop following a user.
+    # Can only be called if you are authenticated.
+    def unfollow!(login)
+      raise AuthenticationRequired, "To stop following someone, you must be authenticated" if Api.api.read_only?
+      Api.api.post("/user/unfollow/#{login}")
+    end
+  end
+end

data/lib/octopi/tag.rb

@@ -0,0 +1,23 @@
+module Octopi
+  class Tag < Base
+    include Resource
+    
+    attr_accessor :name, :sha
+    set_resource_name "tag"
+
+    resource_path "/repos/show/:id"
+    
+    def initialize(*args)
+      args = args.flatten!
+      self.name = args.first
+      self.sha = args.last
+    end
+    
+    def self.all(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
+      self.validate_args(user => :user, repo => :repo)
+      find_plural([user, repo, 'tags'], :resource) { |i| Tag.new(i) }
+    end
+  end
+end

data/lib/octopi/user.rb

@@ -0,0 +1,131 @@
+module Octopi
+  class User < Base
+    include Resource
+    attr_accessor :company, :name, :following_count, :gravatar_id,
+                  :blog, :public_repo_count, :public_gist_count, 
+                  :id, :login, :followers_count, :created_at, 
+                  :email, :location, :disk_usage, :private_repo_count, 
+                  :private_gist_count, :collaborators, :plan, 
+                  :owned_private_repo_count, :total_private_repo_count, 
+                  
+                  # These come from search results, which doesn't 
+                  # contain the above information.
+                  :actions, :score, :language, :followers, :following,
+                  :fullname, :type, :username, :repos, :pushed, :created
+    
+    def plan=(attributes={})
+      @plan = Plan.new(attributes)
+    end
+    
+    find_path "/user/search/:query"
+    resource_path "/user/show/:id"
+    
+    # Finds a single user identified by the given username
+    #
+    # Example:
+    #   
+    #   user = User.find("fcoury")
+    #   puts user.login # should return 'fcoury'
+    def self.find(username)
+      self.validate_args(username => :user)
+      super username
+    end
+
+    # Finds all users whose username matches a given string
+    # 
+    # Example:
+    #
+    #   User.find_all("oe") # Matches joe, moe and monroe
+    #
+    def self.find_all(username)
+      self.validate_args(username => :user)
+      super username
+    end
+    
+    class << self
+      alias_method :search, :find_all
+    end
+
+    # Returns a collection of Repository objects, containing
+    # all repositories of the user.
+    #
+    # If user is the current authenticated user, some
+    # additional information will be provided for the
+    # Repositories.
+    def repositories
+      rs = RepositorySet.new(Repository.find(:user => self.login))
+      rs.user = self
+      rs
+    end
+    
+    # Searches for user Repository identified by name
+    def repository(options={})
+      options = { :name => options } if options.is_a?(String)
+      self.class.ensure_hash(options)
+      Repository.find({ :user => login }.merge!(options))
+    end
+    
+    def create_repository(name, options = {})
+      self.class.validate_args(name => :repo)
+      Repository.create(self, name, options)
+    end
+    
+    def watching
+      repositories = []
+      Api.api.get("/repos/watched/#{login}")["repositories"].each do |repo|
+        repositories << Repository.new(repo)
+      end
+      repositories
+    end
+    
+
+    # Gets a list of followers.
+    # Returns an array of logins.
+    def followers
+      user_property("followers")
+    end
+
+    # Gets a list of followers.
+    # Returns an array of user objects.
+    # If user has a large number of followers you may be rate limited by the API.
+    def followers!
+      user_property("followers", true)
+    end
+
+    # Gets a list of people this user is following.
+    # Returns an array of logins.
+    def following
+      user_property("following")
+    end
+
+    # Gets a list of people this user is following.
+    # Returns an array of user objectrs.
+    # If user has a large number of people whom they follow, you may be rate limited by the API.
+    def following!
+      user_property("following", true)
+    end
+
+    
+    # If a user object is passed into a method, we can use this.
+    # It'll also work if we pass in just the login.
+    def to_s
+      login
+    end
+    
+    private
+    
+    # Helper method for "deep" finds.
+    # Determines whether to return an array of logins (light) or user objects (heavy).
+    def user_property(property, deep=false)
+      users = []
+      property(property, login).each_pair do |k,v|
+        return v unless deep
+        
+        v.each { |u| users << User.find(u) } 
+      end
+      
+      users
+    end
+    
+  end
+end