transcriptic 0.1.0

data/lib/transcriptic/command/console.rb

@@ -0,0 +1,10 @@
+module Transcriptic::Command
+
+  # take interactive control of a lab context
+  #
+  class Console < Base
+  
+    def index; end
+  
+  end
+end

data/lib/transcriptic/command/data.rb

@@ -0,0 +1,8 @@
+module Transcriptic::Command
+
+  # manage experimental data sets
+  #
+  class Data < Base
+    def index; end
+  end
+end

data/lib/transcriptic/command/help.rb

@@ -0,0 +1,124 @@
+module Transcriptic::Command
+
+  # list commands and display help
+  #
+  class Help < Base
+    PRIMARY_NAMESPACES = %w( analyze data history run status sequences)
+    
+      # help [COMMAND]
+      #
+      # list available commands or display help for a specific command
+      #
+      def index
+        if command = args.shift
+          help_for_command(command)
+        else
+          help_for_root
+        end
+      end
+
+      alias_command "-h", "help"
+      alias_command "--help", "help"
+
+      def self.usage_for_command(command)
+        command = new.send(:commands)[command]
+        "Usage: transcriptic #{command[:banner]}" if command
+      end
+
+    private
+
+      def commands_for_namespace(name)
+        Transcriptic::Command.commands.values.select do |command|
+          command[:namespace] == name && command[:command] != name
+        end
+      end
+
+      def namespaces
+        namespaces = Transcriptic::Command.namespaces
+        namespaces.delete("app")
+        namespaces
+      end
+
+      def commands
+        Transcriptic::Command.commands
+      end
+
+      def legacy_help_for_namespace(namespace)
+        instance = Transcriptic::Command::Help.groups.map do |group|
+          [ group.title, group.select { |c| c.first =~ /^#{namespace}/ }.length ]
+        end.sort_by { |l| l.last }.last
+        return nil unless instance
+        return nil if instance.last.zero?
+        instance.first
+      end
+
+      def primary_namespaces
+        PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+      end
+
+      def additional_namespaces
+        (namespaces.values - primary_namespaces)
+      end
+
+      def summary_for_namespaces(namespaces)
+        size = longest(namespaces.map { |n| n[:name] })
+        namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
+          name = namespace[:name]
+          namespace[:description]
+          puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+        end
+      end
+
+      def help_for_root
+        puts "Usage: transcriptic COMMAND [command-specific-options]"
+        puts
+        puts "Primary help topics, type \"transcriptic help TOPIC\" for more details:"
+        puts
+        summary_for_namespaces(primary_namespaces)
+        puts
+        puts "Additional topics:"
+        puts
+        summary_for_namespaces(additional_namespaces)
+        puts
+      end
+
+      def help_for_namespace(name)
+        namespace_commands = commands_for_namespace(name)
+
+        unless namespace_commands.empty?
+          size = longest(namespace_commands.map { |c| c[:banner] })
+          namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+            next if command[:help] =~ /DEPRECATED/
+            command[:summary]
+            puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+          end
+        end
+      end
+
+      def help_for_command(name)
+        if command_alias = Transcriptic::Command.command_aliases[name]
+          display("Alias: #{name} redirects to #{command_alias}")
+          name = command_alias
+        end
+        if command = commands[name]
+          puts "Usage: transcriptic #{command[:banner]}"
+
+          if command[:help].strip.length > 0
+            puts command[:help].split("\n")[1..-1].join("\n")
+          end
+          puts
+        end
+
+        if commands_for_namespace(name).size > 0
+          puts "Additional commands, type \"transcriptic help COMMAND\" for more details:"
+          puts
+          help_for_namespace(name)
+          puts
+        elsif command.nil?
+          error "#{name} is not a transcriptic command. See `transcriptic help`."
+        end
+      end
+    
+  end
+
+end

data/lib/transcriptic/command/history.rb

@@ -0,0 +1,8 @@
+module Transcriptic::Command
+
+  # show the history (audit trail) for a run
+  #
+  class History < Base
+    def index; end
+  end
+end

data/lib/transcriptic/command/login.rb

@@ -0,0 +1,35 @@
+# login, logout, and view your api token
+#
+class Transcriptic::Command::Auth < Transcriptic::Command::Base
+
+  # auth:login
+  #
+  # log in with your transcriptic account
+  #
+  def login
+    Transcriptic::Auth.login
+    display "Authentication successful."
+  end
+
+  alias_command "login", "auth:login"
+
+  # auth:logout
+  #
+  # clear local authentication credentials
+  #
+  def logout
+    Transcriptic::Auth.logout
+    display "Local credentials cleared."
+  end
+
+  alias_command "logout", "auth:logout"
+
+  # auth:token
+  #
+  # display your api token
+  #
+  def token
+    display Transcriptic::Auth.api_key
+  end
+
+end

data/lib/transcriptic/command/run.rb

@@ -0,0 +1,60 @@
+require 'zipruby'
+require 'net/http/post/multipart'
+
+module Transcriptic::Command
+
+  # upload and run a protocol
+  #
+  class Run < Base
+
+    # transcriptic run [FILENAME|DIRECTORY]
+    #
+    # upload FILENAME or DIRECTORY and launch it
+    #
+    def index
+      path = args.shift
+      upload_protocol(path)
+    end
+
+    def upload_protocol(path)
+      begin
+        stat = File.stat(path)
+      rescue
+        puts "No such path: #{path}"
+        return
+      end
+      if stat.directory?
+        files = Pathname.glob("#{path}/**/**")
+        file_count = files.reject(&:directory?).length
+        dir_count = files.reject(&:file?).length
+        puts "Package detected, compressing #{file_count} files (#{dir_count} directories)..."
+        upfile = Tempfile.new('protocol')
+        Zip::Archive.open(upfile.path, Zip::CREATE) do |ar|
+          ar.add_dir(path)
+          Dir.glob("#{path}/**/**").each do |path|
+            if File.directory?(path)
+              ar.add_dir(path)
+            else
+              ar.add_file(path, path)
+            end
+          end
+        end
+      else
+        upfile = path
+      end
+      puts "Uploading `#{path}` to Transcriptic..."
+      url = URI.parse('http://client.transcriptic.com/receive')
+      File.open(upfile) do |zf|
+        req = Net::HTTP::Post::Multipart.new url.path,
+          "file" => UploadIO.new(zf, "application/zip", "protocol.zip")
+        res = Net::HTTP.start(url.host, url.port) do |http|
+          http.request(req)
+        end
+        if res.code != 200
+          puts "HTTP Error: #{res.message} (#{res.code})"
+        end
+      end
+    end
+
+  end
+end

data/lib/transcriptic/command/sequences.rb

@@ -0,0 +1,45 @@
+module Transcriptic::Command
+  
+  # manage sequence data
+  #
+  class Sequences < Base
+  
+    # sequences
+    #
+    # list all sequence entries
+    #
+    #Examples:
+    #
+    # $ transcriptic sequences
+    # ...
+    #
+    def index
+      validate_arguments!
+    end
+    
+    # sequences:add FILENAME.EXT
+    #
+    # upload new sequence data file. EXT must be .gb or .fasta
+    #
+    #Examples:
+    #
+    # $ transcriptic sequences:add myvector.fasta
+    # ...
+    #
+    def add
+    end
+  
+    # sequences:delete NAME
+    #
+    # delete sequence by name NAME
+    #
+    #Examples:
+    #
+    # $ transcriptic sequences:delete myvector20110204
+    # ...
+    #
+    def remove
+    end
+
+  end
+end

data/lib/transcriptic/command/status.rb

@@ -0,0 +1,17 @@
+module Transcriptic::Command
+
+  # view the status of your runs
+  #
+  class Status < Base
+  
+    # transcriptic status [RUNID]
+    #
+    # list active runs, or if RUNID supplied, show details of that run
+    #
+    def index
+      run_id = args.shift
+      puts run_id
+    end
+    
+  end
+end

data/lib/transcriptic/helpers.rb

@@ -0,0 +1,311 @@
+require "vendor/transcriptic/okjson"
+
+module Transcriptic
+  module Helpers
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'].gsub("\\","/") : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def display(msg="", newline=true)
+      if newline
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def redisplay(line, line_break = false)
+      display("\r\e[0K#{line}", line_break)
+    end
+
+    def deprecate(version)
+      display "!!! DEPRECATION WARNING: This command will be removed in version #{version}"
+      display
+    end
+
+    def error(msg)
+      STDERR.puts(msg)
+      exit 1
+    end
+
+    def confirm_billing
+      display
+      display "This action will cause your account to be billed at the end of the month"
+      display "For more information, see http://devcenter.heroku.com/articles/billing"
+      display "Are you sure you want to do this? (y/n) ", false
+      if ask.downcase == 'y'
+        heroku.confirm_billing
+        return true
+      end
+    end
+
+    def confirm(message = "Are you sure you wish to continue? (y/n)?")
+      display("#{message} ", false)
+      ask.downcase == 'y'
+    end
+
+    def confirm_command(app = app)
+      raise(Transcriptic::Command::CommandFailed, "No app specified.\nRun this command from app folder or set it adding --app <app name>") unless app
+
+      confirmed_app = extract_option('--confirm', false)
+      if confirmed_app
+        unless confirmed_app == app
+          raise(Transcriptic::Command::CommandFailed, "Confirmed app #{confirmed_app} did not match the selected app #{app}.")
+        end
+        return true
+      else
+        display
+        display " !    WARNING: Potentially Destructive Action"
+        display " !    This command will affect the app: #{app}"
+        display " !    To proceed, type \"#{app}\" or re-run this command with --confirm #{app}"
+        display
+        display "> ", false
+        if ask.downcase != app
+          display " !    Input did not match #{app}. Aborted."
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def format_date(date)
+      date = Time.parse(date) if date.is_a?(String)
+      date.strftime("%Y-%m-%d %H:%M %Z")
+    end
+
+    def ask
+      gets.strip
+    end
+
+    def shell(cmd)
+      FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
+    end
+
+    def run_command(command, args=[])
+      Transcriptic::Command.run(command, args)
+    end
+
+    def retry_on_exception(*exceptions)
+      retry_count = 0
+      begin
+        yield
+      rescue *exceptions => ex
+        raise ex if retry_count >= 3
+        sleep 3
+        retry_count += 1
+        retry
+      end
+    end
+
+    def has_git?
+      %x{ git --version }
+      $?.success?
+    end
+
+    def git(args)
+      return "" unless has_git?
+      flattened_args = [args].flatten.compact.join(" ")
+      %x{ git #{flattened_args} 2>&1 }.strip
+    end
+
+    def time_ago(elapsed)
+      if elapsed < 60
+        "#{elapsed.floor}s ago"
+      elsif elapsed < (60 * 60)
+        "#{(elapsed / 60).floor}m ago"
+      else
+        "#{(elapsed / 60 / 60).floor}h ago"
+      end
+    end
+
+    def truncate(text, length)
+      if text.size > length
+        text[0, length - 2] + '..'
+      else
+        text
+      end
+    end
+
+    @@kb = 1024
+    @@mb = 1024 * @@kb
+    @@gb = 1024 * @@mb
+    def format_bytes(amount)
+      amount = amount.to_i
+      return '(empty)' if amount == 0
+      return amount if amount < @@kb
+      return "#{(amount / @@kb).round}k" if amount < @@mb
+      return "#{(amount / @@mb).round}M" if amount < @@gb
+      return "#{(amount / @@gb).round}G"
+    end
+
+    def quantify(string, num)
+      "%d %s" % [ num, num.to_i == 1 ? string : "#{string}s" ]
+    end
+
+    def create_git_remote(app, remote)
+      return unless has_git?
+      return if git('remote').split("\n").include?(remote)
+      return unless File.exists?(".git")
+      git "remote add #{remote} git@#{heroku.host}:#{app}.git"
+      display "Git remote #{remote} added"
+    end
+
+    def app_urls(name)
+      "http://#{name}.heroku.com/ | git@heroku.com:#{name}.git"
+    end
+
+    def longest(items)
+      items.map { |i| i.to_s.length }.sort.last
+    end
+
+    def display_table(objects, columns, headers)
+      lengths = []
+      columns.each_with_index do |column, index|
+        header = headers[index]
+        lengths << longest([header].concat(objects.map { |o| o[column].to_s }))
+      end
+      display_row headers, lengths
+      display_row headers.map { |header| "-" * header.length }, lengths
+      objects.each do |row|
+        display_row columns.map { |column| row[column] }, lengths
+      end
+    end
+
+    def display_row(row, lengths)
+      row.zip(lengths).each do |column, length|
+        format = column.is_a?(Fixnum) ? "%#{length}s  " : "%-#{length}s  "
+        display format % column, false
+      end
+      display
+    end
+
+    def json_encode(object)
+      Transcriptic::OkJson.encode(object)
+    rescue Transcriptic::OkJson::ParserError
+      nil
+    end
+
+    def json_decode(json)
+      Transcriptic::OkJson.decode(json)
+    rescue Transcriptic::OkJson::ParserError
+      nil
+    end
+
+    def set_buffer(enable)
+      return unless $stdin.tty?
+
+      if enable
+        `stty icanon echo`
+      else
+        `stty -icanon -echo`
+      end
+    rescue
+      # fails on windows
+    end
+
+    def get_terminal_environment
+      { "TERM" => ENV["TERM"], "COLUMNS" => `tput cols`, "LINES" => `tput lines` }
+    rescue
+      { "TERM" => ENV["TERM"] }
+    end
+
+    def fail(message)
+      raise Transcriptic::Command::CommandFailed, message
+    end
+
+    ## DISPLAY HELPERS
+
+    def arrow(message)
+      "-----> #{message}"
+    end
+
+    def action(message)
+      display "#{arrow(message)}... ", false
+      Transcriptic::Helpers.enable_error_capture
+      yield
+      Transcriptic::Helpers.disable_error_capture
+      display "done", false
+      display(", #{@status}", false) if @status
+      display
+    end
+
+    def status(message)
+      @status = message
+    end
+
+    def output(message="")
+      return if message.to_s.strip == ""
+      display "       " + message.split("\n").join("\n       ")
+    end
+
+    def output_with_arrow(message="")
+      return if message.to_s.strip == ""
+      display "-----> " + message.split("\n").join("\n       ")
+    end
+
+    def error_with_failure(message)
+      display "failed"
+      message.gsub!(/^ +! */, '')
+      display message.split("\n").map { |line| " !     #{line}" }.join("\n")
+      exit 1
+    end
+
+    def self.included_into
+      @@included_into ||= []
+    end
+
+    def self.extended_into
+      @@extended_into ||= []
+    end
+
+    def self.included(base)
+      included_into << base
+    end
+
+    def self.extended(base)
+      extended_into << base
+    end
+
+    def self.enable_error_capture
+      included_into.each do |base|
+        base.send(:alias_method, :error_without_failure, :error)
+        base.send(:alias_method, :error, :error_with_failure)
+      end
+      extended_into.each do |base|
+        class << base
+          alias_method :error_without_failure, :error
+          alias_method :error, :error_with_failure
+        end
+      end
+    end
+
+    def self.disable_error_capture
+      included_into.each do |base|
+        base.send(:alias_method, :error, :error_without_failure)
+      end
+      extended_into.each do |base|
+        class << base
+          alias_method :error, :error_without_failure
+        end
+      end
+    end
+  end
+end
+
+unless String.method_defined?(:shellescape)
+  class String
+    def shellescape
+      empty? ? "''" : gsub(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\\\\1').gsub(/\n/, "'\n'")
+    end
+  end
+end