gist 3.0.2 → 4.0.0

data/lib/gist.rb

@@ -1,301 +1,359 @@
-require 'open-uri'
 require 'net/https'
-require 'optparse'
-
-require 'rubygems'
+require 'cgi'
 require 'json'
-require 'base64'
-
-require 'gist/manpage' unless defined?(Gist::Manpage)
-require 'gist/version' unless defined?(Gist::Version)
-
-# You can use this class from other scripts with the greatest of
-# ease.
-#
-#   >> Gist.read(gist_id)
-#   Returns the body of gist_id as a string.
-#
-#   >> Gist.write(content)
-#   Creates a gist from the string `content`. Returns the URL of the
-#   new gist.
-#
-#   >> Gist.copy(string)
-#   Copies string to the clipboard.
-#
-#   >> Gist.browse(url)
-#   Opens URL in your default browser.
+require 'uri'
+
+# It just gists.
 module Gist
   extend self
 
-  GIST_URL   = 'https://api.github.com/gists/%s'
-  CREATE_URL = 'https://api.github.com/gists'
-
-  if ENV['HTTPS_PROXY']
-    PROXY = URI(ENV['HTTPS_PROXY'])
-  elsif ENV['HTTP_PROXY']
-    PROXY = URI(ENV['HTTP_PROXY'])
-  else
-    PROXY = nil
-  end
-  PROXY_HOST = PROXY ? PROXY.host : nil
-  PROXY_PORT = PROXY ? PROXY.port : nil
-
-  # Parses command line arguments and does what needs to be done.
-  def execute(*args)
-    private_gist = defaults["private"]
-    gist_filename = nil
-    gist_extension = defaults["extension"]
-    browse_enabled = defaults["browse"]
-    description = nil
-
-    opts = OptionParser.new do |opts|
-      opts.banner = "Usage: gist [options] [filename or stdin] [filename] ...\n" +
-        "Filename '-' forces gist to read from stdin."
-
-      opts.on('-p', '--[no-]private', 'Make the gist private') do |priv|
-        private_gist = priv
-      end
+  VERSION = '4.0.0'
 
-      t_desc = 'Set syntax highlighting of the Gist by file extension'
-      opts.on('-t', '--type [EXTENSION]', t_desc) do |extension|
-        gist_extension = '.' + extension
-      end
+  # A list of clipboard commands with copy and paste support.
+  CLIPBOARD_COMMANDS = {
+    'xclip'   => 'xclip -o',
+    'xsel'    => 'xsel -o',
+    'pbcopy'  => 'pbpaste',
+    'putclip' => 'getclip'
+  }
 
-      opts.on('-d','--description DESCRIPTION', 'Set description of the new gist') do |d|
-        description = d
-      end
+  GITHUB_API_URL   = URI("https://api.github.com/")
+  GIT_IO_URL       = URI("http://git.io")
 
-      opts.on('-o','--[no-]open', 'Open gist in browser') do |o|
-        browse_enabled = o
-      end
+  GITHUB_BASE_PATH = ""
+  GHE_BASE_PATH    = "/api/v3"
 
-      opts.on('-m', '--man', 'Print manual') do
-        Gist::Manpage.display("gist")
-      end
+  URL_ENV_NAME     = "GITHUB_URL"
 
-      opts.on('-v', '--version', 'Print version') do
-        puts Gist::Version
-        exit
-      end
+  USER_AGENT       = "gist/#{VERSION} (Net::HTTP, #{RUBY_DESCRIPTION})"
 
-      opts.on('-h', '--help', 'Display this screen') do
-        puts opts
-        exit
-      end
+  # Exception tag for errors raised while gisting.
+  module Error;
+    def self.exception(*args)
+      RuntimeError.new(*args).extend(self)
     end
+  end
+  class ClipboardError < RuntimeError; include Error end
 
-    begin
+  # Upload a gist to https://gist.github.com
+  #
+  # @param [String] content  the code you'd like to gist
+  # @param [Hash] options  more detailed options, see
+  #   the documentation for {multi_gist}
+  #
+  # @see http://developer.github.com/v3/gists/
+  def gist(content, options = {})
+    filename = options[:filename] || "a.rb"
+    multi_gist({filename => content}, options)
+  end
 
-      opts.parse!(args)
+  # Upload a gist to https://gist.github.com
+  #
+  # @param [Hash] files  the code you'd like to gist: filename => content
+  # @param [Hash] options  more detailed options
+  #
+  # @option options [String] :description  the description
+  # @option options [Boolean] :public  (false) is this gist public
+  # @option options [Boolean] :anonymous  (false) is this gist anonymous
+  # @option options [String] :access_token  (`File.read("~/.gist")`) The OAuth2 access token.
+  # @option options [String] :update  the URL or id of a gist to update
+  # @option options [Boolean] :copy  (false) Copy resulting URL to clipboard, if successful.
+  # @option options [Boolean] :open  (false) Open the resulting URL in a browser.
+  # @option options [Symbol] :output (:all) The type of return value you'd like:
+  #   :html_url gives a String containing the url to the gist in a browser
+  #   :short_url gives a String contianing a  git.io url that redirects to html_url
+  #   :javascript gives a String containing a script tag suitable for embedding the gist
+  #   :all gives a Hash containing the parsed json response from the server
+  #
+  # @return [String, Hash]  the return value as configured by options[:output]
+  # @raise [Gist::Error]  if something went wrong
+  #
+  # @see http://developer.github.com/v3/gists/
+  def multi_gist(files, options={})
+    json = {}
 
-      if $stdin.tty? && args[0] != '-'
-        # Run without stdin.
+    json[:description] = options[:description] if options[:description]
+    json[:public] = !!options[:public]
+    json[:files] = {}
+
+    files.each_pair do |(name, content)|
+      raise "Cannot gist empty files" if content.to_s.strip == ""
+      json[:files][File.basename(name)] = {:content => content}
+    end
+
+    existing_gist = options[:update].to_s.split("/").last
+    if options[:anonymous]
+      access_token = nil
+    else
+      access_token = (options[:access_token] || File.read(auth_token_file) rescue nil)
+    end
 
-        if args.empty?
-          # No args, print help.
-          puts opts
-          exit
-        end
+    url = "#{base_path}/gists"
+    url << "/" << CGI.escape(existing_gist) if existing_gist.to_s != ''
+    url << "?access_token=" << CGI.escape(access_token) if access_token.to_s != ''
 
-        files = args.inject([]) do |files, file|
-          # Check if arg is a file. If so, grab the content.
-          abort "Can't find #{file}" unless File.exists?(file)
+    request = Net::HTTP::Post.new(url)
+    request.body = JSON.dump(json)
+    request.content_type = 'application/json'
 
-          files.push({
-            :input     => File.read(file),
-            :filename  => file,
-            :extension => (File.extname(file) if file.include?('.'))
-          })
-        end
+    retried = false
 
+    begin
+      response = http(api_url, request)
+      if Net::HTTPSuccess === response
+        on_success(response.body, options)
       else
-        # Read from standard input.
-        input = $stdin.read
-        files = [{:input => input, :extension => gist_extension}]
+        raise "Got #{response.class} from gist: #{response.body}"
       end
-
-      url = write(files, private_gist, description)
-      browse(url) if browse_enabled
-      puts copy(url)
     rescue => e
-      warn e
-      puts opts
+      raise if retried
+      retried = true
+      retry
     end
-  end
 
-  # Create a gist on gist.github.com
-  def write(files, private_gist = false, description = nil)
-    url = URI.parse(CREATE_URL)
+  rescue => e
+    raise e.extend Error
+  end
 
-    if PROXY_HOST
-      proxy = Net::HTTP::Proxy(PROXY_HOST, PROXY_PORT)
-      http  = proxy.new(url.host, url.port)
+  # Convert long github urls into short git.io ones
+  #
+  # @param [String] url
+  # @return [String] shortened url, or long url if shortening fails
+  def shorten(url)
+    request = Net::HTTP::Post.new("/")
+    request.set_form_data(:url => url)
+    response = http(GIT_IO_URL, request)
+    case response.code
+    when "201"
+      response['Location']
     else
-      http = Net::HTTP.new(url.host, url.port)
+      url
     end
+  end
 
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    http.ca_file = ca_cert
-
-    req = Net::HTTP::Post.new(url.path)
-    req.body = JSON.generate(data(files, private_gist, description))
-
-    user, password = auth()
-    if user && password
-      req.basic_auth(user, password)
+  # Log the user into gist.
+  #
+  # This method asks the user for a username and password, and tries to obtain
+  # and OAuth2 access token, which is then stored in ~/.gist
+  #
+  # @raise [Gist::Error]  if something went wrong
+  # @see http://developer.github.com/v3/oauth/
+  def login!
+    puts "Obtaining OAuth2 access_token from github."
+    print "GitHub username: "
+    username = $stdin.gets.strip
+    print "GitHub password: "
+    password = begin
+      `stty -echo` rescue nil
+      $stdin.gets.strip
+    ensure
+      `stty echo` rescue nil
     end
-
-    response = http.start{|h| h.request(req) }
-    case response
-    when Net::HTTPCreated
-      JSON.parse(response.body)['html_url']
+    puts ""
+
+    request = Net::HTTP::Post.new("#{base_path}/authorizations")
+    request.body = JSON.dump({
+      :scopes => [:gist],
+      :note => "The gist gem",
+      :note_url => "https://github.com/ConradIrwin/gist"
+    })
+    request.content_type = 'application/json'
+    request.basic_auth(username, password)
+
+    response = http(api_url, request)
+
+    if Net::HTTPCreated === response
+      File.open(auth_token_file, 'w') do |f|
+        f.write JSON.parse(response.body)['token']
+      end
+      puts "Success! #{ENV[URL_ENV_NAME] || "https://github.com/"}settings/applications"
     else
-      puts "Creating gist failed: #{response.code} #{response.message}"
-      exit(false)
+      raise "Got #{response.class} from gist: #{response.body}"
     end
+  rescue => e
+    raise e.extend Error
   end
 
-  # Given a gist id, returns its content.
-  def read(gist_id)
-    data = JSON.parse(open(GIST_URL % gist_id).read)
-    data["files"].map{|name, content| content['content'] }.join("\n\n")
+  # Return HTTP connection
+  #
+  # @param [URI::HTTP] The URI to which to connect
+  # @return [Net::HTTP]
+  def http_connection(uri)
+    env = ENV['http_proxy'] || ENV['HTTP_PROXY']
+    connection = if env
+                   proxy = URI(env)
+                   Net::HTTP::Proxy(proxy.host, proxy.port).new(uri.host, uri.port)
+                 else
+                   Net::HTTP.new(uri.host, uri.port)
+                 end
+    if uri.scheme == "https"
+      connection.use_ssl = true
+      connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    connection.open_timeout = 10
+    connection.read_timeout = 10
+    connection
   end
 
-  # Given a url, tries to open it in your browser.
-  # TODO: Linux
-  def browse(url)
-    if RUBY_PLATFORM =~ /darwin/
-      `open #{url}`
-    elsif RUBY_PLATFORM =~ /linux/
-       `#{ENV['BROWSER']} #{url}`
-    elsif ENV['OS'] == 'Windows_NT' or
-      RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw|wince/i
-      `start "" "#{url}"`
+  # Run an HTTP operation
+  #
+  # @param [URI::HTTP] The URI to which to connect
+  # @param [Net::HTTPRequest] The request to make
+  # @return [Net::HTTPResponse]
+  def http(url, request)
+    request['User-Agent'] = USER_AGENT
+
+    http_connection(url).start do |http|
+      http.request request
     end
+  rescue Timeout::Error
+    raise "Could not connect to #{api_url}"
   end
 
-  # Tries to copy passed content to the clipboard.
+  # Called after an HTTP response to gist to perform post-processing.
+  #
+  # @param [String] body  the text body from the github api
+  # @param [Hash] options  more detailed options, see
+  #   the documentation for {multi_gist}
+  def on_success(body, options={})
+    json = JSON.parse(body)
+
+    output = case options[:output]
+             when :javascript
+               %Q{<script src="#{json['html_url']}.js"></script>}
+             when :html_url
+               json['html_url']
+             when :short_url
+               shorten(json['html_url'])
+             else
+               json
+             end
+
+    Gist.copy(output.to_s) if options[:copy]
+    Gist.open(json['html_url']) if options[:open]
+
+    output
+  end
+
+  # Copy a string to the clipboard.
+  #
+  # @param [String] content
+  # @raise [Gist::Error] if no clipboard integration could be found
+  #
   def copy(content)
-    cmd = case true
-    when system("type pbcopy > /dev/null 2>&1")
-      :pbcopy
-    when system("type xclip > /dev/null 2>&1")
-      :xclip
-    when system("type putclip > /dev/null 2>&1")
-      :putclip
-    end
+    IO.popen(clipboard_command(:copy), 'r+') { |clip| clip.print content }
 
-    if cmd
-      IO.popen(cmd.to_s, 'r+') { |clip| clip.print content }
-    end
+    unless paste == content
+      message = 'Copying to clipboard failed.'
 
-    content
-  end
+      if ENV["TMUX"] && clipboard_command(:copy) == 'pbcopy'
+        message << "\nIf you're running tmux on a mac, try http://robots.thoughtbot.com/post/19398560514/how-to-copy-and-paste-with-tmux-on-mac-os-x"
+      end
 
-private
-  # Give an array of file information and private boolean, returns
-  # an appropriate payload for POSTing to gist.github.com
-  def data(files, private_gist, description)
-    i = 0
-    file_data = {}
-    files.each do |file|
-      i = i + 1
-      filename = file[:filename] ? file[:filename] : "gistfile#{i}"
-      file_data[filename] = {:content => file[:input]}
+      raise Error, message
     end
-
-    data = {"files" => file_data}
-    data.merge!({ 'description' => description }) unless description.nil?
-    data.merge!({ 'public' => !private_gist })
-    data
+  rescue Error => e
+    raise ClipboardError, e.message + "\nAttempted to copy: #{content}"
   end
 
-  # Returns a basic auth string of the user's GitHub credentials if set.
-  # http://github.com/guides/local-github-config
+  # Get a string from the clipboard.
   #
-  # Returns an Array of Strings if auth is found: [user, password]
-  # Returns nil if no auth is found.
-  def auth
-    user  = config("github.user")
-    password = config("github.password")
-
-    token = config("github.token")
-    if password.to_s.empty? && !token.to_s.empty?
-      abort "Please set GITHUB_PASSWORD or github.password instead of using a token."
-    end
+  # @param [String] content
+  # @raise [Gist::Error] if no clipboard integration could be found
+  def paste
+    `#{clipboard_command(:paste)}`
+  end
 
-    if user.to_s.empty? || password.to_s.empty?
+  # Find command from PATH environment.
+  #
+  # @param [String] cmd  command name to find
+  # @param [String] options  PATH environment variable
+  # @return [String]  the command found
+  def which(cmd, path=ENV['PATH'])
+    if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin|cygwin/
+      path.split(File::PATH_SEPARATOR).each {|dir|
+        f = File.join(dir, cmd+".exe")
+        return f if File.executable?(f) && !File.directory?(f)
+      }
       nil
     else
-      [ user, password ]
+      return system("which #{cmd} > /dev/null 2>&1")
     end
   end
 
-  # Returns default values based on settings in your gitconfig. See
-  # git-config(1) for more information.
-  #
-  # Settings applicable to gist.rb are:
+  # Get the command to use for the clipboard action.
   #
-  # gist.private - boolean
-  # gist.extension - string
-  def defaults
-    extension = config("gist.extension")
-
-    return {
-      "private"   => config("gist.private"),
-      "browse"    => config("gist.browse"),
-      "extension" => extension
-    }
+  # @param [Symbol] action  either :copy or :paste
+  # @return [String]  the command to run
+  # @raise [Gist::ClipboardError] if no clipboard integration could be found
+  def clipboard_command(action)
+    command = CLIPBOARD_COMMANDS.keys.detect do |cmd|
+      which cmd
+    end
+    raise ClipboardError, <<-EOT unless command
+Could not find copy command, tried:
+    #{CLIPBOARD_COMMANDS.values.join(' || ')}
+    EOT
+    action == :copy ? command : CLIPBOARD_COMMANDS[command]
   end
 
-  # Reads a config value using:
-  # => Environment: GITHUB_PASSWORD, GITHUB_USER
-  #                 like vim gist plugin
-  # => git-config(1)
+  # Open a URL in a browser.
+  #
+  # @param [String] url
+  # @raise [RuntimeError] if no browser integration could be found
   #
-  # return something useful or nil
-  def config(key)
-    env_key = ENV[key.upcase.gsub(/\./, '_')]
-    return env_key if env_key and not env_key.strip.empty?
+  # This method was heavily inspired by defunkt's Gist#open,
+  # @see https://github.com/defunkt/gist/blob/bca9b29/lib/gist.rb#L157
+  def open(url)
+    command = if ENV['BROWSER']
+                ENV['BROWSER']
+              elsif RUBY_PLATFORM =~ /darwin/
+                'open'
+              elsif RUBY_PLATFORM =~ /linux/
+                %w(
+                  sensible-browser
+                  firefox
+                  firefox-bin
+                ).detect do |cmd|
+                  which cmd
+                end
+              elsif ENV['OS'] == 'Windows_NT' || RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw|wince/i
+                'start ""'
+              else
+                raise "Could not work out how to use a browser."
+              end
+
+    `#{command} #{url}`
+  end
 
-    str_to_bool `git config --global #{key}`.strip
+  # Get the API base path
+  def base_path
+    ENV.key?(URL_ENV_NAME) ? GHE_BASE_PATH : GITHUB_BASE_PATH
   end
 
-  # Parses a value that might appear in a .gitconfig file into
-  # something useful in a Ruby script.
-  def str_to_bool(str)
-    if str.size > 0 and str[0].chr == '!'
-      command = str[1, str.length]
-      value = `#{command}`
-    else
-      value = str
-    end
+  # Get the API URL
+  def api_url
+    ENV.key?(URL_ENV_NAME) ? URI(ENV[URL_ENV_NAME]) : GITHUB_API_URL
+  end
 
-    case value.downcase.strip
-    when "false", "0", "nil", "", "no", "off"
-      nil
-    when "true", "1", "yes", "on"
-      true
+  def auth_token_file
+    if ENV.key?(URL_ENV_NAME)
+      File.expand_path "~/.gist.#{ENV[URL_ENV_NAME].gsub(/[^a-z.]/, '')}"
     else
-      value
+      File.expand_path "~/.gist"
     end
   end
 
-  def ca_cert
-    cert_file = [
-      File.expand_path("../gist/cacert.pem", __FILE__),
-      "/tmp/gist_cacert.pem"
-    ].find{|l| File.exist?(l) }
+  def legacy_private_gister?
+    return unless which('git')
+    `git config --global gist.private` =~ /\Ayes|1|true|on\z/i
+  end
 
-    if cert_file
-      cert_file
+  def should_be_public?(options={})
+    if options.key? :private
+      !options[:private]
     else
-      File.open("/tmp/gist_cacert.pem", "w") do |f|
-        f.write(DATA.read.split("__CACERT__").last)
-      end
-      "/tmp/gist_cacert.pem"
+      !Gist.legacy_private_gister?
     end
   end
-
 end

data/spec/clipboard_spec.rb

@@ -0,0 +1,40 @@
+describe '...' do
+  before do
+    @saved_path = ENV['PATH']
+    @bobo_url = 'http://example.com'
+  end
+
+  after do
+    ENV['PATH'] = @saved_path
+  end
+
+  def ask_for_copy
+    Gist.on_success({'html_url' => @bobo_url}.to_json, :copy => true, :output => :html_url)
+  end
+  def gist_but_dont_ask_for_copy
+    Gist.on_success({'html_url' => 'http://example.com/'}.to_json, :output => :html_url)
+  end
+
+  it 'should try to copy the url when the clipboard option is passed' do
+    Gist.should_receive(:copy).with(@bobo_url)
+    ask_for_copy
+  end
+
+  it 'should try to copy the embed url when the clipboard-js option is passed' do
+    js_link = %Q{<script src="#{@bobo_url}.js"></script>}
+    Gist.should_receive(:copy).with(js_link)
+    Gist.on_success({'html_url' => @bobo_url}.to_json, :copy => true, :output => :javascript)
+  end
+
+  it "should not copy when not asked to" do
+    Gist.should_not_receive(:copy).with(@bobo_url)
+    gist_but_dont_ask_for_copy
+  end
+
+  it "should raise an error if no copying mechanisms are available" do
+    ENV['PATH'] = ''
+    lambda{
+      ask_for_copy
+    }.should raise_error(/Could not find copy command.*http/m)
+  end
+end