Fix codeowners

* adding basic http authentication

* updating ruby style

* SSL support, variable name corrections

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @toptal/site-acquisition-eng

.github/workflows/close-inactive.yaml

@@ -0,0 +1,30 @@
+name: Close inactive issues and PRs
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "30 1 * * *"
+
+jobs:
+  close-stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v3
+        with:
+          days-before-stale: 30
+          days-before-close: 14
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+
+          exempt-issue-labels: backlog,triage,nostale
+          exempt-pr-labels: backlog,triage,nostale
+
+          stale-pr-message: "This PR is stale because it has been open for 30 days with no activity."
+          close-pr-message: "This PR was closed because it has been inactive for 14 days since being marked as stale."
+
+          stale-issue-message: "This issue is stale because it has been open for 30 days with no activity."
+          close-issue-message: "This issue was closed because it has been inactive for 14 days since being marked as stale."
+
+          repo-token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,3 +1,5 @@
 *.swp
 *.swo
 *.gem
+Gemfile.lock
+.rspec

.travis.yml

@@ -0,0 +1,9 @@
+script: "rspec spec"
+branches:
+  only:
+    - master
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.4.0

Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

README.md

@@ -1,5 +1,7 @@
 # Haste Client
 
+[![Build Status](https://secure.travis-ci.org/seejohnrun/haste-client.png)](http://travis-ci.org/seejohnrun/haste-client)
+
 haste-client is a simple client for uploading data to haste-server.  All you do it pipe data in STDIN:
 
 `cat file | haste`
@@ -8,35 +10,103 @@ And once the output makes it to the server, it will print the URL to STDOUT.
 
 This can be really really cool in combination with `pbcopy`, like:
 
-* mac osx: `cat file | haste | pbcopy` 
+* mac osx: `cat file | haste | pbcopy`
 * linux: `cat file | haste | xsel`
 
 after which the contents of `file` will be accessible at a URL which has been copied to your pasteboard.
 
+## Installation
+
+``` bash
+gem install haste
+```
+
 ## Making uploading file contents easier
 
 If you supply a valid file path as argument #1 to the client, it will be uploaded:
 
 ``` bash
-# equivelant
+# equivalent
 cat file | haste
 haste file
 ```
 
-## Changing the location of your haste server
+## You can get the raw version
 
-By default, haste will point at `http://hastebin.com`.  You can change this by setting the value of `ENV['HASTE_SERVER']` to the URL of your haste server.  You can also use `alias` to make easy shortcuts if you commonly use a few hastes intermingled with each other.  To do that, you'd put something like this into ~.bash_profile:
+Want the raw URL returned instead? (a plain-text version)?
 
 ``` bash
-alias work_haste="HASTE_SERVER=http://something.com haste"
+cat file | haste --raw # or
+haste file --raw
+```
+
+## Changing the location of your haste server
+
+By default, haste will point at `https://hastebin.com`.  You can change this by setting the value of `ENV['HASTE_SERVER']` to the URL of your haste server.  You can also use `alias` to make easy shortcuts if you commonly use a few hastes intermingled with each other.  To do that, you'd put something like this into ~.bash_profile:
+
+``` bash
+alias work_haste="HASTE_SERVER=https://something.com haste"
 ```
 
 After which you can use `work_haste` to send hastes to that server instead.
 
+### Authentication
+
+If your haste installation requires http authentication,
+add the following to your ~.bash_profile:
+
+```bash
+export HASTE_USER="myusername"
+export HASTE_PASS="mypassword"
+```
+
+if you are using SSL, you will need to supply your certs path
+
+```bash
+export HASTE_SSL_CERTS="/System/Library/OpenSSL/certs"
+```
+
+## Use as a library
+
+You can also use `Haste` as a library to upload hastes:
+
+``` ruby
+require 'haste'
+uploader = Haste::Uploader.new
+uploader.upload_raw 'this is my data' # key
+uploader.upload_path '/tmp/whaaaa' # key
+```
+
 ## Windows Support
 
 If you'd like an alternative on Windows that supports functionality similar to `pbcopy`, check out Aidan Ryan's [WinHaste](https://github.com/ajryan/WinHaste) project.
 
+## Lightweight Alternative
+
+Han Boetes and @nickthename have contributed a simple shell-script alternative for those not interested in installing a RubyGem:
+
+``` bash
+haste() {
+    local S="https" H="hastebin.com" P="" L="$1"
+    local SHP="${S}://${H}${P}/"
+    curl -X POST -s --data-binary @- "${SHP}documents" \
+      | awk -F '"' 'b{ b="."b }; {print a$4b}' a="${SHP}" b="${L}"
+}
+```
+
+Where `S` is the scheme, `H` is the host, `P` is the port, and `L` is the language. Requires `curl`
+
+Usage:
+
+``` bash
+cat file.txt | haste     # cat file into hate, output url
+haste sh < script.sh     # Same as above, but ensure shell syntax highlighting 
+xsel -b | haste txt      # Output clipboard buffer into haste, ensure no highlighting  
+```
+
+And a more expansive BASH option by @diethnis can be found at:
+https://github.com/diethnis/standalones/blob/master/hastebin.sh
+
 ## Author
 
 John Crepezzi <john.crepezzi@gmail.com>

Rakefile

@@ -1,7 +1,9 @@
 require 'rspec/core/rake_task'
 require File.dirname(__FILE__) + '/lib/haste/version'
- 
+
-task :build => :test do
+RSpec::Core::RakeTask.new(:spec)
+
+task :build => :spec do
   system "gem build haste.gemspec"
 end
 
@@ -12,14 +14,3 @@ task :release => :build do
   # push the gem
   system "gem push haste-#{Haste::VERSION}.gem"
 end
- 
-RSpec::Core::RakeTask.new(:test) do |t|
-  t.pattern = 'spec/**/*_spec.rb'
-  fail_on_error = true # be explicit
-end
- 
-RSpec::Core::RakeTask.new(:rcov) do |t|
-  t.pattern = 'spec/**/*_spec.rb'
-  t.rcov = true
-  fail_on_error = true # be explicit
-end

haste.gemspec

@@ -1,12 +1,15 @@
 require 'rubygems'
 require File.dirname(__FILE__) + '/lib/haste/version'
 
-spec = Gem::Specification.new do |s|
+Gem::Specification.new do |s|
   s.name = 'haste'
   s.author = 'John Crepezzi'
   s.add_development_dependency('rspec')
   s.add_dependency('json')
+  s.add_dependency('faraday', '~> 0.9')
   s.description = 'CLI Haste Client'
+  s.license = 'MIT License'
+  s.homepage = 'https://github.com/seejohnrun/haste-client'
   s.email = 'john.crepezzi@gmail.com'
   s.executables = 'haste'
   s.files = Dir['lib/**/*.rb', 'haste']

lib/haste.rb

@@ -1,53 +1,6 @@
-require 'json'
+require File.dirname(__FILE__) + '/haste/uploader'
-require 'net/http'
+require File.dirname(__FILE__) + '/haste/exception'
-require 'uri'
+require File.dirname(__FILE__) + '/haste/cli'
 
 module Haste
-
-  DEFAULT_URL = 'http://hastebin.com'
-
-  class CLI
-
-    # Pull all of the data from STDIN
-    def initialize
-      if STDIN.tty?
-        abort 'No input file given' unless ARGV.length == 1
-        abort "#{file}: No such path" unless File.exists?(file = ARGV[0])
-        @input = open(file).read
-      else
-        @input = STDIN.readlines.join
-      end
-      # clean up
-      @input.strip!
-    end
-
-    # Upload the and output the URL we get back
-    def start
-      uri = URI.parse server
-      http = Net::HTTP.new uri.host, uri.port
-      response = http.post '/documents', @input
-      if response.is_a?(Net::HTTPOK)
-        data = JSON.parse(response.body)
-        method = STDOUT.tty? ? :puts : :print
-        STDOUT.send method, "#{server}/#{data['key']}"
-      else
-        abort "failure uploading: #{response.code}"
-      end
-    rescue RuntimeError, JSON::ParserError => e
-      abort "failure uploading: #{response.code}"
-    rescue Errno::ECONNREFUSED => e
-      abort "failure connecting: #{e.message}"
-    end
-
-    private
-
-    def server
-      return @server if @server
-      @server = ENV['HASTE_SERVER'] || Haste::DEFAULT_URL
-      @server.chop! if server.end_with?('/')
-      @server
-    end
-
-  end
-
 end

lib/haste/cli.rb

@@ -0,0 +1,40 @@
+module Haste
+
+  class CLI
+
+    # Create a new uploader
+    def initialize
+      @uploader = Uploader.new(
+        ENV['HASTE_SERVER'],
+        ENV['HASTE_USER'],
+        ENV['HASTE_PASS'],
+        ENV['HASTE_SSL_CERTS'])
+    end
+
+    # And then handle the basic usage
+    def start
+      # Take data in
+      if STDIN.tty?
+        key = @uploader.upload_path ARGV.first
+      else
+        key = @uploader.upload_raw STDIN.readlines.join
+      end
+      # Put together a URL
+      if ARGV.include?('--raw')
+        url = "#{@uploader.server_url}/raw/#{key}"
+      else
+        url = "#{@uploader.server_url}/#{key}"
+      end
+      # And write data out
+      if STDOUT.tty?
+        STDOUT.puts url
+      else
+        STDOUT.print url
+      end
+    rescue Exception => e
+      abort e.message
+    end
+
+  end
+
+end

lib/haste/exception.rb

@@ -0,0 +1,4 @@
+module Haste
+  class Exception < StandardError
+  end
+end

lib/haste/uploader.rb

@@ -0,0 +1,89 @@
+require 'json'
+require 'faraday'
+require 'uri'
+
+module Haste
+
+  DEFAULT_URL = 'https://hastebin.com'
+
+  class Uploader
+
+    attr_reader :server_url, :server_user, :server_pass, :ssl_certs
+
+    def initialize(server_url = nil, server_user = nil, server_pass = nil, ssl_certs = nil)
+      @server_url = server_url || Haste::DEFAULT_URL
+      @server_url = @server_url.dup
+      @server_url = @server_url.chop if @server_url.end_with?('/')
+
+      @server_user = server_user
+      @server_pass = server_pass
+      @ssl_certs   = ssl_certs
+    end
+
+    # Take in a path and return a key
+    def upload_path(path)
+      fail_with 'No input file given' unless path
+      fail_with "#{path}: No such path" unless File.exists?(path)
+      upload_raw open(path).read
+    end
+
+    # Take in data and return a key
+    def upload_raw(data)
+      data.rstrip!
+      response = do_post data
+      if response.status == 200
+        data = JSON.parse(response.body)
+        data['key']
+      else
+        fail_with "failure uploading: #{response.body}"
+      end
+    rescue JSON::ParserError => e
+      fail_with "failure parsing response: #{e.message}"
+    rescue Errno::ECONNREFUSED => e
+      fail_with "failure connecting: #{e.message}"
+    end
+
+    private
+
+    def post_path
+      parsed_uri = URI.parse(server_url)
+      "#{parsed_uri.path}/documents"
+    end
+
+    def do_post(data)
+      connection.post(post_path, data)
+    end
+
+    def connection
+      @connection ||= connection_set
+    end
+
+    def connection_set
+      return connection_https if @ssl_certs
+      connection_http
+    end
+
+    def connection_http
+      Faraday.new(:url => server_url) do |c|
+        connection_config(c)
+      end
+    end
+
+    def connection_https
+      Faraday.new(:url => server_url, :ssl => { :ca_path => @ssl_certs }) do |c|
+        connection_config(c)
+      end
+    end
+
+    def connection_config(config)
+      config.basic_auth(@server_user, @server_pass) if @server_user
+      config.adapter Faraday.default_adapter
+    end
+
+    def fail_with(msg)
+      raise Exception.new(msg)
+    end
+
+  end
+
+end

lib/haste/version.rb

@@ -1,5 +1,5 @@
 module Haste
 
-  VERSION = '0.1.1'
+  VERSION = '0.2.3'
 
 end

spec/examples/uploader_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Haste::Uploader do
+
+  let(:uploader) { Haste::Uploader.new(base) }
+
+  describe :upload_raw do
+
+    let(:data) { 'hello world' }
+    let(:base) { nil }
+    let(:error_message) do
+      begin
+        @key = uploader.upload_raw data
+        nil # nil otherwise
+      rescue Haste::Exception => e
+        e.message
+      end
+    end
+
+    context 'with a good response' do
+
+      let(:json) { '{"key":"hello"}' }
+
+      before do
+        ostruct = OpenStruct.new(:status => 200, :body => json)
+        expect(uploader.send(:connection)).to receive(:post).with('/documents', data).and_return(ostruct)
+      end
+
+      it 'should get the key' do
+        expect(error_message).to be_nil # no error
+        expect(@key).to eq('hello')
+      end
+
+    end
+
+    context 'with a bad json response' do
+
+      let(:json) { '{that:not_even_json}' }
+
+      before do
+        ostruct = OpenStruct.new(:status => 200, :body => json)
+        expect(uploader.send(:connection)).to receive(:post).with('/documents', data).and_return(ostruct)
+      end
+
+      it 'should get an error' do
+        expect(error_message).to start_with('failure parsing response: ')
+      end
+
+    end
+
+    context 'with a 404 response' do
+
+      before do
+        ostruct = OpenStruct.new(:status => 404, :body => 'ohno')
+        expect(uploader.send(:connection)).to receive(:post).with('/documents', data).and_return(ostruct)
+      end
+
+      it 'should get an error' do
+        expect(error_message).to eq('failure uploading: ohno')
+      end
+
+    end
+
+    context 'with a non-existent server' do
+
+      before do
+        error = Errno::ECONNREFUSED
+        expect(uploader.send(:connection)).to receive(:post).with('/documents', data).and_raise(error)
+      end
+
+      it 'should get the key' do
+        expect(error_message).to eq('failure connecting: Connection refused')
+      end
+
+    end
+
+  end
+
+  describe :upload_path do
+
+    let(:base) { nil }
+    let(:error_message) do
+      begin
+        uploader.upload_path path
+        nil # nil otherwise
+      rescue Haste::Exception => e
+        e.message
+      end
+    end
+
+    context 'with no path given' do
+
+      let(:path) { nil }
+
+      it 'should have an error' do
+        expect(error_message).to eq('No input file given')
+      end
+
+    end
+
+    context 'with an invalid path given' do
+
+      let(:path) { '/tmp/why-do-you-have-a-file-called-john' }
+
+      it 'should have an error' do
+        expect(error_message).to eq("#{path}: No such path")
+      end
+
+    end
+
+    context 'with a valid path' do
+
+      let(:data) { 'hello world' }
+      let(:path) { '/tmp/real' }
+      before { File.open(path, 'w') { |f| f.write(data) } }
+
+      before do
+        expect(uploader).to receive(:upload_raw).with(data) # check
+      end
+
+      it 'should not receive an error' do
+        expect(error_message).to be_nil
+      end
+
+    end
+
+  end
+
+  describe :post_path do
+
+    let(:post_path) { uploader.send(:post_path) }
+
+    context "when the server URL doesn't have a path" do
+
+      let(:base) { 'http://example.com/' }
+
+      it 'should return /documents' do
+        expect(post_path).to eq('/documents')
+      end
+
+    end
+
+    context "when the server URL has a path" do
+
+      let(:base) { 'http://example.com/friend' }
+
+      it 'should return /documents' do
+        expect(post_path).to eq('/friend/documents')
+      end
+
+    end
+
+    context "when the server URL has a path that ends with slash" do
+
+      let(:base) { 'http://example.com/friend/' }
+
+      it 'should return /documents appended to the path without a duplicate slash' do
+        expect(post_path).to eq('/friend/documents')
+      end
+
+    end
+
+  end
+
+  describe :server_url do
+
+    let(:server_url) { uploader.server_url }
+
+    context 'with default constructor' do
+
+      let(:base) { nil }
+
+      it 'should use the default url' do
+        expect(server_url).to eq(Haste::DEFAULT_URL)
+      end
+
+    end
+
+    context 'with server url passed in constructor' do
+
+      context 'with a trailing slash' do
+
+        before { @string = 'hello/' }
+        let(:base) { @string }
+
+        it 'should remove the slash' do
+          expect(server_url).to eq(@string.chop)
+        end
+
+        it 'should not modify the original' do
+          expect(@string).to eq('hello/')
+        end
+
+      end
+
+      context 'with no trailing slash' do
+
+        let(:base) { 'hello' }
+
+        it 'should not chop the url' do
+          expect(server_url).to eq(base)
+        end
+
+      end
+
+    end
+
+  end
+
+end

spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'ostruct'
+
+require File.dirname(__FILE__) + '/../lib/haste'