tui 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler"
+
+Bundler::GemHelper.install_tasks

data/bin/tui

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "commander/import"
+require "tui"
+
+program :version, Tui::VERSION
+program :description, Tui::DESCRIPTION
+
+command :upload do |c|
+  c.syntax = "upload [file]"
+  c.description = "Uploads a file"
+  c.when_called do |args, options|
+    upload = Tui::Upload.new(args[0])
+
+    say "Requesting authorization"
+    request = Tui::Authorization::Request.new(upload)
+    authorization = request.perform
+
+    say "File URL will be #{authorization.short_url}"
+
+    say "Uploading #{upload.path} (#{upload.size} bytes)"
+
+    bar = Commander::UI::ProgressBar.new(upload.chunks, { :complete_message => "Uploaded" })
+
+    upload.perform(authorization) do |bytes_written, bytes_total|
+      bar.increment
+      true
+    end
+  end
+end
+
+alias_command :u, :upload

data/lib/tui.rb

@@ -0,0 +1,5 @@
+require "tui/version"
+require "tui/patch"
+require "tui/authorization"
+require "tui/upload"
+require "tui/config"

data/lib/tui/authorization.rb

@@ -0,0 +1,2 @@
+require "tui/authorization/request"
+require "tui/authorization/response"

data/lib/tui/authorization/request.rb

@@ -0,0 +1,41 @@
+require "json/add/rails"
+require "base64"
+
+module Tui
+  module Authorization
+    class Request
+
+      def initialize(upload)
+        @upload = upload
+      end
+
+      attr_reader :upload
+
+      def perform
+        json_request = upload.as_json.to_json
+
+        connection = Excon.new("http://#{Tui::Config.host}/files")
+
+        login = Base64.urlsafe_encode64("#{Tui::Config.username}:#{Tui::Config.password}")
+
+        headers = {
+          "Authorization" => "Basic #{login}",
+          "Accept"        => "application/json",
+          "Content-Type"  => "application/json",
+        }
+
+        response = connection.request({
+          :method          => "POST",
+          :headers         => headers,
+          :expects         => 200,
+          :body            => json_request,
+        })
+
+        json_response = JSON.parse(response.body)
+
+        Response.new(json_response)
+      end
+
+    end
+  end
+end

data/lib/tui/authorization/response.rb

@@ -0,0 +1,15 @@
+module Tui
+  module Authorization
+    class Response
+
+      attr_reader :short_url, :upload_url, :headers
+
+      def initialize(json)
+        @short_url = json.delete("short_url")
+        @upload_url = json.delete("upload_url")
+        @headers = json.delete("headers")
+      end
+
+    end
+  end
+end

data/lib/tui/config.rb

@@ -0,0 +1,30 @@
+require "singleton"
+require "yaml"
+
+module Tui
+  class Config
+
+    include Singleton
+
+    attr_reader :config
+
+    class << self
+      [:host, :username, :password].each do |attribute|
+        define_method attribute do
+          instance.config[attribute.to_s]
+        end
+      end
+    end
+
+    private
+
+      def initialize
+        path = File.expand_path("~/.tui.yml")
+        
+        @config = File.open(path, "r") do |f|
+          YAML.load(f.read)
+        end
+      end
+
+  end
+end

data/lib/tui/patch.rb

@@ -0,0 +1,155 @@
+module Excon
+  class Connection
+    
+    CHUNK_SIZE = 128 * 1024
+
+    def request_with_uploadprogress(params, &block)
+      begin
+        # connection has defaults, merge in new params to override
+        params = @connection.merge(params)
+        params[:headers] = @connection[:headers].merge(params[:headers] || {})
+        params[:headers]['Host'] ||= '' << params[:host] << ':' << params[:port]
+
+        # if path is empty or doesn't start with '/', insert one
+        unless params[:path][0, 1] == '/'
+          params[:path].insert(0, '/')
+        end
+
+        if params[:mock]
+          for stub, response in Excon.stubs
+            # all specified non-headers params match and no headers were specified or all specified headers match
+            if [stub.keys - [:headers]].all? {|key| stub[key] == params[key] } &&
+              (!stub.has_key?(:headers) || stub[:headers].keys.all? {|key| stub[:headers][key] == params[:headers][key]})
+              case response
+              when Proc
+                return Excon::Response.new(response.call(params))
+              else
+                return Excon::Response.new(response)
+              end
+            end
+          end
+          # if we reach here no stubs matched
+          raise(Excon::Errors::StubNotFound.new('no stubs matched ' << params.inspect))
+        end
+
+        # start with "METHOD /path"
+        request = params[:method].to_s.upcase << ' '
+        if @proxy
+          request << params[:scheme] << '://' << params[:host] << ':' << params[:port]
+        end
+        request << params[:path]
+
+        # add query to path, if there is one
+        case params[:query]
+        when String
+          request << '?' << params[:query]
+        when Hash
+          request << '?'
+          for key, values in params[:query]
+            if values.nil?
+              request << key.to_s << '&'
+            else
+              for value in [*values]
+                request << key.to_s << '=' << CGI.escape(value.to_s) << '&'
+              end
+            end
+          end
+          request.chop! # remove trailing '&'
+        end
+
+        # finish first line with "HTTP/1.1\r\n"
+        request << HTTP_1_1
+
+        # calculate content length and set to handle non-ascii
+        unless params[:headers].has_key?('Content-Length')
+          params[:headers]['Content-Length'] = case params[:body]
+          when File
+            params[:body].binmode
+            File.size(params[:body])
+          when String
+            if FORCE_ENC
+              params[:body].force_encoding('BINARY')
+            end
+            params[:body].length
+          else
+            0
+          end
+        end
+
+        # add headers to request
+        for key, values in params[:headers]
+          for value in [*values]
+            request << key.to_s << ': ' << value.to_s << CR_NL
+          end
+        end
+
+        # add additional "\r\n" to indicate end of headers
+        request << CR_NL
+
+        # write out the request, sans body
+        socket.write(request)
+        socket.flush
+
+        # PATCH BEGINS
+
+        bytes_written = 0
+        bytes_total = params[:headers]['Content-Length']
+
+        # write out the body
+        if params[:body]
+          if params[:body].is_a?(String)
+            socket.write(params[:body])
+          else
+            while chunk = params[:body].read(CHUNK_SIZE)
+              socket.write(chunk)
+              bytes_written += CHUNK_SIZE
+              if params[:upload_progress]
+                params[:upload_progress].call([bytes_written, bytes_total].min, bytes_total)
+              end
+            end
+          end
+        end
+        
+        # PATCH ENDS
+
+        # read the response
+        response = Excon::Response.parse(socket, params, &block)
+
+        if response.headers['Connection'] == 'close'
+          reset
+        end
+
+        response
+      rescue Excon::Errors::StubNotFound => stub_not_found
+        raise(stub_not_found)
+      rescue => socket_error
+        reset
+        raise(Excon::Errors::SocketError.new(socket_error))
+      end
+
+      if params.has_key?(:expects) && ![*params[:expects]].include?(response.status)
+        reset
+        raise(Excon::Errors.status_error(params, response))
+      else
+        response
+      end
+
+    rescue => request_error
+      if params[:idempotent] && [Excon::Errors::SocketError, Excon::Errors::HTTPStatusError].include?(request_error)
+        retries_remaining ||= 4
+        retries_remaining -= 1
+        if retries_remaining > 0
+          if params[:body].respond_to?(:pos=)
+            params[:body].pos = 0
+          end
+          retry
+        else
+          raise(request_error)
+        end
+      else
+        raise(request_error)
+      end
+    end
+
+  end
+end

data/lib/tui/upload.rb

@@ -0,0 +1,76 @@
+require "digest/md5"
+require "mime/types"
+require "excon"
+
+module Tui
+
+  class Upload
+
+    attr_reader :path
+    attr_accessor :authorization
+
+    def initialize(path)
+      @path = File.realpath(path)
+    end
+
+    def file
+      @file ||= File.new(path, "r")
+    end
+
+    def size
+      @size ||= File.size(path)
+    end
+
+    def original_filename
+      @original_filename ||= File.basename(path)
+    end
+
+    def md5sum
+      @digest ||= Digest::MD5.file(path)
+      @md5sum ||= @digest.hexdigest
+    end
+
+    def mime_type
+      @mime_type ||= MIME::Types.type_for(path).first.to_s
+    end
+
+    def chunks
+      @chunks ||= (size / Excon::Connection::CHUNK_SIZE.to_f).ceil
+    end
+
+    def perform(authorization, &block)
+      connection = Excon.new(authorization.upload_url)
+
+      headers = {
+        "User-Agent" => user_agent,
+      }.merge(authorization.headers)
+
+      connection.request_with_uploadprogress(
+        :method          => "PUT",
+        :body            => file,
+        :headers         => headers,
+        :expects         => 200,
+        :upload_progress => block
+      )
+
+      true
+    end
+
+    def as_json
+      {
+        :original_filename => original_filename,
+        :md5sum            => md5sum,
+        :size              => size,
+        :mime_type         => mime_type
+      }
+    end
+
+    private
+
+      def user_agent
+        "tui-#{Tui::VERSION}"
+      end
+
+  end
+
+end

data/lib/tui/version.rb

@@ -0,0 +1,4 @@
+module Tui
+  VERSION = "0.0.1"
+  DESCRIPTION = "A collection of command line utilities to interact with tu.is"
+end

data/tui.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tui/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tui"
+  s.version     = Tui::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Steve Hoeksema"]
+  s.email       = ["steve@seven.net.nz"]
+  s.homepage    = ""
+  s.summary     = Tui::DESCRIPTION
+  s.description = Tui::DESCRIPTION
+
+  s.rubyforge_project = "tui"
+
+  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"]
+
+  s.add_dependency "commander", "~> 4.0"
+  s.add_dependency "excon", "~> 0.6"
+  s.add_dependency "mime-types", "~> 1.1"
+  s.add_dependency "json"
+
+  s.add_development_dependency "rspec", "~> 2.6"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: tui
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Steve Hoeksema
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-18 00:00:00 +12:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: commander
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "4.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: excon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.1"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.6"
+  type: :development
+  version_requirements: *id005
+description: A collection of command line utilities to interact with tu.is
+email: 
+- steve@seven.net.nz
+executables: 
+- tui
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/tui
+- lib/tui.rb
+- lib/tui/authorization.rb
+- lib/tui/authorization/request.rb
+- lib/tui/authorization/response.rb
+- lib/tui/config.rb
+- lib/tui/patch.rb
+- lib/tui/upload.rb
+- lib/tui/version.rb
+- tui.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: tui
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: A collection of command line utilities to interact with tu.is
+test_files: []
+