transcriptic 0.1.3 → 0.2.0

data/lib/transcriptic/command/base.rb

@@ -1,157 +0,0 @@
-require "fileutils"
-require "transcriptic/auth"
-require "transcriptic/command"
-
-class Transcriptic::Command::Base
-  include Transcriptic::Helpers
-
-  def self.namespace
-    self.to_s.split("::").last.downcase
-  end
-
-  attr_reader :args
-  attr_reader :options
-
-  def initialize(args=[], options={})
-    @args = args
-    @options = options
-  end
-
-  def transcriptic
-    Transcriptic::Auth.client
-  end
-
-protected
-
-  def self.inherited(klass)
-    unless klass == Transcriptic::Command::Base
-      help = extract_help_from_caller(caller.first)
-
-      Transcriptic::Command.register_namespace(
-        :name => klass.namespace,
-        :description => help.first
-      )
-    end
-  end
-
-  def self.method_added(method)
-    return if self == Transcriptic::Command::Base
-    return if private_method_defined?(method)
-    return if protected_method_defined?(method)
-
-    help = extract_help_from_caller(caller.first)
-    resolved_method = (method.to_s == "index") ? nil : method.to_s
-    command = [ self.namespace, resolved_method ].compact.join(":")
-    banner = extract_banner(help) || command
-
-    Transcriptic::Command.register_command(
-      :klass       => self,
-      :method      => method,
-      :namespace   => self.namespace,
-      :command     => command,
-      :banner      => banner.strip,
-      :help        => help.join("\n"),
-      :summary     => extract_summary(help),
-      :description => extract_description(help),
-      :options     => extract_options(help)
-    )
-  end
-
-  def self.alias_command(new, old)
-    raise "no such command: #{old}" unless Transcriptic::Command.commands[old]
-    Transcriptic::Command.command_aliases[new] = old
-  end
-
-  def self.extract_help_from_caller(line)
-    # pull out of the caller the information for the file path and line number
-    if line =~ /^(.+?):(\d+)/
-      extract_help($1, $2)
-    else
-      raise("unable to extract help from caller: #{line}")
-    end
-  end
-
-  def self.extract_help(file, line_number)
-    buffer = []
-    lines = Transcriptic::Command.files[file]
-
-    (line_number.to_i-2).downto(0) do |i|
-      line = lines[i]
-      case line[0..0]
-        when ""
-        when "#"
-          buffer.unshift(line[1..-1])
-        else
-          break
-      end
-    end
-
-    buffer
-  end
-
-  def self.extract_command(help)
-    extract_banner(help).to_s.split(" ").first
-  end
-
-  def self.extract_banner(help)
-    help.first
-  end
-
-  def self.extract_summary(help)
-    extract_description(help).split("\n").first
-  end
-
-  def self.extract_description(help)
-    help.reject do |line|
-      line =~ /^\s+-(.+)#(.+)/
-    end.join("\n")
-  end
-
-  def self.extract_options(help)
-    help.select do |line|
-      line =~ /^\s+-(.+)#(.+)/
-    end.inject({}) do |hash, line|
-      description = line.split("#", 2).last
-      long  = line.match(/--([A-Za-z\- ]+)/)[1].strip
-      short = line.match(/-([A-Za-z ])/)[1].strip
-      hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
-    end
-  end
-
-  def current_command
-    Transcriptic::Command.current_command
-  end
-
-  def extract_option(name, default=true)
-    key = name.gsub("--", "").to_sym
-    return unless options[key]
-    value = options[key] || default
-    block_given? ? yield(value) : value
-  end
-
-  def invalid_arguments
-    Transcriptic::Command.invalid_arguments
-  end
-
-  def shift_argument
-    Transcriptic::Command.shift_argument
-  end
-
-  def validate_arguments!
-    Transcriptic::Command.validate_arguments!
-  end
-
-  def confirm_mismatch?
-    options[:confirm] && (options[:confirm] != options[:app])
-  end
-
-  def escape(value)
-    transcriptic.escape(value)
-  end
-end
-
-module Transcriptic::Command
-  unless const_defined?(:BaseWithApp)
-    BaseWithApp = Base
-  end
-end

data/lib/transcriptic/command/console.rb

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

data/lib/transcriptic/command/data.rb

@@ -1,29 +0,0 @@
-module Transcriptic::Command
-
-  # manage experimental data sets
-  #
-  class Data < Base
-
-    # data RUNID
-    #
-    # list available datasets for RUNID
-    #
-    def index
-    end
-
-    # transcriptic data:download DATASETID
-    #
-    # download the dataset identified by DATASETID
-    #
-    def download
-    end
-
-    # transcriptic data:delete DATASETID
-    #
-    # delete the dataset identified by DATASETID
-    #
-    def delete
-    end
-
-  end
-end

data/lib/transcriptic/command/help.rb

@@ -1,124 +0,0 @@
-module Transcriptic::Command
-
-  # list commands and display help
-  #
-  class Help < Base
-    PRIMARY_NAMESPACES = %w(run data)
-    
-      # 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/login.rb

@@ -1,35 +0,0 @@
-# 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

@@ -1,108 +0,0 @@
-require 'zipruby'
-require 'net/http/post/multipart'
-
-module Transcriptic::Command
-
-  # upload and run a protocol
-  #
-  class Run < Base
-
-    # run [FILENAME|DIRECTORY]
-    #
-    # upload FILENAME or DIRECTORY and launch it
-    #
-    def index
-      path = args.shift
-      fd = create_protocol_fd_for_path(path)
-      if 1 == fd
-        error "Couldn't create run!"
-      end
-      display "Uploading `#{path}` to Transcriptic..."
-      run_id = transcriptic.create_run(fd)["run_id"]
-      display "Run launched (#{run_id})"
-    end
-
-    # transcriptic run:analyze [FILENAME|DIRECTORY]
-    #
-    # upload FILENAME or DIRECTORY and analyze it
-    #
-    def analyze
-      path = args.shift
-    end
-
-    # transcriptic run:status [RUNID]
-    #
-    # show details of RUNID
-    #
-    def status
-      run_id = args.shift
-      if run_id.nil?
-        error("Usage: transcriptic status RUNID\nMust specify RUNID to get run status.")
-      end
-      ret = transcriptic.status(run_id)
-      if ret.nil?
-        error("#{run_id} not found for #{transcriptic.user}")
-        return
-      end
-      display(ret.inspect)
-    end
-
-    # transcriptic run:list
-    #
-    # list active runs
-    #
-    def list
-      ret = transcriptic.list
-      if ret.empty?
-        error("No runs for #{transcriptic.user}")
-        return
-      end
-      display("Runs:")
-      ret.each do |run|
-        display "  #{run.name}"
-      end
-    end
-
-    # transcriptic run:logs RUNID
-    #
-    # get log data for RUNID
-    #
-    def logs
-      run_id = args.shift
-      transcriptic.read_logs(run_id)
-    end
-
-    private
-    def create_protocol_fd_for_path(path)
-      begin
-        stat = File.stat(path)
-      rescue
-        display "No such path: #{path}"
-        return 1
-      end
-      upfile = Tempfile.new('protocol')
-      if stat.directory?
-        files = Pathname.glob("#{path}/**/**")
-        file_count = files.reject(&:directory?).length
-        dir_count = files.reject(&:file?).length
-        display "Package detected, compressing #{file_count} files (#{dir_count} directories)..."
-        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
-        Zip::Archive.open(upfile.path, Zip::CREATE) do |ar|
-          ar.add_file(path, path)
-        end
-      end
-      upfile
-    end
-
-  end
-end