tpitale-octopi 0.3.0

data/lib/ext/string_ext.rb

@@ -0,0 +1,5 @@
+class String
+  def camel_case
+    self.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end

data/lib/octopi.rb

@@ -0,0 +1,92 @@
+require 'rubygems'
+
+require 'httparty'
+require 'api_cache'
+
+require 'yaml'
+require 'pp'
+
+# Core extension stuff
+Dir[File.join(File.dirname(__FILE__), "ext/*.rb")].each { |f| require f }
+
+# Octopi stuff
+# By sorting them we ensure that api and base are loaded first on all sane operating systems
+Dir[File.join(File.dirname(__FILE__), "octopi/*.rb")].sort.each { |f| require f }
+
+# Include this into your app so you can access the child classes easier.
+# This is the root of all things Octopi.
+module Octopi
+  
+  # The authenticated methods are all very similar.
+  # TODO: Find a way to merge them into something... better.
+  
+  def authenticated(options={}, &block)
+    begin
+      config = config = File.open(options[:config]) { |yf| YAML::load(yf) } if options[:config]
+      config = read_gitconfig
+      options[:login] = config["github"]["user"]
+      options[:token] = config["github"]["token"]
+      
+      authenticated_with(options) do
+        yield 
+      end
+    ensure
+      # Reset authenticated so if we were to do an anonymous call it would Just Work(tm)
+      Api.authenticated = false
+      Api.api = AnonymousApi.instance
+    end
+  end
+  
+  def authenticated_with(options, &block)
+    begin
+
+      Api.api.trace_level = options[:trace] if options[:trace]
+      
+      raise "This version of octopi requires a token be set" if options[:token].nil?
+
+      begin
+        User.find(options[:login])
+        # If the user cannot see themselves then they are not logged in, tell them so
+      rescue Octopi::NotFound
+        raise Octopi::InvalidLogin
+      end
+    
+      trace("=> Trace on: #{options[:trace]}")
+    
+      Api.api = AuthApi.instance
+      Api.api.login = options[:login]
+      Api.api.token = options[:token]
+    
+      yield
+    ensure
+      # Reset authenticated so if we were to do an anonymous call it would Just Work(tm)
+      Api.authenticated = false
+      Api.api = AnonymousApi.instance
+    end
+  end
+    
+  private
+  def read_gitconfig
+    config = {}
+    group = nil
+    File.foreach("#{ENV['HOME']}/.gitconfig") do |line|
+      line.strip!
+      if line[0] != ?# && line =~ /\S/
+        if line =~ /^\[(.*)\]$/
+          group = $1
+          config[group] ||= {}
+        else
+          key, value = line.split("=").map { |v| v.strip }
+          config[group][key] = value
+        end
+      end
+    end
+    config
+  end
+  
+  def trace(text)
+    if Api.api.trace_level
+      puts "text"
+    end
+  end
+end

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