ddollar-octopi 0.0.13

data/lib/octopi.rb

@@ -0,0 +1,236 @@
+require 'rubygems'
+require 'httparty'
+require 'yaml'
+require 'pp'
+
+module Octopi
+  def authenticated(*args, &block)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    config = read_gitconfig
+    login = config["github"]["user"]
+    token = config["github"]["token"]
+    
+    api = AuthApi.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 = AuthApi.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("=")
+          value ||= ''
+          (config[group]||={})[key.strip] = value.strip
+        end
+      end
+    end
+    config
+  end
+  
+  class Api
+    CONTENT_TYPE = {
+      'yaml' => 'application/x-yaml',
+      'json' => 'application/json',
+      'xml'  => 'application/sml'
+    }  
+    RETRYABLE_STATUS = [403]
+    MAX_RETRIES = 10
+      
+    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 commits(repo,opts={})
+      branch = opts[:branch] || "master"
+      commits = Commit.find_all(repo, branch, self)
+    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)
+      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
+          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 = {}, format = "yaml")
+      @@retries = 0
+      begin
+        trace "POST", "/#{format}#{path}", params
+        submit(path, params, format) do |path, params, format|
+          resp = self.class.post "/#{format}#{path}", :query => params
+          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 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
+  
+  class AuthApi < Api
+    include HTTParty
+    base_uri "https://github.com/api/v2"
+  end
+    
+  class AnonymousApi < Api
+    include HTTParty
+    base_uri "http://github.com/api/v2"
+  end
+  
+  ANONYMOUS_API = AnonymousApi.new
+    
+  %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,111 @@
+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-Za-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?
+        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]
+      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,18 @@
+module Octopi
+  class Branch < Base
+    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
+      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 }
+      }
+    end
+  end
+end

data/lib/octopi/commit.rb

@@ -0,0 +1,65 @@
+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)
+      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}"
+      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