turbot 0.1.36 → 0.2.3

data/lib/turbot/deprecated.rb

@@ -1,5 +0,0 @@
-require "turbot"
-
-module Turbot::Deprecated
-end
-

data/lib/turbot/deprecated/help.rb

@@ -1,38 +0,0 @@
-require "turbot/deprecated"
-
-module Turbot::Deprecated::Help
-  def self.included(base)
-    base.extend ClassMethods
-  end
-
-  class HelpGroup < Array
-    attr_reader :title
-
-    def initialize(title)
-      @title = title
-    end
-
-    def command(name, description)
-      self << [name, description]
-    end
-
-    def space
-      self << ['', '']
-    end
-  end
-
-  module ClassMethods
-    def groups
-      @groups ||= []
-    end
-
-    def group(title, &block)
-      groups << begin
-        group = HelpGroup.new(title)
-        yield group
-        group
-      end
-    end
-  end
-end
-

data/lib/turbot/distribution.rb

@@ -1,9 +0,0 @@
-module Turbot
-  module Distribution
-    def self.files
-      (Dir[File.expand_path("../../../{Gemfile,turbot.gemspec,.gitmodules,schema}", __FILE__)] + Dir[File.expand_path("../../../{.git,bin,data,lib,templates}/**/*", __FILE__)]).select do |file|
-        File.file?(file)
-      end
-    end
-  end
-end

data/lib/turbot/errors.rb

@@ -1,28 +0,0 @@
-module Turbot
-  class API
-    module Errors
-      class Error < StandardError; end
-
-      class ErrorWithResponse < Error
-        attr_reader :response
-
-        def initialize(message, response=nil)
-          message = message << "\nbody: #{response.body.inspect}" if response
-          super message
-          @response = response
-        end
-      end
-
-      class Unauthorized < ErrorWithResponse; end
-      class VerificationRequired < ErrorWithResponse; end
-      class Forbidden < ErrorWithResponse; end
-      class NotFound < ErrorWithResponse; end
-      class Timeout < ErrorWithResponse; end
-      class Locked < ErrorWithResponse; end
-      class RateLimitExceeded < ErrorWithResponse; end
-      class RequestFailed < ErrorWithResponse; end
-      class NilApp < ErrorWithResponse; end
-      class MissingManifest < ErrorWithResponse; end
-    end
-  end
-end

data/lib/turbot/excon.rb

@@ -1,11 +0,0 @@
-module Excon
-
-  def self.get_with_redirect(url, options={})
-    res = Excon.get(url, options)
-    if [301, 302].include?(res.status)
-      return self.get_with_redirect(res.headers["Location"], options)
-    end
-    res
-  end
-
-end

data/lib/turbot/helpers/log_displayer.rb

@@ -1,70 +0,0 @@
-require "turbot/helpers"
-
-module Turbot::Helpers
-  class LogDisplayer
-
-    include Turbot::Helpers
-
-    attr_reader :api, :bot, :opts
-
-    def initialize(api, bot, opts)
-      @api, @bot, @opts = api, bot, opts
-    end
-
-    def display_logs
-      @assigned_colors = {}
-      @line_start = true
-      @token = nil
-
-      api.read_logs(bot, opts).each do |chunk|
-        unless chunk.empty?
-          if STDOUT.isatty && ENV.has_key?("TERM")
-            display(colorize(chunk))
-          else
-            display(chunk)
-          end
-        end
-      end
-    rescue Errno::EPIPE
-    rescue Interrupt => interrupt
-      if STDOUT.isatty && ENV.has_key?("TERM")
-        display("\e[0m")
-      end
-      raise(interrupt)
-    end
-
-    COLORS = %w( cyan yellow green magenta red )
-    COLOR_CODES = {
-      "red"     => 31,
-      "green"   => 32,
-      "yellow"  => 33,
-      "magenta" => 35,
-      "cyan"    => 36,
-    }
-
-    def colorize(chunk)
-      lines = []
-      chunk.split("\n").map do |line|
-        if parsed_line = parse_log(line)
-          header, identifier, body = parsed_line
-          @assigned_colors[identifier] ||= COLORS[@assigned_colors.size % COLORS.size]
-          lines << [
-            "\e[#{COLOR_CODES[@assigned_colors[identifier]]}m",
-            header,
-            "\e[0m",
-            body,
-          ].join("")
-        elsif not line.empty?
-          lines << line
-        end
-      end
-      lines.join("\n")
-    end
-
-    def parse_log(log)
-      return unless parsed = log.match(/^(.*?\[([\w-]+)([\d\.]+)?\]:)(.*)?$/)
-      [1, 2, 4].map { |i| parsed[i] }
-    end
-
-  end
-end

data/lib/turbot/helpers/pg_dump_restore.rb

@@ -1,115 +0,0 @@
-require 'uri'
-class PgDumpRestore
-  attr_reader :command
-
-  def initialize(source, target, command)
-    @source = URI.parse(source)
-    @target = URI.parse(target)
-    @command = command
-
-    fill_in_shorthand_uris!
-  end
-
-  def execute
-    prepare
-    run
-    verify
-  end
-
-  def prepare
-    if @target.host == 'localhost'
-      create_local_db
-    else
-      ensure_remote_db_empty
-    end
-  end
-
-  def verify
-    verify_extensions_match
-  end
-
-  def dump_restore_cmd
-    pg_restore = gen_pg_restore_command(@target)
-    pg_dump = gen_pg_dump_command(@source)
-    "#{pg_dump} | #{pg_restore}"
-  end
-
-  private
-
-  def create_local_db
-    dbname = @target.path[1..-1]
-    cdb_output = `createdb #{dbname} 2>&1`
-    if $?.exitstatus != 0
-      if cdb_output =~ /already exists/
-        command.error(cdb_output + "\nPlease drop the local database (`dropdb #{dbname}`) and try again.")
-      else
-        command.error(cdb_output + "\nUnable to create new local database. Ensure your local Postgres is working and try again.")
-      end
-    end
-  end
-
-  def ensure_remote_db_empty
-    sql = 'select count(*) = 0 from pg_stat_user_tables;'
-    result = exec_sql_on_uri(sql, @target)
-    unless result == " ?column? \n----------\n t\n(1 row)\n\n"
-      command.error("Remote database is not empty.\nPlease create a new database, or use `turbot pg:reset`")
-    end
-  end
-
-  def gen_pg_dump_command(uri)
-    # It is occasionally necessary to override PGSSLMODE, as when the server
-    # wasn't built to support SSL.
-    %{ env PGPASSWORD=#{uri.password} PGSSLMODE=prefer pg_dump --verbose -F c -Z 0 #{connstring(uri, :skip_d_flag)} }
-  end
-
-  def gen_pg_restore_command(uri)
-    %{ env PGPASSWORD=#{uri.password} pg_restore --verbose --no-acl --no-owner #{connstring(uri)} }
-  end
-
-  def connstring(uri, skip_d_flag=false)
-    database = uri.path[1..-1]
-    user = uri.user ? "-U #{uri.user}" : ""
-    %Q{#{user} -h #{uri.host} -p #{uri.port} #{skip_d_flag ? '' : '-d'} #{database} }
-  end
-
-  def fill_in_shorthand_uris!
-    [@target, @source].each do |uri|
-      uri.host ||= 'localhost'
-      uri.port ||= Integer(ENV['PGPORT'] || 5432)
-    end
-  end
-
-  def verify_extensions_match
-    # It's pretty common for local DBs to not have extensions available that
-    # are used by the remote bot, so take the final precaution of warning if
-    # the extensions available in the local database don't match. We don't
-    # report it if the difference is solely in the version of an extension
-    # used, though.
-    ext_sql = "SELECT extname FROM pg_extension ORDER BY extname;"
-    target_exts = exec_sql_on_uri(ext_sql, @target)
-    source_exts = exec_sql_on_uri(ext_sql, @source)
-    if target_exts != source_exts
-      command.error <<-EOM
-WARNING: Extensions in newly created target database differ from existing source database.
-
-Target extensions:
-#{target_exts}
-Source extensions:
-#{source_exts}
-HINT: You should review output to ensure that any errors
-ignored are acceptable - entire tables may have been missed, where a dependency
-could not be resolved. You may need to to install a postgresql-contrib package
-and retry.
-EOM
-    end
-  end
-
-  def exec_sql_on_uri(sql, uri)
-    command.send(:exec_sql_on_uri, sql, uri)
-  end
-
-  def run
-    system dump_restore_cmd
-  end
-end
-

data/lib/turbot/helpers/turbot_postgresql.rb

@@ -1,213 +0,0 @@
-require "turbot/helpers"
-
-module Turbot::Helpers::TurbotPostgresql
-
-  extend self
-  extend Turbot::Helpers
-
-  class Attachment
-    attr_reader :bot, :name, :config_var, :resource_name, :url, :addon, :plan
-    def initialize(raw)
-      @raw = raw
-      @bot           = raw['bot']['name']
-      @name          = raw['name']
-      @config_var    = raw['config_var']
-      @resource_name = raw['resource']['name']
-      @url           = raw['resource']['value']
-      @addon, @plan  = raw['resource']['type'].split(':')
-    end
-
-    def starter_plan?
-      plan =~ /dev|basic/
-    end
-
-    def display_name
-      config_var + (primary_attachment? ? " (DATABASE_URL)"  : '')
-    end
-
-    def primary_attachment!
-      @primary_attachment = true
-    end
-
-    def primary_attachment?
-      @primary_attachment
-    end
-  end
-
-  def hpg_resolve(identifier, default=nil)
-    $stderr.puts " !    #hpg_resolve is deprecated. Please run `turbot plugins:update` to update your plugins."
-    $stderr.puts " !    from: #{caller.first}"
-    Resolver.new(bot, api).resolve(identifier , default)
-  end
-
-  class Resolver
-    include Turbot::Helpers
-    attr_reader :api, :bot_name
-    def initialize(bot_name, api)
-      @bot_name = bot_name
-      @api = api
-    end
-
-    def resolve(identifier, default=nil)
-      if identifier =~ /::/
-        @bot_name, db_name = identifier.split('::')
-      else
-        db_name = identifier
-      end
-
-      hpg_resolve(db_name, default)
-    end
-
-    def all_databases
-      hpg_databases
-    end
-
-    def database_name_from_url(url)
-      vars = bot_config_vars.reject {|key,value| key == 'DATABASE_URL'}
-      if var = vars.invert[url]
-        var.gsub(/_URL$/, '')
-      else
-        uri = URI.parse(url)
-        "Database on #{uri.host}:#{uri.port || 5432}#{uri.path}"
-      end
-    end
-
-    def hpg_addon_name
-      if ENV['SHOGUN']
-        "shogun-#{ENV['SHOGUN']}"
-      else
-        ENV['TURBOT_POSTGRESQL_ADDON_NAME'] || 'turbot-postgresql'
-      end
-    end
-
-    private
-
-    def protect_missing_bot
-      # in the case where --bot was left out, AND bot::db shorthand was not used, AND no bot autodetect
-      unless bot_name
-        error("No bot specified.\nRun this command from an bot folder or specify which bot to use with --bot APP.")
-      end
-    end
-
-    def bot_config_vars
-      protect_missing_bot
-      @bot_config_vars ||= api.get_config_vars(bot_name).body
-    end
-
-    def bot_attachments
-      protect_missing_bot
-      @bot_attachments ||= api.get_attachments(bot_name).body.map { |raw| Attachment.new(raw) }
-    end
-
-    def hpg_databases
-      return @hpg_databases if @hpg_databases
-      pairs = bot_attachments.select {|att|
-          att.addon == hpg_addon_name
-        }.map { |att|
-          [att.config_var, att]
-        }
-      @hpg_databases = Hash[ pairs ]
-
-      if find_database_url_real_attachment
-        @hpg_databases['DATABASE_URL'] = find_database_url_real_attachment
-      end
-
-      return @hpg_databases
-    end
-
-    def resource_url(resource)
-      api.get_resource(resource).body['value']
-    end
-
-    def forget_config!
-      @hpg_databases   = nil
-      @bot_config_vars = nil
-      @bot_attachments = nil
-    end
-
-    def find_database_url_real_attachment
-      raw_primary_db_url = bot_config_vars['DATABASE_URL']
-      return unless raw_primary_db_url
-
-      primary_db_url = raw_primary_db_url.split("?").first
-      return unless primary_db_url && !primary_db_url.empty?
-
-      real_config = bot_config_vars.detect {|k,v| k != 'DATABASE_URL' && v == primary_db_url }
-      if real_config
-        real = hpg_databases[real_config.first]
-        real.primary_attachment! if real
-        return real
-      else
-        return nil
-      end
-    end
-
-    def match_attachments_by_name(name)
-       return [] if name.empty?
-       return [name] if hpg_databases[name]
-       hpg_databases.keys.grep(%r{#{ name }}i)
-    end
-
-    def hpg_resolve(name, default=nil)
-      name = '' if name.nil?
-      name = 'DATABASE_URL' if name == 'DATABASE'
-
-      if hpg_databases.empty?
-        error("Your bot has no databases.")
-      end
-
-      found_attachment = nil
-      candidates = match_attachments_by_name(name)
-      if default && name.empty? && bot_config_vars[default]
-        found_attachment = hpg_databases[default]
-      elsif candidates.size == 1
-        found_attachment = hpg_databases[candidates.first]
-      end
-
-      if found_attachment.nil?
-        error("Unknown database#{': ' + name unless name.empty?}. Valid options are: #{hpg_databases.keys.sort.join(", ")}")
-      end
-
-      return found_attachment
-    end
-  end
-
-  def hpg_translate_fork_and_follow(addon, config)
-    $stderr.puts " !    #hpg_translate_fork_and_follow is deprecated. Update your plugins."
-    hpg_translate_db_opts_to_urls(addon, config)
-  end
-
-  def hpg_translate_db_opts_to_urls(addon, config)
-    bot_name = bot rescue nil
-    resolver = Resolver.new(bot_name, api)
-    if addon =~ /^#{resolver.hpg_addon_name}/
-      %w[fork follow rollback].each do |opt|
-        if val = config[opt]
-          unless val.is_a?(String)
-            error("--#{opt} requires a database argument.")
-          end
-
-          uri = URI.parse(val) rescue nil
-          if uri && uri.scheme && uri.scheme == 'postgres'
-            argument_url = uri.to_s
-          else
-            attachment = resolver.resolve(val)
-            if attachment.starter_plan?
-              error("#{opt.tr 'f', 'F'} is only available on production databases.")
-            end
-            argument_url = attachment.url
-          end
-
-          config[opt] = argument_url
-        end
-      end
-    end
-  end
-
-  private
-
-  def hpg_promote(url)
-    api.put_config_vars(bot, "DATABASE_URL" => url)
-  end
-
-end