transcriptic 0.1.0

data/lib/transcriptic/command.rb

@@ -0,0 +1,233 @@
+require 'transcriptic/helpers'
+require "optparse"
+
+#Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Transcriptic
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+
+    extend Transcriptic::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @current_command
+    end
+
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
+    def self.current_args
+      @current_args
+    end
+
+    def self.current_options
+      @current_options
+    end
+
+    def self.global_options
+      @global_options ||= []
+    end
+
+    def self.invalid_arguments
+      @invalid_arguments
+    end
+
+    def self.shift_argument
+      @invalid_arguments.shift.downcase rescue nil
+    end
+
+    def self.validate_arguments!
+      unless invalid_arguments.empty?
+        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+        if arguments.length == 1
+          message = "Invalid argument: #{arguments.first}"
+        elsif arguments.length > 1
+          message = "Invalid arguments: "
+          message << arguments[0...-1].join(", ")
+          message << " and "
+          message << arguments[-1]
+        end
+        $stderr.puts(format_with_bang(message))
+        run(current_command, ["--help"])
+        exit(1)
+      end
+    end
+
+    def self.global_option(name, *args)
+      global_options << { :name => name, :args => args }
+    end
+
+    global_option :confirm, "--confirm PROTOCOL"
+    global_option :help,    "--help", "-h"
+    global_option :remote,  "--remote REMOTE"
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      unless command
+        if %w( -v --version ).include?(cmd)
+          display Transcriptic::VERSION
+          exit
+        end
+        
+        output_with_bang("`#{cmd}` is not a transcriptic command.")
+
+        distances = {}
+        (commands.keys + command_aliases.keys).each do |suggestion|
+          distance = string_distance(cmd, suggestion)
+          distances[distance] ||= []
+          distances[distance] << suggestion
+        end
+
+        if distances.keys.min < 4
+          suggestions = distances[distances.keys.min].sort
+          if suggestions.length == 1
+            output_with_bang("Perhaps you meant `#{suggestions.first}`.")
+          else
+            output_with_bang("Perhaps you meant #{suggestions[0...-1].map {|suggestion| "`#{suggestion}`"}.join(', ')} or `#{suggestions.last}`.")
+          end
+        end
+
+        output_with_bang("See `transcriptic help` for additional details.")
+        exit(1)
+
+      end
+
+      @current_command = cmd
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        # overwrite OptionParsers Officious['version'] to avoid conflicts
+        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        parser.on("--version") do |value|
+          invalid_options << "--version"
+        end
+        global_options.each do |global_option|
+          parser.on(*global_option[:args]) do |value|
+            global_option[:proc].call(value) if global_option[:proc]
+            opts[global_option[:name]] = value
+          end
+        end
+        command[:options].each do |name, option|
+          parser.on("-#{option[:short]}", "--#{option[:long]}", option[:desc]) do |value|
+            opts[name.gsub("-", "_").to_sym] = value
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        retry
+      end
+
+      if opts[:help]
+        args.unshift cmd unless cmd =~ /^-.*/
+        cmd = "help"
+        command = parse(cmd)
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      [ command[:klass].new(args.dup, opts.dup), command[:method] ]
+    end
+
+    def self.run(cmd, arguments=[])
+        object, method = prepare_run(cmd, arguments.dup)
+        object.send(method)
+      rescue RestClient::Unauthorized
+        puts "Authentication failure"
+        unless ENV['TRANSCRIPTIC_API_KEY']
+          run "login"
+          retry
+        end
+      rescue RestClient::PaymentRequired => e
+        retry if run('account:confirm_billing', arguments.dup)
+      rescue RestClient::ResourceNotFound => e
+        error extract_error(e.http_body) {
+          e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+        }
+      rescue RestClient::Locked => e
+        app = e.response.headers[:x_confirmation_required]
+        if confirm_command(app, extract_error(e.response.body))
+          arguments << '--confirm' << app
+          retry
+        end
+      rescue RestClient::RequestTimeout
+        error "API request timed out. Please try again, or contact support@transcriptic.com if this issue persists."
+      rescue RestClient::RequestFailed => e
+        error extract_error(e.http_body)
+      rescue CommandFailed => e
+        error e.message
+      rescue OptionParser::ParseError => ex
+        commands[cmd] ? run("help", [cmd]) : run("help")
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+    def self.extract_error(body, options={})
+      default_error = block_given? ? yield : "Internal server error.\nRun 'try status' to check for known platform issues."
+      parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
+    end
+
+    def self.parse_error_xml(body)
+      xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+      msg = xml_errors.map { |a| a.text }.join(" / ")
+      return msg unless msg.empty?
+    rescue Exception
+    end
+
+    def self.parse_error_json(body)
+      json = json_decode(body.to_s) rescue false
+      json ? json['error'] : nil
+    end
+
+    def self.parse_error_plain(body)
+      return unless body.respond_to?(:headers) && body.headers[:content_type].to_s.include?("text/plain")
+      body.to_s
+    end
+  end
+end

data/lib/transcriptic/command/analyze.rb

@@ -0,0 +1,20 @@
+require "transcriptic/command/base"
+
+module Transcriptic::Command
+
+  # analyze an autoprotocol script or project
+  #
+  # analyze a 
+  #
+  #Example:
+  #
+  # $ heroku run bash
+  # Running `bash` attached to terminal... up, run.1
+  # ~ $
+  #
+  class Analyze < Base
+  
+    def index; end
+  
+  end
+end

data/lib/transcriptic/command/base.rb

@@ -0,0 +1,195 @@
+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 extract_app_in_dir(dir)
+    return unless remotes = git_remotes(dir)
+
+    if remote = options[:remote]
+      remotes[remote]
+    elsif remote = extract_app_from_git_config
+      remotes[remote]
+    else
+      apps = remotes.values.uniq
+      if apps.size == 1
+        apps.first
+      else
+        raise(Transcriptic::Command::CommandFailed, "Multiple apps in folder and no app specified.\nSpecify which app to use with --app <app name>")
+      end
+    end
+  end
+
+  def extract_app_from_git_config
+    remote = git("config transcriptic.remote")
+    remote == "" ? nil : remote
+  end
+
+  def git_remotes(base_dir=Dir.pwd)
+    remotes = {}
+    original_dir = Dir.pwd
+    Dir.chdir(base_dir)
+
+    git("remote -v").split("\n").each do |remote|
+      name, url, method = remote.split(/\s/)
+      if url =~ /^git@#{transcriptic.host}:([\w\d-]+)\.git$/
+        remotes[name] = $1
+      end
+    end
+
+    Dir.chdir(original_dir)
+    remotes
+  end
+
+  def escape(value)
+    transcriptic.escape(value)
+  end
+end
+
+module Transcriptic::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end