gist

#!/usr/bin/env ruby

require 'optparse'
require File.expand_path('../../lib/gist', __FILE__)

# For the holdings of options.
options = {}
filenames = []

opts = OptionParser.new do |opts|
  executable_name = File.split($0)[1]
  opts.banner = <<-EOS
Gist (v#{Gist::VERSION}) lets you upload to https://gist.github.com/

The content to be uploaded can be passed as a list of files, if none are
specified STDIN will be read. The default filename for STDIN is "a.rb", and all
filenames can be overridden by repeating the "-f" flag. The most useful reason
to do this is to change the syntax highlighting.

If you'd like your gists to be associated with your GitHub account, so that you
can edit them and find them in future, first use `gist --login` to obtain an
Oauth2 access token. This is stored and used by gist in the future.

Public gists have guessable URLs and can be created with "-p", you can also set
the description at the top of the gist by passing "-d".

Anonymous gists are not associated with your GitHub account, they can be created
with "-a" even after you have used "gist --login".

If you would like to shorten the resulting gist URL, use the -s flag. This will
use GitHub's URL shortener, git.io.

To copy the resulting URL to your clipboard you can use the -c option, or to just
open it directly in your browser, use -o. Using the -e option will copy the embeddable
URL to the clipboard. You can add `alias gist='gist -c'` to your shell's rc file to configure this
behaviour by default.

Instead of creating a new gist, you can update an existing one by passing its ID
or URL with "-u". For this to work, you must be logged in, and have created the
original gist with the same GitHub account.

Usage: #{executable_name} [-o|-c|-e] [-p] [-s] [-d DESC] -a] [-u URL] [-P] [-f NAME|-t EXT]* FILE*
       #{executable_name} --login

  EOS

  opts.on("--login", "Authenticate gist on this computer.") do
    Gist.login!
    exit
  end

  opts.on("-f", "--filename [NAME.EXTENSION]", "Sets the filename and syntax type.") do |filename|
    filenames << filename
    options[:filename] = filename
  end

  opts.on("-t", "--type [EXTENSION]", "Sets the file extension and syntax type.") do |extension|
    filenames << "foo.#{extension}"
    options[:filename] = "foo.#{extension}"
  end

  opts.on("-p", "--public", "Makes your gist public.") do |public|
    options[:public] = public
  end

  opts.on("-d", "--description DESCRIPTION", "Adds a description to your gist.") do |description|
    options[:description] = description
  end

  opts.on("-s", "--shorten", "Shorten the gist URL using git.io.") do |shorten|
    options[:shorten] = shorten
  end

  opts.on("-u", "--update [ URL | ID ]", "Update an existing gist.") do |update|
    options[:update] = update
  end

  opts.on("-a", "--anonymous", "Create an anonymous gist.") do
    options[:anonymous] = true
  end

  opts.on("-c", "--copy", "Copy the resulting URL to the clipboard") do
    options[:copy] = true
  end

  opts.on("-e", "--embed", "Copy the embed code for the gist to the clipboard") do
    options[:embed] = true
    options[:copy] = true
  end

  opts.on("-o", "--open", "Open the resulting URL in a browser") do
    options[:open] = true
  end

  opts.on("-P", "--paste", "Paste from the clipboard to gist") do
    options[:paste] = true
  end

  opts.on_tail("-h","--help", "Show this message.") do
    puts opts
    exit
  end

  opts.on_tail("-v", "--version", "Print the version.") do
    puts "gist v#{Gist::VERSION}"
    exit
  end

end
opts.parse!

begin
  options[:output] = if options[:embed] && options[:shorten]
                       raise Gist::Error, "--embed does not make sense with --shorten"
                     elsif options[:embed]
                       :javascript
                     elsif options[:shorten]
                       :short_url
                     else
                       :html_url
                     end

  if options[:paste]
    puts Gist.gist(Gist.paste, options)
  elsif ARGV.size == 0
    $stderr.puts "(type a gist. <ctrl-c> to cancel, <ctrl-d> when done)" if $stdin.tty?
    puts Gist.gist(ARGF.read, options)
  else
    files = {}
    ARGV.zip(filenames).each do |(file, name)|
      files[name || file] = begin
        File.read(File.expand_path(file))
      rescue => e
        raise e.extend(Gist::Error)
      end
    end

    puts Gist.multi_gist(files, options)
  end
rescue Gist::Error => e
  puts "Error: #{e.message}"
  exit 1
rescue Interrupt
  # bye!
end