ddollar-octopi 0.0.13

data/lib/octopi/error.rb

@@ -0,0 +1,23 @@
+module Octopi
+
+  class FormatError < StandardError
+   def initialize(f)
+     $stderr.puts "Got unexpected format (got #{f.first} for #{f.last})"
+   end
+  end 
+
+  class APIError < StandardError
+   def initialize(m)
+     $stderr.puts m 
+   end
+  end
+
+  class RetryableAPIError < RuntimeError
+    attr_reader :code
+    def initialize(code=nil)
+      @code = code.nil? ? '???' : code
+      @message = "GitHub returned status #{@code}. Retrying request."
+      super @message
+    end  
+  end
+end

data/lib/octopi/file_object.rb

@@ -0,0 +1,15 @@
+module Octopi
+  class FileObject < Base
+    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
+      self.validate_args(sha => :sha, user => :user, repo => :repo)
+      super [user,repo,sha] 
+    end  
+  end
+end

data/lib/octopi/issue.rb

@@ -0,0 +1,102 @@
+module Octopi
+  class Issue < Base
+    include Resource
+    STATES = %w{open closed}
+
+    find_path "/issues/list/:query"
+    resource_path "/issues/show/:id"
+    
+    attr_accessor :repository
+    
+    # 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(*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)
+
+      issues = super user, repo_name, state
+      issues.each { |i| i.repository = repo } if repo.is_a? Repository
+      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)
+      
+      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
+    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
+      issue
+    end
+    
+    def reopen(*args)
+      data = @api.post(command_path("reopen"))
+    end
+    
+    def close(*args)
+      data = @api.post(command_path("close"))
+    end
+    
+    def save
+      data = @api.post(command_path("edit"), { :title => self.title, :body => self.body })
+    end
+    
+    %w(add remove).each do |oper|
+      define_method("#{oper}_label") do |*labels|
+        labels.each do |label|
+          @api.post("#{prefix("label/#{oper}")}/#{label}/#{number}")
+        end
+      end
+    end
+
+    def comment(comment)
+      @api.post(command_path("comment"), { :comment => 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/key.rb

@@ -0,0 +1,18 @@
+module Octopi
+  class Key < Base
+    include Resource
+    
+    attr_reader :user
+
+    def initialize(api, data, user = nil)
+      super api, data
+      @user = user
+    end
+    
+    def remove!
+      result = @api.post "/user/key/remove", :id => id
+      keys = result["public_keys"].select { |k| k["title"] == title }
+      keys.empty?
+    end
+  end
+end

data/lib/octopi/repository.rb

@@ -0,0 +1,111 @@
+module Octopi
+  class Repository < Base
+    include Resource
+    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
+    
+    # Returns all branches for the Repository
+    #
+    # Example:
+    #   repo = Repository.find("fcoury", "octopi")
+    #   repo.branches.each { |r| puts r.name }
+    #
+    def branches
+      Branch.find(self.owner, self.name,api)
+    end  
+
+    # Returns all tags for the Repository
+    #
+    # Example:
+    #   repo = Repository.find("fcoury", "octopi")
+    #   repo.tags.each { |t| puts t.name }
+    #
+    def tags
+      Tag.find(self.owner, self.name)
+    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"  
+      end
+    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)
+    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
+      
+      self.validate_args(user => :user, repo => :repo)
+      super user, repo, api
+    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
+    
+    def self.open_issue(args)
+      Issue.open(args[:user], args[:repo], args)
+    end
+    
+    def open_issue(args)
+      Issue.open(self.owner, self, args, @api)
+    end
+    
+    def commits(branch = "master")
+      api = self.api || ANONYMOUS_API
+      Commit.find_all(self, {:branch => branch}, api)
+    end
+    
+    def issues(state = "open")
+      Issue.find_all(self, :state => state)
+    end
+   
+    def all_issues
+      Issue::STATES.map{|state| self.issues(state)}.flatten
+    end
+
+    def issue(number)
+      Issue.find(self, number)
+    end
+
+    def collaborators
+      property('collaborators', [self.owner,self.name].join('/')).values
+    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)
+    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?
+    end
+
+  end
+end

data/lib/octopi/resource.rb

@@ -0,0 +1,75 @@
+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)
+        api = args.last.is_a?(Api) ? args.pop : ANONYMOUS_API
+        args = args.join('/') if args.is_a? Array
+        result = api.find(path_for(:resource), @resource_name[:singular], args)
+        key = result.keys.first
+
+        if result[key].is_a? Array
+          result[key].map { |r| new(api, r) }
+        else  
+          Resource.for(key).new(api, result[key])
+        end  
+      end
+      
+      def find_all(*s)
+        api = s.last.is_a?(Api) ? s.pop : ANONYMOUS_API
+        find_plural(s, :find, api)
+      end
+
+      def find_plural(s, path, api = ANONYMOUS_API)
+        s = s.join('/') if s.is_a? Array
+        api.find_all(path_for(path), @resource_name[:plural], s).
+          map do |item|
+            payload = block_given? ? yield(item) : item
+            new(api, payload)
+          end
+      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/tag.rb

@@ -0,0 +1,17 @@
+module Octopi
+  class Tag < Base
+    include Resource
+    set_resource_name "tag"
+
+    resource_path "/repos/show/:id"
+    
+    def self.find(user, repo)
+      user = user.login if user.is_a? User
+      repo = repo.name if repo.is_a? Repository
+      self.validate_args(user => :user, repo => :repo)
+      find_plural([user,repo,'tags'], :resource){
+        |i| {:name => i.first, :hash => i.last }
+      }
+    end
+  end
+end

data/lib/octopi/user.rb

@@ -0,0 +1,99 @@
+module Octopi
+  class User < Base
+    include Resource
+    
+    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
+
+    # 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
+      api = self.api || ANONYMOUS_API
+      Repository.find_by_user(login,api)
+    end
+    
+    # Searches for user Repository identified by
+    # name
+    def repository(name)
+      self.class.validate_args(name => :repo)
+      Repository.find(login, name)
+    end
+    
+    def create_repository(name, opts = {})
+      self.class.validate_args(name => :repo)
+      Repository.create(self, name, opts)
+    end
+    
+    # Adds an SSH Public Key to the user. Requires
+    # authentication.
+    def add_key(title, key)
+      raise APIError, 
+        "To add a key, you must be authenticated" if @api.read_only?
+
+      result = @api.post("/user/key/add", :title => title, :key => key)
+      return if !result["public_keys"]
+      key_params = result["public_keys"].select { |k| k["title"] == title }
+      return if !key_params or key_params.empty?
+      Key.new(@api, key_params.first, self)
+    end
+
+    # Returns a list of Key objects containing all SSH Public Keys this user
+    # currently has. Requires authentication.
+    def keys
+      raise APIError, 
+        "To add a key, you must be authenticated" if @api.read_only?
+
+      result = @api.get("/user/keys")
+      return unless result and result["public_keys"]
+      result["public_keys"].inject([]) { |result, element| result << Key.new(@api, element) }
+    end
+    
+    # takes one param, deep that indicates if returns 
+    # only the user login or an user object
+    %w[followers following].each do |method|
+      define_method(method) do
+        user_property(method, false)
+      end
+      define_method("#{method}!") do
+        user_property(method, true)
+      end
+    end
+    
+    def user_property(property, deep)
+      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