octopi 0.1.0 → 0.2.1

data/lib/octopi/api.rb

@@ -0,0 +1,209 @@
+require 'singleton'
+require File.join(File.dirname(__FILE__), "self")
+module Octopi
+  # Dummy class, so AnonymousApi and AuthApi have somewhere to inherit from
+  class Api
+    include Self
+    attr_accessor :format, :login, :token, :trace_level, :read_only
+  end
+  
+  # Used for accessing the Github API anonymously
+  class AnonymousApi < Api
+    include HTTParty
+    include Singleton
+    base_uri "http://github.com/api/v2"
+    
+    def read_only?
+      true
+    end
+    
+    def auth_parameters
+      { }
+    end
+  end
+  
+  class AuthApi < Api
+    include HTTParty
+    include Singleton
+    base_uri "https://github.com/api/v2"
+    
+    def read_only?
+      false
+    end
+    
+    def auth_parameters
+      { :login => Api.me.login, :token => Api.me.token }
+    end
+  end
+  
+  # This is the real API class.
+  #
+  # API requests are limited to 60 per minute.
+  #
+  # Sets up basic methods for accessing the API.
+  class Api
+    @@api = Octopi::AnonymousApi.instance
+    @@authenticated = false
+    
+    include Singleton
+    CONTENT_TYPE = {
+      'yaml' => ['application/x-yaml', 'text/yaml', 'text/x-yaml', 'application/yaml'],
+      'json' => 'application/json',
+      'xml'  => 'application/xml',
+      # Unexpectedly, Github returns resources such as blobs as text/html!
+      # Thus, plain == text/html.
+      'plain' => ['text/plain', 'text/html']
+    }  
+    RETRYABLE_STATUS = [403]
+    MAX_RETRIES = 10
+    # Would be nice if cattr_accessor was available, oh well.
+    
+    # We use this to check if we use the auth or anonymous api
+    def self.authenticated
+      @@authenticated
+    end
+    
+    # We set this to true when the user has auth'd.
+    def self.authenticated=(value)
+      @@authenticated = value
+    end
+    
+    # The API we're using 
+    def self.api
+      @@api
+    end
+    
+    class << self
+      alias_method :me, :api
+    end
+    
+    # set the API we're using
+    def self.api=(value)
+      @@api = value
+    end
+
+
+    def user
+      user_data = get("/user/show/#{login}")
+      raise "Unexpected response for user command" unless user_data and user_data['user']
+      User.new(user_data['user'])
+    end
+  
+    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, klass=nil, cache=true)      
+      result = get(path, { :id => resource_id, :cache => cache }, klass) 
+      result
+    end
+    
+    
+    def find_all(path, result_key, query, klass=nil, cache=true)
+      { :query => query, :id => query, :cache => cache }
+      result = get(path, { :query => query, :id => query, :cache => cache }, klass)
+      result[result_key]
+    end
+  
+    def get_raw(path, params, klass=nil)
+     get(path, params, klass,  'plain')
+    end
+  
+    def get(path, params = {}, klass=nil, format = :yaml)
+      @@retries = 0
+      begin
+        submit(path, params, klass, format) do |path, params, format, query|
+          self.class.get "/#{format}#{path}", { :format => format, :query => query }
+        end
+      rescue RetryableAPIError => e
+        if @@retries < MAX_RETRIES 
+          $stderr.puts e.message
+          @@retries += 1
+          sleep 6
+          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 = {}, klass=nil, format = :yaml)
+      @@retries = 0
+      begin
+        trace "POST", "/#{format}#{path}", params
+        submit(path, params, klass, format) do |path, params, format, query|
+          resp = self.class.post "/#{format}#{path}", { :body => params, :format => format, :query => query }
+          resp
+        end
+      rescue RetryableAPIError => e
+        if @@retries < MAX_RETRIES
+          $stderr.puts e.message
+          @@retries += 1
+          sleep 6
+          retry
+        else
+          raise APIError, "GitHub returned status #{e.code}, despite" +
+           " repeating the request #{MAX_RETRIES} times. Giving up."
+        end
+      end
+    end
+
+    private
+    
+    def method_missing(method, *args)
+      api.send(method, *args)
+    end
+    
+    def submit(path, params = {}, klass=nil, format = :yaml, &block)
+      # Ergh. Ugly way to do this. Find a better one!
+      cache = params.delete(:cache) 
+      cache = true if cache.nil?
+      params.each_pair do |k,v|
+        if path =~ /:#{k.to_s}/
+          params.delete(k)
+          path = path.gsub(":#{k.to_s}", v)
+        end
+      end
+      begin
+        key = "#{Api.api.class.to_s}:#{path}"
+        resp = if cache
+          APICache.get(key, :cache => 61) do
+            yield(path, params, format, auth_parameters)
+          end
+        else
+          yield(path, params, format, auth_parameters)
+        end
+      rescue Net::HTTPBadResponse
+        raise RetryableAPIError
+      end     
+      
+      raise RetryableAPIError, resp.code.to_i if RETRYABLE_STATUS.include? resp.code.to_i
+      # puts resp.code.inspect
+      raise NotFound, klass || self.class if resp.code.to_i == 404
+      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.
+      
+      # It happens, in tests.
+      return resp if resp.headers.empty?
+      ctype = resp.headers['content-type'].first.split(";").first
+      raise FormatError, [ctype, format] unless CONTENT_TYPE[format.to_s].include?(ctype)
+      if format == 'yaml' && resp['error']
+        raise APIError, resp['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 && !params.empty?
+      puts "#{oper}: #{url}#{par_str}"
+    end
+    
+  end
+end

data/lib/octopi/base.rb

@@ -1,8 +1,3 @@
-class String
-  def camel_case
-    self.gsub(/(^|_)(.)/) { $2.upcase }
-  end
-end  
 module Octopi
   class Base
     VALID = {
@@ -14,9 +9,6 @@ module Octopi
       :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"},
@@ -29,62 +21,70 @@ module Octopi
     
     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
+    def initialize(attributes={})
+      # Useful for finding out what attr_accessor needs for classes
+      # puts caller.first.inspect
+      # puts "#{self.class.inspect} #{attributes.keys.map { |s| s.to_sym }.inspect}"
+      attributes.each do |key, value|
+        raise "no attr_accessor set for #{key} on #{self.class}" if !respond_to?("#{key}=")
+        self.send("#{key}=", value)
+      end
+    end
+    
+    def error=(error)
+      if /\w+ not found/.match(error)
+        raise NotFound, self.class
       end
     end
     
     def property(p, v)
       path = "#{self.class.path_for(:resource)}/#{p}"
-      @api.find(path, self.class.resource_name(:singular), v)
+      Api.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)
+      Api.api.save(self.path_for(:resource), hash)
     end
     
     private
+    
+    def self.gather_name(options)
+      options[:repository] || options[:repo] || options[:name]
+    end
+    
+    def self.gather_details(options)
+      repo = self.gather_name(options)
+      repo = Repository.find(:user => options[:user], :name => repo) if !repo.is_a?(Repository)
+      user = repo.owner.to_s
+      user ||= options[:user].to_s
+      branch = options[:branch] || "master"
+      self.validate_args(user => :user, repo.name => :repo)
+      [user, repo, branch, options[:sha]].compact
+    end
+    
     def self.extract_user_repository(*args)
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      if opts.empty?
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      if options.empty?
         if args.length > 1
           repo, user = *args
         else
           repo = args.pop
         end
       else
-        opts[:repo] = opts[:repository] if opts[:repository]
-        repo = args.pop || opts[:repo]
-        user = opts[:user]
+        options[:repo] = options[:repository] if options[:repository]
+        repo = args.pop || options[:repo]
+        user = options[:user]
       end
       
       user = repo.owner if repo.is_a? Repository
       
-      if repo.is_a?(String) and !user
+      if repo.is_a?(String) && !user
         raise "Need user argument when repository is identified by name"
       end
       ret = extract_names(user, repo)
-      ret << opts
+      ret << options
       ret
     end
 
@@ -95,7 +95,11 @@ module Octopi
         v
       end
     end
-
+    
+    def self.ensure_hash(spec)
+      raise ArgumentMustBeHash, "find takes a hash of options as a solitary argument" if !spec.is_a?(Hash)
+    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'

data/lib/octopi/blob.rb

@@ -1,20 +1,24 @@
+require File.join(File.dirname(__FILE__), "resource")
 module Octopi
   class Blob < Base
+    attr_accessor :text, :data, :name, :sha, :size, :mode, :mime_type
     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)
+    def self.find(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
+      sha = options[:sha]
+      path = options[:path]
+      
+      self.validate_args(sha => :sha, user => :user)
+      
       if path
-        super [user,repo,sha,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})
+        Api.api.get_raw(path_for(:resource), {:id => [user, repo, sha].join('/')})
       end  
     end  
   end

data/lib/octopi/branch.rb

@@ -1,18 +1,31 @@
 module Octopi
   class Branch < Base
+    attr_accessor :name, :sha
     include Resource
     set_resource_name "branch", "branches"
 
     resource_path "/repos/show/:id"
     
-    def self.find(user, repo, api=ANONYMOUS_API)
-      user = user.login if user.is_a? User
-      repo = repo.name if repo.is_a? Repository
+    # Called when we ask for a resource.
+    # Arguments are passed in like [<name>, <sha>]
+    # TODO: Find out why args are doubly nested
+    def initialize(*args)
+      args = args.flatten!
+      self.name = args.first
+      self.sha = args.last
+    end
+    
+    def to_s
+      name
+    end
+    
+    def self.all(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
       self.validate_args(user => :user, repo => :repo)
-      api = ANONYMOUS_API if repo.is_a?(Repository) && !repo.private
-      find_plural([user,repo,'branches'], :resource, api){
-        |i| {:name => i.first, :hash => i.last }
-      }
+      BranchSet.new(find_plural([user, repo, 'branches'], :resource)) do |i|
+        { :name => i.first, :hash => i.last }
+      end
     end
   end
 end

data/lib/octopi/branch_set.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "branch")
+class Octopi::BranchSet < Array
+  include Octopi
+  attr_accessor :user, :repository
+  # Takes a name, returns a branch if it exists
+  def find(name)
+    branch = detect { |b| b.name == name }
+    raise NotFound, Branch if branch.nil?
+    branch
+  end
+end

data/lib/octopi/comment.rb

@@ -0,0 +1,20 @@
+module Octopi
+  class Comment < Base
+    attr_accessor :content, :author, :title, :updated, :link, :published, :id, :repository
+    include Resource
+    set_resource_name "tree"
+
+    resource_path "/tree/show/:id"
+
+    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] 
+    end 
+    
+    def commit
+      Commit.find(:user => repository.owner, :repo => repository, :sha => /commit\/(.*?)#/.match(link)[1])
+    end
+  end
+end

data/lib/octopi/commit.rb

@@ -4,51 +4,55 @@ module Octopi
     find_path "/commits/list/:query"
     resource_path "/commits/show/:id"
     
-    attr_accessor :repository
+    attr_accessor :repository, :message, :parents, :author, :url, :id, :committed_date, :authored_date, :tree, :committer, :added, :removed, :modified
     
-    # Finds all commits for a given Repository's branch
+    
+    # Finds all commits for the given options:
     #
-    # 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.
+    # :repo or :repository or :name - A repository object or the name of a repository
+    # :user - A user object or the login of a user
+    # :branch - A branch object or the name of a branch. Defaults to master. 
     # 
-    # 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
+    #   >> find_all(:user => "fcoury", :repo => "octopi")
+    #   => <Latest 30 commits for master branch>
+    #  
+    #   => find_all(:user => "fcoury", :repo => "octopi", :branch => "lazy") # branch is set to lazy.
+    #   => <Latest 30 commits for lazy branch>
     #
-    def self.find_all(*args)
-      api = args.last.is_a?(Api) ? args.pop : ANONYMOUS_API
-      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"
-      api = ANONYMOUS_API if repo.is_a?(Repository) && !repo.private
-      commits = super user, repo_name, branch, api
-      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}"
+    def self.find_all(options={})
+      ensure_hash(options)
+      user, repo, branch = gather_details(options)
+      commits = if options[:path]
+        super user, repo.name, branch, options[:path]
       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]
+        super user, repo.name, branch
       end
+      # Repository is not passed in from the data, set it manually.
+      commits.each { |c| c.repository = repo }
+      commits
     end
     
-    def details
-      self.class.find(self)
+    # Finds all commits for the given options:
+    #
+    # :repo or :repository or :name - A repository object or the name of a repository
+    # :user - A user object or the login of a user
+    # :branch - A branch object or the name of a branch. Defaults to master. 
+    # :sha - The commit ID
+    # 
+    # Sample usage:
+    #
+    #   >> find(:user => "fcoury", :repo => "octopi", :sha => "f6609209c3ac0badd004512d318bfaa508ea10ae")
+    #   => <Commit f6609209c3ac0badd004512d318bfaa508ea10ae for branch master>
+    #
+    #   >> find(:user => "fcoury", :repo => "octopi", :branch => "lazy", :sha => "f6609209c3ac0badd004512d318bfaa508ea10ae") # branch is set to lazy.
+    #   => <Commit f6609209c3ac0badd004512d318bfaa508ea10ae for branch lazy>
+    #
+    def self.find(options={})
+      ensure_hash(options)
+      user, repo, branch, sha = gather_details(options)
+      super [user, repo, sha]
     end
     
     def repo_identifier