octopi 0.0.9

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Felipe Coury
+
+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,166 @@
+= octopi
+
+Octopi is a Ruby interface to GitHub API v2 (http://develop.github.com).
+
+To install it as a Gem, just run:
+
+  $ sudo gem install fcoury-octopi --source http://gems.github.com
+
+== Authenticated Usage
+
+=== Seamless authentication using .gitconfig defaults
+
+If you have your <tt>~/.gitconfig</tt> file in place, and you have a [github] section (if you don't, take a look at this GitHub Guides entry: http://github.com/guides/tell-git-your-user-name-and-email-address), you can use seamless authentication using this method:
+
+  authenticated do |g|
+    repo = g.repository("api-labrat")
+    (...)
+  end
+  
+=== Explicit authentication
+
+Sometimes, you may not want to get authentication data from <tt>~/.gitconfig</tt>. You want to use GitHub API authenticated as a third party. For this use case, you have a couple of options too.
+
+<b>1. Providing login and token inline:</b>
+
+  authenticated_with "mylogin", "mytoken" do |g|
+    repo = g.repository("api-labrat")
+    issue = repo.open_issue :title => "Sample issue", 
+      :body => "This issue was opened using GitHub API and Octopi"
+    puts issue.number
+  end
+  
+<b>2. Providing a YAML file with authentication information:</b>
+
+Use the following format:
+
+  #
+  # Octopi GitHub API configuration file
+  #
+
+  # GitHub user login and token
+  login: github-username
+  token: github-token
+
+  # Trace level
+  # Possible values:
+  #   false - no tracing, same as if the param is ommited
+  #   true  - will output each POST or GET operation to the stdout
+  #   curl  - same as true, but in addition will output the curl equivalent of each command (for debugging)
+  trace: curl
+  
+And change the way you connect to:
+
+  authenticated_with :config => "github.yml" do |g|
+    (...)
+  end
+  
+== Anonymous Usage
+
+This reflects the usage of the API to retrieve information on a read-only fashion, where the user doesn't have to be authenticated.
+
+=== Users API
+
+Getting user information
+
+  user = User.find("fcoury")
+  puts "#{user.name} is being followed by #{user.followers.join(", ")} and following #{user.following.join(", ")}"
+
+The bang methods `followers!` and `following!` retrieves a full User object for each user login returned, so it has to be used carefully.
+
+  user.followers!.each do |u|
+    puts "  - #{u.name} (#{u.login}) has #{u.public_repo_count} repo(s)"
+  end
+  
+Searching for user
+
+  users = User.find_all("silva")
+  puts "#{users.size} users found for 'silva':"
+  users.each do |u|
+    puts "  - #{u.name}"
+  end
+
+=== Repositories API
+
+  repo = user.repository("octopi") # same as: Repository.find("fcoury", "octopi")
+  puts "Repository: #{repo.name} - #{repo.description} (by #{repo.owner}) - #{repo.url}"
+  puts "      Tags: #{repo.tags and repo.tags.map {|t| t.name}.join(", ")}"
+  
+Search:
+
+  repos = Repository.find_all("ruby", "git")
+  puts "#{repos.size} repository(ies) with 'ruby' and 'git':"
+  repos.each do |r|
+    puts "  - #{r.name}"
+  end
+  
+Issues API integrated into the Repository object:
+
+  issue = repo.issues.first
+  puts "First open issue: #{issue.number} - #{issue.title} - Created at: #{issue.created_at}"
+
+Single issue information:
+
+  issue = repo.issue(11)
+
+Commits API information from a Repository object:
+
+  first_commit = repo.commits.first
+  puts "First commit: #{first_commit.id} - #{first_commit.message} - by #{first_commit.author['name']}"
+  
+Single commit information:
+
+  puts "Diff:"
+  first_commit.details.modified.each {|m| puts "#{m['filename']} DIFF: #{m['diff']}" }
+
+== Tracing
+
+=== Levels
+
+You can can use tracing to enable better debugging output when something goes wrong. There are 3 tracing levels: 
+
+* false (default) - no tracing
+* true - will output each GET and POST calls, along with URL and params
+* curl - same as true, but additionally outputs the curl command to replicate the issue
+
+If you choose curl tracing, the curl command equivalent to each command sent to GitHub will be output to the stdout, like this example:
+
+  => Trace on: curl
+  POST: /issues/open/webbynode/api-labrat params: body=This issue was opened using GitHub API and Octopi, title=Sample issue
+  ===== curl version
+  curl -F 'body=This issue was opened using GitHub API and Octopi' -F 'login=mylogin' -F 'token=mytoken' -F 'title=Sample issue' http://github.com/api/v2/issues/open/webbynode/api-labrat
+  ==================
+  
+=== Enabling
+
+Tracing can be enabled in different ways, depending on the API feature you're using:
+
+<b>Anonymous (this will be improved later):</b>
+
+  ANONYMOUS_API.trace_level = "trace-level"
+  
+<b>Seamless authenticated</b>
+
+  authenticated :trace => "trace-level" do |g|; ...; end
+  
+<b>Explicitly authenticated</b>
+
+Current version of explicit authentication requires a :config param to a YAML file to allow tracing. For enabling tracing on a YAML file refer to the config.yml example presented on the Explicit authentication section.
+
+== Author
+
+* Felipe Coury - http://felipecoury.com
+* HasMany.info blog - http://hasmany.info
+
+== Contributors
+
+In alphabetical order:
+
+* Brandon Calloway - http://github.com/bcalloway
+* runpaint - http://github.com/runpaint
+
+Thanks guys!
+
+== Copyright
+
+Copyright (c) 2009 Felipe Coury. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 9

data/lib/octopi.rb

@@ -0,0 +1,210 @@
+require 'rubygems'
+require 'httparty'
+require 'yaml'
+require 'pp'
+
+module Octopi
+  class Api; end
+  ANONYMOUS_API = Api.new
+  
+  def authenticated(*args, &block)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    config = read_gitconfig
+    login = config["github"]["user"]
+    token = config["github"]["token"]
+    
+    api = Api.new(login, token)
+    api.trace_level = opts[:trace]
+    
+    puts "=> Trace on: #{api.trace_level}" if api.trace_level
+
+    yield api
+  end
+  
+  def authenticated_with(*args, &block)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    if opts[:config]
+      config = File.open(opts[:config]) { |yf| YAML::load(yf) }
+      raise "Missing config #{opts[:config]}" unless config
+      
+      login = config["login"]
+      token = config["token"]
+      trace = config["trace"]
+    else
+      login, token = *args
+    end
+    
+    puts "=> Trace on: #{trace}" if trace
+    
+    api = Api.new(login, token)
+    api.trace_level = trace if trace
+    yield api
+  end
+  
+  def read_gitconfig
+    config = {}
+    group = nil
+    File.foreach("#{ENV['HOME']}/.gitconfig") do |line|
+      line.strip!
+      if line[0] != ?# and line =~ /\S/
+        if line =~ /^\[(.*)\]$/
+          group = $1
+        else
+          key, value = line.split("=")
+          (config[group]||={})[key.strip] = value.strip
+        end
+      end
+    end
+    config
+  end
+  
+  class Api
+    include HTTParty
+    CONTENT_TYPE = {
+      'yaml' => 'application/x-yaml',
+      'json' => 'application/json',
+      'xml'  => 'application/sml'
+    }  
+    RETRYABLE_STATUS = [403]
+    MAX_RETRIES = 10
+    
+    base_uri "http://github.com/api/v2"
+  
+    attr_accessor :format, :login, :token, :trace_level, :read_only
+  
+    def initialize(login = nil, token = nil, format = "yaml")
+      @format = format
+      @read_only = true
+      
+      if login
+        @login = login
+        @token = token
+        @read_only = false
+        self.class.default_params :login => login, :token => token
+      end
+    end
+
+    def read_only?
+      read_only
+    end
+
+    {:keys => 'public_keys', :emails => 'emails'}.each_pair do |action, key|
+      define_method("#{action}") do
+        get("/user/#{action}")[key]
+      end
+    end
+
+    def user
+      user_data = get("/user/show/#{login}")
+      raise "Unexpected response for user command" unless user_data and user_data['user']
+      User.new(self, user_data['user'])
+    end
+    
+    def open_issue(user, repo, params)
+      Issue.open(user, repo, params, self)
+    end
+    
+    def repository(name)
+      repo = Repository.find(user, name, self)
+      repo.api = self
+      repo
+    end
+    alias_method :repo, :repository
+    
+    def save(resource_path, data)
+      traslate resource_path, data
+      #still can't figure out on what format values are expected
+      post("#{resource_path}", { :query => data })
+    end
+    
+    def find(path, result_key, resource_id)
+      get(path, { :id => resource_id }) 
+    end
+
+    def find_all(path, result_key, query)
+      get(path, { :query => query, :id => query })[result_key]
+    end
+    
+    def get_raw(path, params)
+     get(path, params, 'plain')
+    end
+    
+    def get(path, params = {}, format = "yaml")
+      @@retries = 0
+      begin
+        trace "GET [#{format}]", "/#{format}#{path}", params
+        submit(path, params, format) do |path, params, format|
+          self.class.get "/#{format}#{path}"
+        end
+      rescue RetryableAPIError => e
+        if @@retries < MAX_RETRIES 
+          $stderr.puts e.message
+          @@retries += 1
+          retry
+        else  
+          raise APIError, "GitHub returned status #{e.code}, despite" +
+           " repeating the request #{MAX_RETRIES} times. Giving up."
+        end  
+      end  
+    end
+    
+    def post(path, params = {}, format = "yaml")
+      trace "POST", "/#{format}#{path}", params
+      submit(path, params, format) do |path, params, format|
+        resp = self.class.post "/#{format}#{path}", :query => params
+        resp
+      end
+    end
+
+    private
+    def submit(path, params = {}, format = "yaml", &block)
+      params.each_pair do |k,v|
+        if path =~ /:#{k.to_s}/
+          params.delete(k)
+          path = path.gsub(":#{k.to_s}", v)
+        end
+      end
+      query = login ? { :login => login, :token => token } : {}
+      query.merge!(params)
+      
+      begin
+        resp = yield(path, query.merge(params), format)
+      rescue Net::HTTPBadResponse
+        raise RetryableAPIError
+      end
+      
+      if @trace_level
+        case @trace_level
+          when "curl"
+            query_trace = []
+            query.each_pair { |k,v| query_trace << "-F '#{k}=#{v}'" }
+            puts "===== [curl version]"
+            puts "curl #{query_trace.join(" ")} #{self.class.base_uri}/#{format}#{path}"
+            puts "===================="
+        end
+      end
+      raise RetryableAPIError, resp.code.to_i if RETRYABLE_STATUS.include? resp.code.to_i
+      raise APIError, 
+        "GitHub returned status #{resp.code}" unless resp.code.to_i == 200
+      # FIXME: This fails for showing raw Git data because that call returns
+      # text/html as the content type. This issue has been reported.
+      ctype = resp.headers['content-type'].first
+      raise FormatError, [ctype, format] unless 
+        ctype.match(/^#{CONTENT_TYPE[format]};/)
+      if format == 'yaml' && resp['error']
+        raise APIError, resp['error'].first['error']
+      end  
+      resp
+    end
+    
+    def trace(oper, url, params)
+      return unless trace_level
+      par_str = " params: " + params.map { |p| "#{p[0]}=#{p[1]}" }.join(", ") if params and !params.empty?
+      puts "#{oper}: #{url}#{par_str}"
+    end
+  end
+    
+  %w{error base resource user tag repository issue file_object blob key commit branch}.
+    each{|f| require "#{File.dirname(__FILE__)}/octopi/#{f}"} 
+
+end

data/lib/octopi/base.rb

@@ -0,0 +1,109 @@
+class String
+  def camel_case
+    self.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end  
+module Octopi
+  class Base
+    VALID = {
+      :repo => {
+        # FIXME: API currently chokes on repository names containing periods,
+        # but presumably this will be fixed.
+        :pat => /^[a-z0-9_\.-]+$/,
+        :msg => "%s is an invalid repository name"},
+      :user => {
+        :pat => /^[A-Za-z0-9_\.-]+$/,
+        :msg => "%s is an invalid username"},
+      :file => {
+        :pat => /^[^ \/]+$/,
+        :msg => "%s is an invalid filename"},
+      :sha => {
+        :pat => /^[a-f0-9]{40}$/,
+        :msg => "%s is an invalid SHA hash"},
+      :state => {
+        # FIXME: Any way to access Issue::STATES from here?
+        :pat => /^(open|closed)$/, 
+        :msg => "%s is an invalid state; should be 'open' or 'closed'."  
+      }
+    }  
+    
+    attr_accessor :api
+    
+    def initialize(api, hash)
+      @api = api
+      @keys = []
+      
+      raise "Missing data for #{@resource}" unless hash
+      
+      hash.each_pair do |k,v|
+        @keys << k
+        next if k =~ /\./
+        instance_variable_set("@#{k}", v)
+        
+        method = (TrueClass === v || FalseClass === v) ? "#{k}?" : k
+
+        self.class.send :define_method, "#{method}=" do |v|
+          instance_variable_set("@#{k}", v)
+        end
+
+        self.class.send :define_method, method do
+          instance_variable_get("@#{k}")
+        end
+      end
+    end
+    
+    def property(p, v)
+      path = "#{self.class.path_for(:resource)}/#{p}"
+      @api.find(path, self.class.resource_name(:singular), v)
+    end
+    
+    def save
+      hash = {}
+      @keys.each { |k| hash[k] = send(k) }
+      @api.save(self.path_for(:resource), hash)
+    end
+    
+    private
+    def self.extract_user_repository(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      if opts.empty?
+        user, repo = *args if args.length > 1
+        repo ||= args.first
+      else
+        opts[:repo] = opts[:repository] if opts[:repository]
+        repo = args.pop || opts[:repo]
+        user = opts[:user]
+      end
+      
+      user ||= repo.owner if repo.is_a? Repository
+      
+      if repo.is_a?(String) and !user
+        raise "Need user argument when repository is identified by name"
+      end
+      
+      ret = extract_names(user, repo)
+      ret << opts
+      ret
+    end
+
+    def self.extract_names(*args)
+      args.map do |v|
+        v = v.name  if v.is_a? Repository
+        v = v.login if v.is_a? User
+        v
+      end
+    end
+
+    def self.validate_args(spec)
+      m = caller[0].match(/\/([a-z0-9_]+)\.rb:\d+:in `([a-z_0-9]+)'/)
+      meth = m ? "#{m[1].camel_case}.#{m[2]}" : 'method'
+      raise ArgumentError, "Invalid spec" unless 
+        spec.values.all? { |s| VALID.key? s }
+      errors = spec.reject{|arg, spec| arg.nil?}.
+                    reject{|arg, spec| arg.to_s.match(VALID[spec][:pat])}.
+                    map   {|arg, spec| "Invalid argument '%s' for %s (%s)" % 
+                      [arg, meth, VALID[spec][:msg] % arg]} 
+      raise ArgumentError, "\n" + errors.join("\n") unless errors.empty?
+    end  
+  end
+end

data/lib/octopi/blob.rb

@@ -0,0 +1,21 @@
+module Octopi
+  class Blob < Base
+    include Resource
+    set_resource_name "blob"
+
+    resource_path "/blob/show/:id"
+
+    def self.find(user, repo, sha, path=nil)
+      user = user.login if user.is_a? User
+      repo = repo.name if repo.is_a? Repository
+      self.class.validate_args(sha => :sha, user => :user, path => :file)
+      if path
+        super [user,repo,sha,path]
+      else
+        blob = ANONYMOUS_API.get_raw(path_for(:resource), 
+              {:id => [user,repo,sha].join('/')})
+        new(ANONYMOUS_API, {:text => blob})
+      end  
+    end  
+  end
+end

data/lib/octopi/branch.rb

@@ -0,0 +1,17 @@
+module Octopi
+  class Branch < Base
+    include Resource
+    set_resource_name "branch", "branches"
+
+    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,'branches'], :resource){
+        |i| {:name => i.first, :hash => i.last }
+      }
+    end
+  end
+end

data/lib/octopi/commit.rb

@@ -0,0 +1,64 @@
+module Octopi
+  class Commit < Base
+    include Resource
+    find_path "/commits/list/:query"
+    resource_path "/commits/show/:id"
+    
+    attr_accessor :repository
+    
+    # Finds all commits for a given Repository's branch
+    #
+    # 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 branch is given, "master" is assumed.
+    #
+    # Sample usage:
+    #
+    #   find_all(repo, :branch => "develop") # repo must be an object
+    #   find_all("octopi", :user => "fcoury") # user must be provided
+    #   find_all(:user => "fcoury", :repo => "octopi") # branch defaults to master
+    #
+    def self.find_all(*args)
+      repo = args.first
+      user ||= repo.owner if repo.is_a? Repository
+      user, repo_name, opts = extract_user_repository(*args)
+      self.validate_args(user => :user, repo_name => :repo)
+      branch = opts[:branch] || "master"
+      
+      commits = super user, repo_name, branch
+      commits.each { |c| c.repository = repo } if repo.is_a? Repository
+      commits
+    end
+    
+    # TODO: Make find use hashes like find_all
+    def self.find(*args)
+      if args.last.is_a?(Commit)
+        commit = args.pop
+        super "#{commit.repo_identifier}"
+      else
+        user, name, sha = *args
+        user = user.login if user.is_a? User
+        name = repo.name  if name.is_a? Repository
+        self.validate_args(user => :user, name => :repo, sha => :sha)
+        super [user, name, sha]
+      end
+    end
+    
+    def details
+      self.class.find(self)
+    end
+    
+    def repo_identifier
+      url_parts = url.split('/')
+      if @repository
+        parts = [@repository.owner, @repository.name, url_parts[6]] 
+      else
+        parts = [url_parts[3], url_parts[4], url_parts[6]]
+      end
+      
+      parts.join('/')
+    end
+  end
+end

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,98 @@
+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
+    
+    %[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
+    
+    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,79 @@
+module Octopi
+  class Repository < Base
+    include Resource
+    set_resource_name "repository", "repositories"
+
+    find_path "/repos/search/:query"
+    resource_path "/repos/show/:id"
+    
+    def branches
+      Branch.find(self.owner, self.name)
+    end  
+
+    def tags
+      Tag.find(self.owner, self.name)
+    end  
+    
+    def clone_url
+      #FIXME: Return "git@github.com:#{self.owner}/#{self.name}.git" if
+      #user's logged in and owns this repo.
+      "git://github.com/#{self.owner}/#{self.name}.git"  
+    end
+
+    def self.find_by_user(user)
+      user = user.login if user.is_a? User
+      self.validate_args(user => :user)
+      find_plural(user, :resource)
+    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")
+      Commit.find_all(self, :branch => branch)
+    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  
+
+  end
+end

data/lib/octopi/resource.rb

@@ -0,0 +1,66 @@
+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 find_path(path)
+        (@path_spec||={})[:find] = path
+      end
+    
+      def resource_path(path)
+        (@path_spec||={})[:resource] = 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)
+        find_plural(s, :find)
+      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,69 @@
+module Octopi
+  class User < Base
+    include Resource
+    
+    find_path "/user/search/:query"
+    resource_path "/user/show/:id"
+    
+    def self.find(username)
+      self.validate_args(username => :user)
+      super username
+    end
+
+    def self.find_all(username)
+      self.validate_args(username => :user)
+      super username
+    end
+
+    def repositories
+      Repository.find_by_user(login)
+    end
+    
+    def repository(name)
+      self.class.validate_args(name => :repo)
+      Repository.find(login, name)
+    end
+    
+    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
+
+    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

data/test/octopi_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class OctopiTest < Test::Unit::TestCase
+  include Octopi
+  
+  # TODO: Those tests are obviously brittle. Need to stub/mock it.
+  
+  def assert_find_all(cls, check_method, repo, user)
+    repo_method = cls.resource_name(:plural)
+    
+    item1 = cls.find_all(user.login, repo.name).first
+    item2 = cls.find_all(repo).first
+    item3 = repo.send(repo_method).first
+    
+    assert_equal item1.send(check_method), item2.send(check_method)
+    assert_equal item1.send(check_method), item3.send(check_method)
+  end
+  
+  def setup
+    @user = User.find("fcoury")
+    @repo = @user.repository("octopi")
+    @issue = @repo.issues.first
+  end
+  
+  context Issue do
+    should "return the correct issue by number" do
+      assert_equal @issue.number, Issue.find(@repo, @issue.number).number
+      assert_equal @issue.number, Issue.find(@user, @repo, @issue.number).number
+      assert_equal @issue.number, Issue.find(@repo.owner, @repo.name, @issue.number).number
+    end
+
+    should "return the correct issue by using repo.issue number" do
+      assert_equal @issue.number, @repo.issue(@issue.number).number
+    end
+    
+    should "fetch the same issue using different but equivalent find_all params" do
+      assert_find_all Issue, :number, @repo, @user
+    end
+  end
+
+  context Commit do
+    should "fetch the same commit using different but equivalent find_all params" do
+      assert_find_all Commit, :id, @repo, @user
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'octopi'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: octopi
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- Felipe Coury
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-27 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: felipe.coury@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/octopi/base.rb
+- lib/octopi/blob.rb
+- lib/octopi/branch.rb
+- lib/octopi/commit.rb
+- lib/octopi/error.rb
+- lib/octopi/file_object.rb
+- lib/octopi/issue.rb
+- lib/octopi/key.rb
+- lib/octopi/repository.rb
+- lib/octopi/resource.rb
+- lib/octopi/tag.rb
+- lib/octopi/user.rb
+- lib/octopi.rb
+- test/octopi_test.rb
+- test/test_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/fcoury/octopi
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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: octopi
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: A Ruby interface to GitHub API v2
+test_files: []
+