dcuddeback-octopi 0.2.8

data/lib/octopi/api.rb

@@ -0,0 +1,213 @@
+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
+          if e.code != 403
+            @@retries += 1
+            sleep 6
+            retry
+          else
+            raise APIError, "Github returned status #{e.code}, you may not have access to this resource."
+          end
+        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

@@ -0,0 +1,115 @@
+module Octopi
+  class Base
+    VALID = {
+      :repo => {
+        # FIXME: API currently chokes on repository names containing periods,
+        # but presumably this will be fixed.
+        :pat => /^[A-Za-z0-9_\.-]+$/,
+        :msg => "%s is an invalid repository name"},
+      :user => {
+        :pat => /^[A-Za-z0-9_\.-]+$/,
+        :msg => "%s is an invalid username"},
+      :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(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|
+        method = "#{key}="
+        self.send(method, value) if respond_to? method
+      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.api.find(path, self.class.resource_name(:singular), v)
+    end
+    
+    def save
+      hash = {}
+      @keys.each { |k| hash[k] = send(k) }
+      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)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      if options.empty?
+        if args.length > 1
+          repo, user = *args
+        else
+          repo = args.pop
+        end
+      else
+        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) && !user
+        raise "Need user argument when repository is identified by name"
+      end
+      ret = extract_names(user, repo)
+      ret << options
+      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.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'
+      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,25 @@
+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(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]
+      else
+        Api.api.get_raw(path_for(:resource), {:id => [user, repo, sha].join('/')})
+      end  
+    end  
+  end
+end

data/lib/octopi/branch.rb

@@ -0,0 +1,31 @@
+module Octopi
+  class Branch < Base
+    attr_accessor :name, :sha
+    include Resource
+    set_resource_name "branch", "branches"
+
+    resource_path "/repos/show/:id"
+    
+    # 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)
+      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

@@ -0,0 +1,69 @@
+module Octopi
+  class Commit < Base
+    include Resource
+    find_path "/commits/list/:query"
+    resource_path "/commits/show/:id"
+    
+    attr_accessor :repository, :message, :parents, :author, :url, :id, :committed_date, :authored_date, :tree, :committer, :added, :removed, :modified
+    
+    
+    # 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. 
+    # 
+    # Sample usage:
+    #
+    #   >> 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(options={})
+      ensure_hash(options)
+      user, repo, branch = gather_details(options)
+      commits = if options[:path]
+        super user, repo.name, branch, options[:path]
+      else
+        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
+    
+    # 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
+      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/deploy_key.rb

@@ -0,0 +1,27 @@
+module Octopi
+  class DeployKey < Base
+    include Resource
+    set_resource_name "public_key"
+
+    attr_accessor :title, :id, :key
+
+    create_path "/repos/key/:id/add"
+    delete_path "/repos/key/:id/remove"
+    find_path "/repos/keys/:id"
+
+    def self.all(options={})
+      ensure_hash(options)
+      user, repo = gather_details(options)
+      self.validate_args(repo => :repo)
+      DeployKeySet.new(repo, find_plural([repo], :find))
+    end
+
+    def self.create(options={})
+      ensure_hash(options)
+      repo = options.delete(:repo)
+      options[:id] = repo.name
+      resp = Api.api.post(path_for(:create), options.merge(:cache => false))
+      DeployKeySet.new(repo, resp[resource_name(:plural)].map {|k| self.new(k)})
+    end
+  end
+end

data/lib/octopi/deploy_key_set.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "key")
+class Octopi::DeployKeySet < Array
+  include Octopi
+  attr_accessor :repository
+
+  def initialize(repo, keys)
+    self.repository = repo
+    super keys
+  end
+
+  def find(title)
+    detect {|key| key.title == title}
+  end
+
+  def add(options={})
+    DeployKey.create(options.merge(:repo => repository))
+  end
+end

data/lib/octopi/error.rb

@@ -0,0 +1,35 @@
+module Octopi
+
+  class FormatError < StandardError
+   def initialize(f)
+     super("Got unexpected format (got #{f.first} for #{f.last})")
+   end
+  end
+  
+  class AuthenticationRequired < StandardError
+  end
+
+  class APIError < StandardError
+  end
+  
+  class InvalidLogin < StandardError
+  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
+  
+  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

@@ -0,0 +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(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  
+  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