github-downloads 0.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubyforge
+
+gemspec
+
+group :test do
+  gem "mocha"
+  gem "rspec"
+  gem "mimic"
+  gem "awesome_print"
+end
+

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    github-downloads (0.1.0)
+      highline (~> 1.6.2)
+      hirb (~> 0.4.5)
+      json (~> 1.5.3)
+      mime-types (~> 1.16.0)
+      rest-client (~> 1.6.3)
+      simpleconsole (~> 0.1.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (0.3.1)
+    diff-lcs (1.1.2)
+    highline (1.6.2)
+    hirb (0.4.5)
+    json (1.5.3)
+    mime-types (1.16)
+    mimic (0.4.1)
+      json
+      plist
+      rack
+      sinatra
+    mocha (0.9.10)
+      rake
+    plist (3.1.0)
+    rack (1.2.1)
+    rake (0.9.2)
+    rest-client (1.6.3)
+      mime-types (>= 1.16)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.2)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    simpleconsole (0.1.1)
+    sinatra (1.1.2)
+      rack (~> 1.1)
+      tilt (~> 1.2)
+    tilt (1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  github-downloads!
+  mimic
+  mocha
+  rspec

data/README.md

@@ -0,0 +1,25 @@
+# github-downloads - a gem for managing your downloads, on Github
+
+This is a simple gem that does exactly what it says on the tin: manages your Github project downloads.
+
+    $ gem install github-downloads
+
+It can be used to list the downloads for your project:
+
+    $ github-downloads list -u lukeredpath -r simpleconfig
+  
+It can also be used to create a new download:
+
+    $ github-downloads create -u lukeredpath -r simpleconfig -f ~/myproject/somefile.zip -d "This is an important file"
+  
+### Github::Client, a generic Github API client
+
+The gem is built on top of [version 3 of the Github API](http://developer.github.com/v3/); included in the source is a class, Github::Client, a simple wrapper around the Github API that uses RestClient and simplifies communication with the Github API. 
+
+It provides a simple interface to the Github REST API. It handles errors appropriately and returns parsed response data as well as additional metadata such as API rate limits. 
+
+It doesn't aim to be a full-blown Github API library (completely with a local domain model) but a very thin utility ckass that can be used to write other simple scripts and gems, like this one. Feel free to use this in your own project if you are working with the Github API.
+
+### License
+
+This code is provided under the terms of the MIT license.

data/Rakefile

@@ -0,0 +1,102 @@
+require 'rake'
+require 'rdoc/task'
+require "bundler/setup"
+require 'rspec/core/rake_task'
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:specs)
+
+task :default => :specs
+
+require "rubygems"
+require "rubygems/package_task"
+
+GEM_VERSION = "0.1.0"
+
+# This builds the actual gem. For details of what all these options
+# mean, and other ones you can add, check the documentation here:
+#
+#   http://rubygems.org/read/chapter/20
+#
+spec = Gem::Specification.new do |s|
+
+  # Change these as appropriate
+  s.name              = "github-downloads"
+  s.version           = GEM_VERSION
+  s.summary           = "Manages downloads for your Github projects"
+  s.author            = "Luke Redpath"
+  s.email             = "luke@lukeredpath.co.uk"
+  s.homepage          = "http://lukeredpath.co.uk"
+
+  s.has_rdoc          = false
+  # s.extra_rdoc_files  = %w(README)
+  # s.rdoc_options      = %w(--main README)
+
+  # Add any extra files to include in the gem
+  s.files             = %w(Gemfile Gemfile.lock Rakefile README.md) + Dir.glob("{bin,spec,lib}/**/*")
+  s.executables       = FileList["bin/**"].map { |f| File.basename(f) }
+  s.require_paths     = ["lib"]
+
+  # If you want to depend on other gems, add them here, along with any
+  # relevant versions
+  gem "rest-client"
+  gem "json"
+  gem "simpleconsole"
+  gem "hirb"
+  gem "mime-types"
+  gem "highline"
+  
+  s.add_dependency("rest-client", "~> 1.6.3")
+  s.add_dependency("json", "~> 1.5.3")
+  s.add_dependency("simpleconsole", "~> 0.1.1")
+  s.add_dependency("hirb", "~> 0.4.5")
+  s.add_dependency("mime-types", "~> 1.16.0")
+  s.add_dependency("highline", "~> 1.6.2")
+
+  # If your tests use any gems, include them here
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("mocha")
+  s.add_development_dependency("mimic")
+  s.add_development_dependency("awesome_print")
+end
+
+# This task actually builds the gem. We also regenerate a static
+# .gemspec file, which is useful if something (i.e. GitHub) will
+# be automatically building a gem for this project. If you're not
+# using GitHub, edit as appropriate.
+#
+# To publish your gem online, install the 'gemcutter' gem; Read more 
+# about that here: http://gemcutter.org/pages/gem_docs
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Build the gemspec file #{spec.name}.gemspec"
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+# If you don't want to generate the .gemspec file, just remove this line. Reasons
+# why you might want to generate a gemspec:
+#  - using bundler with a git source
+#  - building the gem without rake (i.e. gem build blah.gemspec)
+#  - maybe others?
+task :package => :gemspec
+
+# Generate documentation
+RDoc::Task.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc 'Clear out RDoc and generated packages'
+task :clean => [:clobber_rdoc, :clobber_package] do
+  rm "#{spec.name}.gemspec"
+end
+
+desc 'Publish gem'
+task :publish => :gem do
+  system "gem push pkg/#{spec.file_name}"
+end

data/bin/github-downloads

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'simpleconsole'
+require File.join(File.dirname(__FILE__), *%w[.. lib github])
+
+SimpleConsole::Application.run(ARGV, Github::DownloadsController)

data/lib/github.rb

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__)
+require 'github/downloads_controller'

data/lib/github/client.rb

@@ -0,0 +1,142 @@
+require 'restclient'
+require 'ostruct'
+require 'json'
+
+module Github
+  class Client
+    class << self
+      def connect(base_url, user = nil, pass = nil)
+        new RestClient::Resource.new(base_url, user, pass)
+      end
+      
+      def proxy=(proxy_host)
+        RestClient.proxy = proxy_host
+      end
+    end
+    
+    def initialize(resource)
+      @resource = resource
+    end
+    
+    def get(path)
+      request :get, path
+    end
+    
+    def post(path, data)
+      request :post, path, data
+    end
+    
+    def put(path, data)
+      request :put, path, data
+    end
+    
+    def delete(path)
+      request :delete, path
+    end
+    
+    def head(path)
+      request :head, path
+    end
+    
+    private
+    
+    def request(method, path, data = nil)
+      if data
+        Response.new(@resource[path].send(method, data.to_json))
+      else
+        Response.new(@resource[path].send(method))
+      end
+    rescue RestClient::Exception => e
+      if Response.can_handle?(e.response)
+        Response.new(e.response)
+      else
+        raise e
+      end
+    end
+    
+    class Response
+      SUCCESS_CODES = [200, 201]
+      FAILURE_CODES = [400, 401, 422]
+      
+      def initialize(response)
+        @response = response
+      end
+      
+      def self.can_handle?(response)
+        (SUCCESS_CODES + FAILURE_CODES).include?(response.code)
+      end
+      
+      def to_s
+        "#{@response.description.strip} | Rate limit: #{rate_limit_remaining} / #{rate_limit_remaining}"
+      end
+      
+      def success?
+        when_statuses_are *SUCCESS_CODES
+      end
+      
+      def error?
+        when_statuses_are *FAILURE_CODES
+      end
+      
+      def error_message
+        parsed_response["message"]
+      end
+      
+      def errors
+        parsed_response["errors"].map { |hash| EntityError.new(hash) }
+      end
+      
+      def rate_limit
+        @response.headers[:x_ratelimit_limit].to_i
+      end
+      
+      def rate_limit_remaining
+        @response.headers[:x_ratelimit_remaining].to_i
+      end
+      
+      def location
+        @response.headers[:location]
+      end
+      
+      def data
+        parsed_response
+      end
+      
+      private
+      
+      def parsed_response
+        @parsed_response ||= JSON.parse(@response)
+      end
+      
+      def when_statuses_are(*codes)
+        codes.include?(@response.code)
+      end
+    end
+    
+    class EntityError < OpenStruct
+      MISSING        = "missing"
+      MISSING_FIELD  = "missing_field"
+      INVALID        = "invalid"
+      ALREADY_EXISTS = "already_exists"
+      
+      def to_s
+        "<Github::Client::EntityError: #{description}>"
+      end
+      
+      def description
+        case self.code
+          when MISSING
+            "#{self.resource} is missing"
+          when MISSING_FIELD
+            "#{self.resource}##{self.field} is missing"
+          when INVALID
+            "#{self.resource}##{self.field} is invalid (refer to documentation)"
+          when ALREADY_EXISTS
+            "#{self.resource}##{self.field} value is already taken (must be unique)"
+          else
+            "#{self.resource}##{self.field} error: #{self.code}"
+        end
+      end
+    end
+  end
+end

data/lib/github/downloads.rb

@@ -0,0 +1,66 @@
+require 'ostruct'
+require 'mime/types'
+require 'github/client'
+
+module Github
+  class Downloads
+    attr_accessor :uploader
+    
+    GITHUB_BASE_URL = "https://api.github.com"
+    
+    def initialize(client, user, repos)
+      @client = client
+      @user = user
+      @repos = repos
+    end
+    
+    def self.connect(user, password, repos)
+      client = Client.connect(GITHUB_BASE_URL, user, password)
+      new(client, user, repos)
+    end
+    
+    class UnexpectedResponse < StandardError
+      attr_reader :response
+      
+      def initialize(response)
+        @response = response
+      end
+    end
+    
+    def list
+      response = @client.get(downloads_resource_path)
+      
+      if response.success?
+        from_response_data(response.data)
+      else
+        raise UnexpectedResponse, response
+      end
+    end
+    
+    def create(file_path, description = "")
+      response = @client.post(downloads_resource_path, {
+        :name         => File.basename(file_path),
+        :description  => description,
+        :content_type => MIME::Types.type_for(file_path)[0] || MIME::Types["application/octet-stream"][0],
+        :size         => File.size?(file_path)
+      })
+      
+      if response.success?
+        uploader.upload(File.expand_path(file_path), response.data)
+      end
+    end
+    
+    private
+    
+    def downloads_resource_path
+      "/repos/#{@user}/#{@repos}/downloads"
+    end
+    
+    def from_response_data(data)
+      data.map { |hash| Download.new(hash) }
+    end
+    
+    class Download < OpenStruct
+    end
+  end
+end

data/lib/github/downloads_controller.rb

@@ -0,0 +1,109 @@
+require 'simpleconsole'
+require 'hirb'
+require 'highline/import'
+require 'osx_keychain'
+
+require 'github/downloads'
+require 'github/s3_uploader'
+
+module Github
+  class DownloadsController < SimpleConsole::Controller
+    include Hirb::Console
+    
+    params :string => { 
+      :u => :user, 
+      :f => :file, 
+      :n => :name, 
+      :r => :repos,
+      :d => :description,
+      :p => :proxy
+    }, 
+    :bool => {
+      :o => :overwrite
+    }
+        
+    before_filter :set_proxy
+    
+    def default
+      puts "Valid actions: list, upload, delete"
+      exit 1
+    end
+    
+    def list
+      if (downloads = github.list)
+        table downloads, {:fields => [:name, :description, :download_count]}
+      else
+        puts "Couldn't fetch downloads!"
+      end
+    rescue Github::Downloads::UnexpectedResponse => e
+      fail! "Unexpected response (#{e.response})."
+    end
+    
+    def create
+      if params[:file].nil?
+        fail! "* A file must be specified (-f or --file)"
+      end
+
+      if (url_for_upload = github(:authenticated).create(params[:file], params[:description]))
+        puts "Upload successful! (#{url_for_upload})"
+      else
+        fail! "Upload failed!"
+      end
+    rescue Github::Downloads::UnexpectedResponse => e
+      fail! "Unexpected response (#{e.response})."
+    end
+    
+    private
+    
+    def fail!(message, status = 1)
+      puts(message)
+      exit(status)
+    end
+    
+    def fetch_downloads(repo)
+       Hpricot(open("https://github.com/#{repo}/downloads"))
+    end
+    
+    def set_proxy
+      Github::Client.proxy = params[:proxy]
+    end
+    
+    def github(authentication_required = false)
+      if params[:repos].nil? || params[:user].nil?
+        fail! "* Please specify a user (-u or --user) and repository (-r or --repos)"
+      end
+      
+      if authentication_required
+        password = lookup_or_prompt_for_password(params[:user])
+      end
+      
+      @github ||= Github::Downloads.connect(params[:user], password, params[:repos]).tap do |gh|
+        gh.uploader = Github::S3Uploader.new
+      end
+    end
+    
+    def lookup_or_prompt_for_password(user)
+      fetch_password_from_keychain(user) || prompt_for_password(user)
+    end
+    
+    def prompt_for_password(user)
+      ask("Enter Github password:") {|q| q.echo = false }.tap do |password|
+        store_password_in_keychain(user, password)
+      end
+    end
+    
+    def mac?
+      RUBY_PLATFORM.match(/darwin/)
+    end
+    
+    KEYCHAIN_SERVICE = "github-uploads"
+    
+    def fetch_password_from_keychain(user)
+      OSXKeychain.new[KEYCHAIN_SERVICE, user] if mac?
+    end
+    
+    def store_password_in_keychain(user, password)
+      OSXKeychain.new[KEYCHAIN_SERVICE, user] = password if mac?
+    end
+  end
+end

data/lib/github/s3_uploader.rb

@@ -0,0 +1,24 @@
+require 'restclient'
+
+module Github
+  class S3Uploader 
+    def upload(path, metadata)
+      response = RestClient.post(metadata["s3_url"], [
+        ["key", "#{metadata["prefix"]}#{metadata["name"]}"],
+        ["acl", metadata["acl"]],
+        ["success_action_status", 201],
+        ["Filename", metadata["name"]],
+        ["AWSAccessKeyId", metadata["accesskeyid"]],
+        ["Policy", metadata["policy"]],
+        ["Signature", metadata["signature"]],
+        ["Content-Type", metadata["mime_type"]],
+        ["file", File.open(path)]
+      ])
+      if response.code == 201
+        metadata["url"]
+      else 
+        false
+      end
+    end
+  end
+end

data/spec/github_client_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+require 'github/client'
+
+class FakeResource # fake RestClient::Resource
+  attr_reader :path
+  
+  def initialize(path = "/")
+    @path = Mocha::Mockery.instance.new_state_machine("location").starts_as(path)
+  end
+  
+  def [](path)
+    tap { @path.become(path) }
+  end
+end
+
+describe "Github::Client" do
+  
+  before :each do
+    @resource = FakeResource.new
+    @client = Github::Client.new(@resource)
+  end
+  
+  describe "#get" do
+    it "performs a GET request to /some/path on the resource" do
+      @resource.expects(:get).when @resource.path.is("/some/path")
+      @client.get("/some/path")
+    end
+    
+    it "returns a Github::Client::Response" do
+      @resource.stubs(:get)
+      @client.get("/some/path").should be_instance_of(Github::Client::Response)
+    end
+  end
+  
+  describe "#post" do
+    it "performs a POST request with the supplied data in JSON format to /some/path on the resource" do
+      @resource.expects(:post).with({"foo" => "bar"}.to_json).when @resource.path.is("/some/path")
+      @client.post("/some/path", {"foo" => "bar"})
+    end
+    
+    it "returns a Github::Client::Response" do
+      @resource.stubs(:post)
+      @client.post("/some/path", nil).should be_instance_of(Github::Client::Response)
+    end
+  end
+  
+  describe "#put" do
+    it "performs a PUT request with the supplied data in JSON format to /some/path on the resource" do
+      @resource.expects(:put).with({"foo" => "bar"}.to_json).when @resource.path.is("/some/path")
+      @client.put("/some/path", {"foo" => "bar"})
+    end
+    
+    it "returns a Github::Client::Response" do
+      @resource.stubs(:put)
+      @client.put("/some/path", nil).should be_instance_of(Github::Client::Response)
+    end
+  end
+  
+  describe "#delete" do
+    it "performs a DELETE request to /some/path on the resource" do
+      @resource.expects(:delete).when @resource.path.is("/some/path")
+      @client.delete("/some/path")
+    end
+    
+    it "returns a Github::Client::Response" do
+      @resource.stubs(:delete)
+      @client.delete("/some/path").should be_instance_of(Github::Client::Response)
+    end
+  end
+  
+  describe "#head" do
+    it "performs a HEAD request to /some/path on the resource" do
+      @resource.expects(:head).when @resource.path.is("/some/path")
+      @client.head("/some/path")
+    end
+    
+    it "returns a Github::Client::Response" do
+      @resource.stubs(:head)
+      @client.head("/some/path").should be_instance_of(Github::Client::Response)
+    end
+  end
+  
+end
+
+describe "Github::Client::Response" do
+    
+  before :each do
+    @client = Github::Client.connect("http://localhost:#{mimic_port}")
+  end
+  
+  def response
+    @client.get("/some/path")
+  end
+  
+  def post_response(data = "")
+    @client.post("/some/path", data)
+  end
+  
+  context "for a standard non-paginated 200 response" do
+    before :each do
+      Mimic.mimic.get("/some/path").returning({"result" => "ok"}.to_json, 200, {"X-RateLimit-Limit" => "5000", "X-RateLimit-Remaining" => "4966"})
+    end
+    
+    it "indicates success" do
+      response.should be_success
+    end
+    
+    it "stores the current rate limit" do
+      response.rate_limit.should == 5000
+    end
+    
+    it "stores the number of rate-limited requests remaining" do
+      response.rate_limit_remaining.should == 4966
+    end
+    
+    it "returns the parsed JSON response" do
+      response.data.should == {"result" => "ok"}
+    end
+  end
+  
+  context "for 201 created responses" do
+    before :each do
+      Mimic.mimic.post("/some/path").returning("", 201, {"Location" => "http://example.com/resource"})
+    end
+    
+    it "indicates success" do
+      post_response.should be_success
+    end
+    
+    it "returns the location of the created resource" do
+      post_response.location.should == "http://example.com/resource"
+    end
+  end
+  
+  context "for a bad request" do
+    before :each do
+      Mimic.mimic.get("/some/path").returning({"message" => "There was an error"}.to_json, 400, {})
+    end
+    
+    it "indicates an error" do
+      response.should be_error
+      response.should_not be_success
+    end
+    
+    it "returns the error message" do
+      response.error_message.should == "There was an error"
+    end
+  end
+  
+  context "for requests with invalid data" do
+    before :each do
+      Mimic.mimic.get("/some/path").returning(
+        {"message" => "Validation failed", 
+          "errors" => [
+            {"resource" => "Issue", "field" => "title", "code" => "missing_field"}
+          ]}.to_json, 422, {})
+    end
+    
+    it "indicates an error" do
+      response.should be_error
+      response.should_not be_success
+    end
+    
+    it "returns the error message" do
+      response.error_message.should == "Validation failed"
+    end
+    
+    it "returns the errors" do
+      response.should have(1).errors
+      response.errors[0].resource.should == "Issue"
+      response.errors[0].field.should == "title"
+      response.errors[0].code.should == Github::Client::EntityError::MISSING_FIELD
+    end
+  end
+  
+  context "for a server error" do
+    before :each do
+      Mimic.mimic.get("/some/path").returning("", 500)
+    end
+    
+    it "raises an exception" do
+      proc{ @client.get("/some/path") }.should raise_error
+    end
+  end  
+end
+
+describe "Github::Client authentication" do
+    
+  context "with basic auth" do
+    before :each do
+      Mimic.mimic do
+        use Rack::Auth::Basic do |user, pass|
+          user == "joebloggs" and pass == "letmein"
+        end
+  
+        get("/some/path") { [200, {}, ""] }
+      end
+    end
+    
+    it "should succeed when authenticated correctly" do
+      @client = Github::Client.connect("http://localhost:#{mimic_port}", "joebloggs", "letmein")
+      @client.get("/some/path").should be_success
+    end
+    
+    it "should fail when not authenticated correctly" do
+      @client = Github::Client.connect("http://localhost:#{mimic_port}", "joebloggs", "wrongpass")
+      @client.get("/some/path").should be_error
+    end
+  end
+  
+end

data/spec/github_download_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'github/downloads'
+
+describe "Github::Downloads" do
+  
+  before :each do
+    @client = mock("client")
+    @downloads = Github::Downloads.new(@client, "username", "somerepo")
+  end
+  
+  describe "#list" do
+    it "returns an empty array when there is no downloads" do
+      @client.stubs(:get).with("/repos/username/somerepo/downloads").returns successful_response_with([])
+      @downloads.list.should be_empty
+    end
+    
+    it "returns an array of downloads parsed from the response when there are downloads" do
+      @client.stubs(:get).with("/repos/username/somerepo/downloads").returns successful_response_with([
+        {
+          "url" => "https://api.github.com/repos/octocat/Hello-World/downloads/1",
+          "html_url" => "https://github.com/repos/octocat/Hello-World/downloads/filename",
+          "id" => 1,
+          "name" => "file.zip",
+          "description" => "The latest release",
+          "size" => 1024,
+          "download_count" => 40
+        }
+      ])
+      @downloads.list.size.should == 1
+      @downloads.list.first.description.should == "The latest release"
+    end
+    
+    it "raises if the response is not successful" do
+      @client.stubs(:get).with("/repos/username/somerepo/downloads").returns unsuccessful_response
+      proc { @downloads.list }.should raise_error(Github::Downloads::UnexpectedResponse)
+    end
+  end
+  
+  describe "#upload" do
+    
+    before :each do
+      @uploader = mock("uploader")
+      @downloads.uploader = @uploader
+    end
+    
+    it "posts the file metadata to the server" do
+      @client.expects(:post).with("/repos/username/somerepo/downloads", {
+        :name         => "textfile.txt",
+        :description  => "an example file",
+        :content_type => "text/plain",
+        :size         => File.size?("fixtures/textfile.txt")
+      }).returns(unsuccessful_response)
+      
+      @downloads.create("fixtures/textfile.txt", "an example file")
+    end
+    
+    it "passes the upload response data to the uploader if successful" do
+      @client.stubs(:post).returns successful_response_with("upload data")
+      @uploader.expects(:upload).with(File.expand_path("fixtures/textfile.txt"), "upload data")
+      @downloads.create("fixtures/textfile.txt", "an example file")
+    end
+    
+    it "returns the URL returned by the uploader if successful" do
+      @client.stubs(:post).returns successful_response_with("upload data")
+      @uploader.stubs(:upload).returns("http://www.example.com/download")
+      @downloads.create("fixtures/textfile.txt", "an example file").should == "http://www.example.com/download"
+    end
+    
+    it "returns false without uploading anything when upload post fails" do
+      @client.stubs(:post).returns unsuccessful_response
+      @uploader.expects(:upload).never
+      @downloads.create("fixtures/textfile.txt", "an example file").should be_false
+    end
+    
+  end
+  
+  private
+  
+  def unsuccessful_response
+    stub("response", :success? => false)
+  end
+  
+  def successful_response_with(data)
+    stub("response", :success? => true, :data => data)
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require "rubygems"
+require "bundler/setup"
+require 'rspec'
+require 'mocha'
+require 'mimic'
+require 'ap'
+
+$:.unshift(File.join(File.dirname(__FILE__), *%w[.. lib]))
+
+Rspec.configure do |config|
+  config.color_enabled = true
+  config.mock_with :mocha
+  config.before(:each) do
+    Mimic.cleanup!
+  end
+end
+
+USE_CHARLES_PROXY = false
+
+def mimic_port
+  if USE_CHARLES_PROXY
+    11989
+  else
+    Mimic::MIMIC_DEFAULT_PORT
+  end
+end

metadata

@@ -0,0 +1,229 @@
+--- !ruby/object:Gem::Specification 
+name: github-downloads
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Luke Redpath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 6
+        - 3
+        version: 1.6.3
+  prerelease: false
+  type: :runtime
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        - 3
+        version: 1.5.3
+  prerelease: false
+  type: :runtime
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  name: simpleconsole
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  prerelease: false
+  type: :runtime
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  name: hirb
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 4
+        - 5
+        version: 0.4.5
+  prerelease: false
+  type: :runtime
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 87
+        segments: 
+        - 1
+        - 16
+        - 0
+        version: 1.16.0
+  prerelease: false
+  type: :runtime
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  name: highline
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 6
+        - 2
+        version: 1.6.2
+  prerelease: false
+  type: :runtime
+  requirement: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id007
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id008
+- !ruby/object:Gem::Dependency 
+  name: mimic
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id009
+- !ruby/object:Gem::Dependency 
+  name: awesome_print
+  version_requirements: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id010
+description: 
+email: luke@lukeredpath.co.uk
+executables: 
+- github-downloads
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- README.md
+- bin/github-downloads
+- spec/fixtures/textfile.txt
+- spec/github_client_spec.rb
+- spec/github_download_spec.rb
+- spec/spec_helper.rb
+- lib/github/client.rb
+- lib/github/downloads.rb
+- lib/github/downloads_controller.rb
+- lib/github/s3_uploader.rb
+- lib/github.rb
+homepage: http://lukeredpath.co.uk
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Manages downloads for your Github projects
+test_files: []
+