gista 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+doc
+pkg

data/.rspec

@@ -0,0 +1,3 @@
+--format progress
+--color
+--order rand

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/.yardopts

@@ -0,0 +1,8 @@
+--no-private
+--title "Gista: create Github gists from the command line"
+--readme README.md
+--markup markdown
+--markup-provider kramdown
+-
+HISTORY.md
+LICENSE

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    gista (1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    fakeweb (1.3.0)
+    kramdown (0.14.0)
+    rake (0.9.2.2)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakeweb (~> 1.3)
+  gista!
+  kramdown
+  rake (~> 0.9)
+  rspec (~> 2.11)
+  yard (~> 0.8)

data/HISTORY.md

@@ -0,0 +1,5 @@
+# Release History
+
+## 1.0.0
+
+* Initial release.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Arjan van der Gaag
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# Gista -- create gists from the command line [![Build Status](https://secure.travis-ci.org/avdgaag/gista.png?branch=master)](http://travis-ci.org/avdgaag/gista) [![Gemnasium dependency status](https://gemnasium.com/avdgaag/gista.png)](https://gemnasium.com/avdgaag/gista)
+
+## Introduction
+
+Gista is a very simple command-line program and Ruby library for creating
+Gists. As a stand-alone program, it can create a new gist from files listed as
+arguments, or by reading from STDIN.
+
+## Installation
+
+Gista is distributed as a Ruby gem, which should be installed on most Macs and
+Linux systems. Once you have ensured you have a working installation of Ruby
+and Ruby gems, install the gem as follows from the command line:
+
+    $ gem install gista
+
+You can verify the gem has installed correctly by checking its version number:
+
+    $ gista -v
+
+If this generates an error, something has gone wrong. You should see something
+along the lines of `gista 1.0.0`.
+
+## Usage
+
+You can list one or more filenames as an argument:
+
+    $ gista filename1 filename2...
+
+Or, you can read content from STDIN:
+
+    $ echo "Hello, world!" | gista
+
+When reading from STDIN one file will be created, by default called `untitled`.
+You can override this name:
+
+    $ echo "Hello, world!" | gista -f "my new gist"
+
+By default, new gists are private. You can make a public gist with the `-p`
+option:
+
+    $ gista -p filename1
+    $ gista --public filename1
+
+When everything went according to plan, the program will output the URL to
+the newly created gist.
+
+If you want to use Gista as a Ruby library, take a look at the `bin/gista`
+file for an example how to use it:
+
+    authoriser = Gista::TokenRequest.new(Gista::LoginPrompt.new)
+    token      = Gista::UserToken.new(authoriser).token
+    options    = Gista::Options.new(ARGV).options
+    puts Gista.post_and_get_url(token, options)
+
+### Documentation
+
+See the inline [API
+docs](http://rubydoc.info/github/avdgaag/gista/master/frames) for more
+information.
+
+## Other
+
+### Note on Patches/Pull Requests
+
+1. Fork the project.
+2. Make your feature addition or bug fix.
+3. Add tests for it. This is important so I don't break it in a future version
+   unintentionally.
+4. Commit, do not mess with rakefile, version, or history. (if you want to have
+   your own version, that is fine but bump version in a commit by itself I can
+   ignore when I pull)
+5. Send me a pull request. Bonus points for topic branches.
+
+### Issues
+
+Please report any issues, defects or suggestions in the [Github issue
+tracker](https://github.com/avdgaag/gista/issues).
+
+### What has changed?
+
+See the [HISTORY](https://github.com/avdgaag/gista/blob/master/HISTORY.md) file
+for a detailed changelog.
+
+### Credits
+
+Created by: Arjan van der Gaag  
+URL: [http://arjanvandergaag.nl](http://arjanvandergaag.nl)  
+Project homepage: [http://avdgaag.github.com/gista](http://avdgaag.github.com/gista)  
+Date: april 2012  
+License: [MIT-license](https://github.com/avdgaag/gista/LICENSE) (same as Ruby)

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+Bundler.setup
+
+require 'rspec/core/rake_task'
+require 'yard'
+
+desc 'Default: run specs.'
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new
+
+desc 'Generate API docs'
+YARD::Rake::YardocTask.new

data/bin/gista

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gista'
+
+begin
+  authoriser = Gista::TokenRequest.new(Gista::LoginPrompt.new)
+  token      = Gista::UserToken.new(authoriser).token
+  options    = Gista::Options.new(ARGV).options
+  puts Gista.post_and_get_url(token, options)
+rescue StandardError => e
+  abort e.message
+end

data/gista.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/gista/version', __FILE__)
+
+Gem::Specification.new do |s|
+  # Metadata
+  s.name        = 'gista'
+  s.version     = Gista::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Arjan van der Gaag']
+  s.email       = %q{arjan@arjanvandergaag.nl}
+  s.description = %q{create gists from the command line}
+  s.homepage    = %q{http://avdgaag.github.com/gista}
+  s.summary     = <<-EOS
+Gista is a very simple command-line program and Ruby library for creating
+Gists. As a stand-alone program, it can create a new gist from files listed as
+arguments, or by reading from STDIN.
+EOS
+
+  # Files
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # Rdoc
+  s.rdoc_options = ['--charset=UTF-8']
+  s.extra_rdoc_files = [
+     'LICENSE',
+     'README.md',
+     'HISTORY.md'
+  ]
+
+  # Dependencies
+  s.add_development_dependency 'yard',     '~> 0.8'
+  s.add_development_dependency 'fakeweb',  '~> 1.3'
+  s.add_development_dependency 'rspec',    '~> 2.11'
+  s.add_development_dependency 'rake',     '~> 0.9'
+  s.add_development_dependency 'kramdown'
+end
+

data/lib/gista.rb

@@ -0,0 +1,53 @@
+require 'gista/version'
+require 'gista/api_request'
+require 'gista/token_request'
+require 'gista/gist_request'
+require 'gista/login_prompt'
+require 'gista/user_token'
+require 'gista/options'
+
+# Gista allows for easily creating Gists from the command line or a Ruby
+# program. For full instructions on how to use it from the command line, run
+# `gista --help`.
+#
+# @example From the command line, listing filenames
+#   $ gista my_file.rb another_file.rb
+#   https://gist.github.com/...
+#
+# @example From the command line, reading STDIN
+#   $ rspec | gista
+#   https://gist.github.com/...
+#   $ gista < my_file.rb
+#   https://gist.github.com/...
+#
+# @example From a Ruby program
+#   require 'gista'
+#   Gista.post_and_get_url(oauth_token, options)
+#
+module Gista
+  # Exception raised when trying to do stuff on Github that you are not
+  # authorized for.
+  class Unauthorized < StandardError
+    def initialize(*args)
+      super "Authorization with Github failed. Please remove your token file and try again to re-authenticate.", *args
+    end
+  end
+
+  # Exception raised when the request does not respond as we expected.
+  class RequestError < StandardError
+    def initialize(*args)
+      super *args.unshift("Github responded with #{args.shift}")
+    end
+  end
+
+  module_function
+
+  # Make a request to the Github API using the given authorization token
+  # and options. Returns the URL to the Gist if it was successful.
+  #
+  # @param token <String>
+  # @param options <Hash>
+  def post_and_get_url(token, options)
+    GistRequest.new(token, options).fetch('html_url')
+  end
+end

data/lib/gista/api_request.rb

@@ -0,0 +1,62 @@
+require 'net/http'
+require 'json'
+require 'cgi'
+
+module Gista
+  # Base class for JSON requests to the Github API. ApiRequest knows how to send
+  # a request with a JSON body and parse the results. Use `fetch` to read values
+  # from the JSON response.
+  #
+  # Raises an exception when not authorized or when the API request responds
+  # with something other than an OK.
+  class ApiRequest
+    URL          = 'api.github.com'
+    PORT         = 443
+    OPEN_TIMEOUT = 10
+    READ_TIMEOUT = 10
+    CONTENT_TYPE = 'application/json'
+
+    # Read a key from the response.
+    def fetch(key)
+      result.fetch(key)
+    end
+
+    private
+
+    def make_post(options = {})
+      Net::HTTP::Post.new(path).tap do |request|
+        request.content_type = CONTENT_TYPE
+        request.body = JSON.dump(options)
+        yield request if block_given?
+        request
+      end
+    end
+
+    def connection
+      @connection ||= Net::HTTP.new(URL, PORT).tap do |connection|
+        connection.use_ssl      = true
+        connection.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+        connection.open_timeout = OPEN_TIMEOUT
+        connection.read_timeout = READ_TIMEOUT
+      end
+    end
+
+    def result
+      @result ||= JSON.parse(response.body)
+    end
+
+    def response
+      @response ||= begin
+        connection.start { |http| http.request(request) }.tap do |r|
+          if Net::HTTPUnauthorized === r
+            raise Unauthorized
+          elsif not Net::HTTPCreated === r
+            raise RequestError, r.class
+          end
+        end
+      rescue Timeout::Error
+        raise 'Could not connect to Github API'
+      end
+    end
+  end
+end

data/lib/gista/gist_request.rb

@@ -0,0 +1,43 @@
+module Gista
+  # Special Github API request to create a new gist. It requires an OAuth token
+  # for authorization, and options for what file to post.
+  #
+  # See the API docs for what options are expected to create a new Gist.
+  #
+  # @example Creating a Gist
+  #   GistRequest.new('acc829df', {
+  #     public: false,
+  #     files: {
+  #       file1: { content: 'my content' }
+  #     }
+  #   }).fetch('html_url')
+  #   # => "http://gist.github.com/fbed697547047a733434"
+  #
+  # @see http://developer.github.com/v3/gists/#create-a-gist
+  class GistRequest < ApiRequest
+    # Authorization token to authorize with Github.
+    #
+    # @see http://developer.github.com/v3/oauth/#scopes
+    # @see Gista::TokenRequest
+    # @return [String]
+    attr_reader :token
+
+    # Options containing information about files, filenames and visibility
+    # @return [Hash]
+    attr_reader :options
+
+    def initialize(token, options = {})
+      @token, @options = token, options
+    end
+
+    private
+
+    def request
+      make_post(options)
+    end
+
+    def path
+      "/gists?access_token=#{CGI.escape(token)}"
+    end
+  end
+end

data/lib/gista/login_prompt.rb

@@ -0,0 +1,55 @@
+module Gista
+  # Create an object that responds to `username` and `password` messages by
+  # prompting the user on the command line. Helpful when creating a
+  # command-line client. When using as a library, simply substitute with a
+  # `Struct` or something similar.
+  #
+  # @example Asking the user for username and password
+  #   lp = LoginPrompt.new
+  #   lp.username
+  #   # ... prompt for username and password...
+  #   # => "username"
+  #   lp.password
+  #   # => "password"
+  #
+  class LoginPrompt
+    def initialize
+      @username = nil
+      @password = nil
+    end
+
+    # Return the username if set, or prompt the user to enter both his username
+    # and password.
+    #
+    # @return [String]
+    def username
+      prompt unless @username
+      @username
+    end
+
+    # Return the password if set, or prompt the user to enter both his username
+    # and password.
+    #
+    # @return [String]
+    def password
+      prompt unless @password
+      @password
+    end
+
+    private
+
+    def prompt
+      $stdout.puts 'Please authenticate with your Github credentials:'
+      $stdout.print 'Username: '
+      @username = $stdin.gets.strip
+      $stdout.print 'Password: '
+      @password = begin
+        `stty -echo` rescue nil
+        $stdin.gets.strip
+      ensure
+        `stty echo` rescue nil
+      end
+      $stdout.puts ''
+    end
+  end
+end

data/lib/gista/options.rb

@@ -0,0 +1,76 @@
+require 'optparse'
+
+module Gista
+  # Parse options given on the command line into an options hash suitable for a
+  # `GistRequest` object.
+  #
+  # This provides the default options:
+  #
+  # * Gists are private by default
+  # * When reading from `STDIN`, the file is titled 'untitled'
+  #
+  # When any options are left after parsing all the flags, they are treated as
+  # filenames. They will be added to the options as files in the Gist. When no
+  # arguments are left, input is read from `STDIN` and its contents will be
+  # added to the options hash as a single file.
+  #
+  # This also provides the `--help` and `--version` options for the
+  # command-line client.
+  class Options
+    # Command line options, flags and filenames
+    #
+    # @return [Array]
+    attr_reader :args
+
+    def initialize(args)
+      @args = args
+      @options = { public: false }
+      @stdin_filename = 'untitled'
+    end
+
+    # @return [Hash]
+    def options
+      parse_options
+      parse_files
+      @options
+    end
+
+    private
+
+    def parse_files
+      if args.any?
+        @options[:files] = args.inject({}) do |acc, filename|
+          acc.merge File.basename(filename) => { content: File.read(filename) }
+        end
+      else
+        @options[:files] = {
+          @stdin_filename => { content: $stdin.read }
+        }
+      end
+    end
+
+    def parse_options
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: gista [options] [file..]'
+        opts.separator ''
+        opts.separator 'Gist options:'
+        opts.on('-p', '--[no-]public', 'Create a public gist') do |v|
+          @options[:public] = v
+        end
+        opts.on('-f', '--filename [FILENAME]', 'Specify filename to use when reading from STDIN') do |f|
+          @stdin_filename = f
+        end
+        opts.separator ''
+        opts.separator 'Generic options:'
+        opts.on_tail('-h', '--help', 'Show brief usage information') do
+          puts opts
+          exit
+        end
+        opts.on_tail('-v', '--version', 'Show version information') do
+          puts VERSION
+          exit
+        end
+      end.parse!(args)
+    end
+  end
+end

data/lib/gista/token_request.rb

@@ -0,0 +1,39 @@
+module Gista
+  # Request to the Github API to authorize with a username and password and
+  # acquire an OAuth token, which can be stored and re-used for password-less
+  # authorization.
+  #
+  # @example Request a token
+  #   credentials = OpenStruct.new(username: 'foo', password: 'bar')
+  #   TokenRequest.new(credentials).fetch('token')
+  #
+  # @see http://developer.github.com/v3/oauth/#scopes
+  class TokenRequest < ApiRequest
+    # An object that contains a username and password
+    #
+    # @see LoginPrompt
+    # @return [#username, #password]
+    attr_reader :credentials
+
+    def initialize(credentials)
+      @credentials = credentials
+    end
+
+    private
+
+    def path
+      '/authorizations'
+    end
+
+    def request
+      options = {
+        scopes:   [:gist],
+        note:     'Gista gem',
+        note_url: 'http://avdgaag.github.com'
+      }
+      make_post(options) do |request|
+        request.basic_auth(credentials.username, credentials.password)
+      end
+    end
+  end
+end

data/lib/gista/user_token.rb

@@ -0,0 +1,56 @@
+module Gista
+  # Acquire and store an OAuth authorization token in the user's home directory.
+  #
+  # @see TokenRequest
+  class UserToken
+
+    # Default path to file to store the token in
+    #
+    # @return [String]
+    DEFAULT_CONFIG_FILE = File.expand_path('~/.gista')
+
+    # @return [#fetch] any object that returns the token to use
+    # when calling `fetch('token')`.
+    attr_reader :authoriser
+
+    def initialize(authoriser, token_file = nil)
+      @authoriser, @token_file = authoriser, token_file
+    end
+
+    # Return the user token. Either read it from disk, or request a new token
+    # with the Github API using the credentials from `creds`.
+    #
+    # @return [String]
+    def token
+      return read_from_config_file if has_config_file?
+      request_token.tap do |token|
+        write_to_config_file(token)
+      end
+    end
+
+    # @return [String] path to file containing a re-usable token
+    def token_file
+      @token_file || DEFAULT_CONFIG_FILE
+    end
+
+    private
+
+    def request_token
+      authoriser.fetch('token')
+    end
+
+    def write_to_config_file(content)
+      File.open(token_file, 'w') do |f|
+        f.write content
+      end
+    end
+
+    def read_from_config_file
+      File.read(token_file).chomp
+    end
+
+    def has_config_file?
+      File.exist?(token_file)
+    end
+  end
+end

data/lib/gista/version.rb

@@ -0,0 +1,3 @@
+module Gista
+  VERSION = '1.0.0'
+end

data/spec/gista/gist_request_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Gista::GistRequest do
+  let(:subject) { described_class.new('token') }
+  let(:url)     { 'https://api.github.com/gists?access_token=token' }
+  it_should_behave_like 'API request'
+end

data/spec/gista/login_prompt_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Gista::LoginPrompt do
+  let(:output) { StringIO.new }
+  let(:input)  { StringIO.new("username\npassword\n") }
+
+  before do
+    $stdout = output
+    $stdin  = input
+  end
+
+  after do
+    $stdout = STDOUT
+    $stdin  = STDIN
+  end
+
+  it 'should ask for username and password' do
+    subject.username
+    output.string.should include('Please authenticate with your Github credentials:')
+    output.string.should include('Username: ')
+    output.string.should include('Password: ')
+  end
+
+  its(:username) { should == 'username' }
+  its(:password) { should == 'password' }
+end

data/spec/gista/options_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Gista::Options do
+  let(:input)   { StringIO.new('input') }
+  let(:subject) { described_class.new(args).options }
+
+  before { $stdin = input }
+
+  context 'without options' do
+    let(:args)     { [] }
+    its([:public]) { should be_false }
+  end
+
+  context 'with public switch' do
+    let(:args)     { ['-p'] }
+    its([:public]) { should be_true }
+  end
+
+  context 'with filenames that exist' do
+    let(:args)    { ['/tmp/gista_file1', '/tmp/gista_file2'] }
+
+    before do
+      args.each_with_index do |filename, i|
+        File.open(filename, 'w') { |f| f.write "gista example #{i}" }
+      end
+    end
+
+    after do
+      args.each { |filename| File.unlink(filename) if File.exists?(filename) }
+    end
+
+    its([:files]) do
+      should == {
+        'gista_file1' => { content: 'gista example 0' },
+        'gista_file2' => { content: 'gista example 1' }
+      }
+    end
+  end
+
+  context 'with filenames that do not exist' do
+    let(:args) { ['foo'] }
+
+    it 'should raise exception' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'reading content from STDIN with default filename' do
+    let(:args)    { ['-f', 'bla'] }
+    its([:files]) { should == { 'bla' => { content: 'input' } } }
+  end
+
+  context 'reading content from STDIN with default filename' do
+    let(:args)    { [] }
+    its([:files]) { should == { 'untitled' => { content: 'input' } } }
+  end
+end

data/spec/gista/token_request_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Gista::TokenRequest do
+  let(:credentials) { double('credentials', username: 'username', password: 'password') }
+  let(:url)         { 'https://username:password@api.github.com/authorizations' }
+  let(:subject)     { described_class.new(credentials) }
+  it_should_behave_like 'API request'
+end

data/spec/gista/user_token_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Gista::UserToken do
+  let(:token_file) { '/tmp/gista_token' }
+  let(:authoriser) { double('auth', fetch: 'token') }
+  let(:subject)    { described_class.new authoriser, token_file }
+
+  after do
+    File.unlink(token_file) if File.exist?(token_file)
+  end
+
+  context 'when the token file exists' do
+    before do
+      File.open(token_file, 'w') { |f| f.write 'foo' }
+    end
+
+    its(:token) { should == 'foo' }
+  end
+
+  context 'when the token file does not exist' do
+    it 'writes token to file' do
+      File.exist?(token_file).should be_false
+      subject.token
+      File.exist?(token_file).should be_true
+      File.read(token_file).should == 'token'
+    end
+
+    its(:token) { should == 'token' }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.require :development
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gista'
+require File.expand_path('../support/api_request_examples', __FILE__)
+
+RSpec.configure do |config|
+  config.before do
+    FakeWeb.allow_net_connect = false
+  end
+end

data/spec/support/api_request_examples.rb

@@ -0,0 +1,38 @@
+shared_examples_for 'API request' do
+  before do
+    FakeWeb.register_uri(:post, url, options)
+  end
+
+  context 'when successful' do
+    let(:options) do
+      { body:         '{"foo":"bar"}',
+        content_type: 'application/json',
+        status:       [201, 'Created'] }
+    end
+
+    it 'should request json at Github' do
+      subject.fetch('foo')
+      FakeWeb.last_request.content_type.should == 'application/json'
+    end
+
+    it 'should parse the body as JSON' do
+      subject.fetch('foo').should == 'bar'
+    end
+  end
+
+  context 'when not OK' do
+    let(:options) { { body: '', status: [301, 'Redirect'] } }
+
+    it 'should raise' do
+      expect { subject.fetch('foo') }.to raise_error(Gista::RequestError)
+    end
+  end
+
+  context 'when not authorized' do
+    let(:options) { { body: '', status: [401, 'Not authorized'] } }
+
+    it 'should raise' do
+      expect { subject.fetch('foo') }.to raise_error(Gista::Unauthorized)
+    end
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: gista
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Arjan van der Gaag
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: create gists from the command line
+email: arjan@arjanvandergaag.nl
+executables:
+- gista
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- HISTORY.md
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- .yardopts
+- Gemfile
+- Gemfile.lock
+- HISTORY.md
+- LICENSE
+- README.md
+- Rakefile
+- bin/gista
+- gista.gemspec
+- lib/gista.rb
+- lib/gista/api_request.rb
+- lib/gista/gist_request.rb
+- lib/gista/login_prompt.rb
+- lib/gista/options.rb
+- lib/gista/token_request.rb
+- lib/gista/user_token.rb
+- lib/gista/version.rb
+- spec/gista/gist_request_spec.rb
+- spec/gista/login_prompt_spec.rb
+- spec/gista/options_spec.rb
+- spec/gista/token_request_spec.rb
+- spec/gista/user_token_spec.rb
+- spec/spec_helper.rb
+- spec/support/api_request_examples.rb
+homepage: http://avdgaag.github.com/gista
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3780918806351321672
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3780918806351321672
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Gista is a very simple command-line program and Ruby library for creating
+  Gists. As a stand-alone program, it can create a new gist from files listed as arguments,
+  or by reading from STDIN.
+test_files:
+- spec/gista/gist_request_spec.rb
+- spec/gista/login_prompt_spec.rb
+- spec/gista/options_spec.rb
+- spec/gista/token_request_spec.rb
+- spec/gista/user_token_spec.rb
+- spec/spec_helper.rb
+- spec/support/api_request_examples.rb
+has_rdoc: