piko-fast-tool 0.0.1

data/capistrano-3.20.1/lib/capistrano/configuration/servers.rb

@@ -0,0 +1,76 @@
+require "set"
+require "capistrano/configuration"
+require "capistrano/configuration/filter"
+
+module Capistrano
+  class Configuration
+    class Servers
+      include Enumerable
+
+      def add_host(host, properties={})
+        new_host = Server[host]
+        new_host.port = properties[:port] if properties.key?(:port)
+        # This matching logic must stay in sync with `Server#matches?`.
+        key = ServerKey.new(new_host.hostname, new_host.port)
+        existing = servers_by_key[key]
+        if existing
+          existing.user = new_host.user if new_host.user
+          existing.with(properties)
+        else
+          servers_by_key[key] = new_host.with(properties)
+        end
+      end
+
+      # rubocop:disable Security/MarshalLoad
+      def add_role(role, hosts, options={})
+        options_deepcopy = Marshal.dump(options.merge(roles: role))
+        Array(hosts).each { |host| add_host(host, Marshal.load(options_deepcopy)) }
+      end
+      # rubocop:enable Security/MarshalLoad
+
+      def roles_for(names)
+        options = extract_options(names)
+        s = Filter.new(:role, names).filter(servers_by_key.values)
+        s.select { |server| server.select?(options) }
+      end
+
+      def role_properties_for(rolenames)
+        roles = rolenames.to_set
+        rps = Set.new unless block_given?
+        roles_for(rolenames).each do |host|
+          host.roles.intersection(roles).each do |role|
+            [host.properties.fetch(role)].flatten(1).each do |props|
+              if block_given?
+                yield host, role, props
+              else
+                rps << (props || {}).merge(role: role, hostname: host.hostname)
+              end
+            end
+          end
+        end
+        block_given? ? nil : rps
+      end
+
+      def fetch_primary(role)
+        hosts = roles_for([role])
+        hosts.find(&:primary) || hosts.first
+      end
+
+      def each
+        servers_by_key.values.each { |server| yield server }
+      end
+
+      private
+
+      ServerKey = Struct.new(:hostname, :port)
+
+      def servers_by_key
+        @servers_by_key ||= {}
+      end
+
+      def extract_options(array)
+        array.last.is_a?(::Hash) ? array.pop : {}
+      end
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/configuration/validated_variables.rb

@@ -0,0 +1,110 @@
+require "capistrano/proc_helpers"
+require "delegate"
+
+module Capistrano
+  class Configuration
+    # Decorates a Variables object to additionally perform an optional set of
+    # user-supplied validation rules. Each rule for a given key is invoked
+    # immediately whenever `set` is called with a value for that key.
+    #
+    # If `set` is called with a callable value or a block, validation is not
+    # performed immediately. Instead, the validation rules are invoked the first
+    # time `fetch` is used to access the value.
+    #
+    # A rule is simply a block that accepts two arguments: key and value. It is
+    # up to the rule to raise an exception when it deems the value is invalid
+    # (or just print a warning).
+    #
+    # Rules can be registered using the DSL like this:
+    #
+    #   validate(:my_key) do |key, value|
+    #     # rule goes here
+    #   end
+    #
+    class ValidatedVariables < SimpleDelegator
+      include Capistrano::ProcHelpers
+
+      def initialize(variables)
+        super(variables)
+        @validators = {}
+      end
+
+      # Decorate Variables#set to add validation behavior.
+      def set(key, value=nil, &block)
+        assert_value_or_block_not_both(value, block)
+
+        # Skip validation behavior if no validators are registered for this key
+        return super unless validators.key?(key)
+
+        value_to_evaluate = block || value
+
+        if callable_without_parameters?(value_to_evaluate)
+          super(key, assert_valid_later(key, value_to_evaluate), &nil)
+        else
+          assert_valid_now(key, value_to_evaluate)
+          super
+        end
+      end
+
+      # Register a validation rule for the given key.
+      def validate(key, &validator)
+        vs = (validators[key] || [])
+        vs << validator
+        validators[key] = vs
+      end
+
+      private
+
+      attr_reader :validators
+
+      # Given a callable that provides a value, wrap the callable with another
+      # object that responds to `call`. This new object will perform validation
+      # and then return the original callable's value.
+      #
+      # If the callable is a `Question`, the object returned by this method will
+      # also be a `Question` (a `ValidatedQuestion`, to be precise). This
+      # ensures that `is_a?(Question)` remains true even after the validation
+      # wrapper is applied. This is needed so that `Configuration#is_question?`
+      # works as expected.
+      #
+      def assert_valid_later(key, callable)
+        validation_callback = proc do
+          value = callable.call
+          assert_valid_now(key, value)
+          value
+        end
+
+        if callable.is_a?(Question)
+          ValidatedQuestion.new(validation_callback)
+        else
+          validation_callback
+        end
+      end
+
+      # Runs all validation rules registered for the given key against the
+      # user-supplied value for that variable. If no validator raises an
+      # exception, the value is assumed to be valid.
+      def assert_valid_now(key, value)
+        validators[key].each do |validator|
+          validator.call(key, value)
+        end
+      end
+
+      def assert_value_or_block_not_both(value, block)
+        return if value.nil? || block.nil?
+        raise Capistrano::ValidationError,
+              "Value and block both passed to Configuration#set"
+      end
+
+      class ValidatedQuestion < Question
+        def initialize(validator)
+          @validator = validator
+        end
+
+        def call
+          @validator.call
+        end
+      end
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/configuration/variables.rb

@@ -0,0 +1,112 @@
+require "capistrano/proc_helpers"
+
+module Capistrano
+  class Configuration
+    # Holds the variables assigned at Capistrano runtime via `set` and retrieved
+    # with `fetch`. Does internal bookkeeping to help identify user mistakes
+    # like spelling errors or unused variables that may lead to unexpected
+    # behavior.
+    class Variables
+      CAPISTRANO_LOCATION = File.expand_path("../..", __FILE__).freeze
+      IGNORED_LOCATIONS = [
+        "#{CAPISTRANO_LOCATION}/configuration/variables.rb:",
+        "#{CAPISTRANO_LOCATION}/configuration.rb:",
+        "#{CAPISTRANO_LOCATION}/dsl/env.rb:",
+        "/dsl.rb:",
+        "/forwardable.rb:"
+      ].freeze
+      private_constant :CAPISTRANO_LOCATION, :IGNORED_LOCATIONS
+
+      include Capistrano::ProcHelpers
+
+      def initialize(values={})
+        @trusted_keys = []
+        @fetched_keys = []
+        @locations = {}
+        @values = values
+        @trusted = true
+      end
+
+      def untrusted!
+        @trusted = false
+        yield
+      ensure
+        @trusted = true
+      end
+
+      def set(key, value=nil, &block)
+        @trusted_keys << key if trusted? && !@trusted_keys.include?(key)
+        remember_location(key)
+        values[key] = block || value
+        trace_set(key)
+        values[key]
+      end
+
+      def fetch(key, default=nil, &block)
+        fetched_keys << key unless fetched_keys.include?(key)
+        peek(key, default, &block)
+      end
+
+      # Internal use only.
+      def peek(key, default=nil, &block)
+        value = fetch_for(key, default, &block)
+        while callable_without_parameters?(value)
+          value = (values[key] = value.call)
+        end
+        value
+      end
+
+      def fetch_for(key, default, &block)
+        block ? values.fetch(key, &block) : values.fetch(key, default)
+      end
+
+      def delete(key)
+        values.delete(key)
+      end
+
+      def trusted_keys
+        @trusted_keys.dup
+      end
+
+      def untrusted_keys
+        keys - @trusted_keys
+      end
+
+      def keys
+        values.keys
+      end
+
+      # Keys that have been set, but which have never been fetched.
+      def unused_keys
+        keys - fetched_keys
+      end
+
+      # Returns an array of source file location(s) where the given key was
+      # assigned (i.e. where `set` was called). If the key was never assigned,
+      # returns `nil`.
+      def source_locations(key)
+        locations[key]
+      end
+
+      private
+
+      attr_reader :locations, :values, :fetched_keys
+
+      def trusted?
+        @trusted
+      end
+
+      def remember_location(key)
+        location = caller.find do |line|
+          IGNORED_LOCATIONS.none? { |i| line.include?(i) }
+        end
+        (locations[key] ||= []) << location
+      end
+
+      def trace_set(key)
+        return unless fetch(:print_config_variables, false)
+        puts "Config variable set: #{key.inspect} => #{values[key].inspect}"
+      end
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/configuration.rb

@@ -0,0 +1,189 @@
+require_relative "configuration/filter"
+require_relative "configuration/question"
+require_relative "configuration/plugin_installer"
+require_relative "configuration/server"
+require_relative "configuration/servers"
+require_relative "configuration/validated_variables"
+require_relative "configuration/variables"
+
+module Capistrano
+  class ValidationError < RuntimeError; end
+
+  class Configuration
+    def self.env
+      @env ||= new
+    end
+
+    def self.reset!
+      @env = new
+    end
+
+    extend Forwardable
+    attr_reader :variables
+    def_delegators :variables,
+                   :set, :fetch, :fetch_for, :delete, :keys, :validate
+
+    def initialize(values={})
+      @variables = ValidatedVariables.new(Variables.new(values))
+    end
+
+    def ask(key, default=nil, options={})
+      question = Question.new(key, default, options)
+      set(key, question)
+    end
+
+    def set_if_empty(key, value=nil, &block)
+      set(key, value, &block) unless keys.include?(key)
+    end
+
+    def append(key, *values)
+      set(key, Array(fetch(key)).concat(values))
+    end
+
+    def remove(key, *values)
+      set(key, Array(fetch(key)) - values)
+    end
+
+    def any?(key)
+      value = fetch(key)
+      if value && value.respond_to?(:any?)
+        begin
+          return value.any?
+        rescue ArgumentError
+          # Gracefully ignore values whose `any?` method doesn't accept 0 args
+        end
+      end
+
+      !value.nil?
+    end
+
+    def is_question?(key)
+      value = fetch_for(key, nil)
+      !value.nil? && value.is_a?(Question)
+    end
+
+    def role(name, hosts, options={})
+      if name == :all
+        raise ArgumentError, "#{name} reserved name for role. Please choose another name"
+      end
+
+      servers.add_role(name, hosts, options)
+    end
+
+    def server(name, properties={})
+      servers.add_host(name, properties)
+    end
+
+    def roles_for(names)
+      servers.roles_for(names)
+    end
+
+    def role_properties_for(names, &block)
+      servers.role_properties_for(names, &block)
+    end
+
+    def primary(role)
+      servers.fetch_primary(role)
+    end
+
+    def backend
+      @backend ||= SSHKit
+    end
+
+    attr_writer :backend
+
+    def configure_backend
+      backend.configure do |sshkit|
+        configure_sshkit_output(sshkit)
+        sshkit.output_verbosity = fetch(:log_level)
+        sshkit.default_env      = fetch(:default_env)
+        sshkit.backend          = fetch(:sshkit_backend, SSHKit::Backend::Netssh)
+        sshkit.backend.configure do |backend|
+          backend.pty                = fetch(:pty)
+          backend.connection_timeout = fetch(:connection_timeout)
+          backend.ssh_options        = (backend.ssh_options || {}).merge(fetch(:ssh_options, {}))
+        end
+      end
+    end
+
+    def configure_scm
+      Capistrano::Configuration::SCMResolver.new.resolve
+    end
+
+    def timestamp
+      @timestamp ||= Time.now.utc
+    end
+
+    def add_filter(filter=nil, &block)
+      if block
+        raise ArgumentError, "Both a block and an object were given" if filter
+
+        filter = Object.new
+        def filter.filter(servers)
+          block.call(servers)
+        end
+      elsif !filter.respond_to? :filter
+        raise TypeError, "Provided custom filter <#{filter.inspect}> does " \
+                         "not have a public 'filter' method"
+      end
+      @custom_filters ||= []
+      @custom_filters << filter
+    end
+
+    def setup_filters
+      @filters = cmdline_filters
+      @filters += @custom_filters if @custom_filters
+      @filters << Filter.new(:role, ENV["ROLES"]) if ENV["ROLES"]
+      @filters << Filter.new(:host, ENV["HOSTS"]) if ENV["HOSTS"]
+      fh = fetch_for(:filter, {}) || {}
+      @filters << Filter.new(:host, fh[:hosts]) if fh[:hosts]
+      @filters << Filter.new(:role, fh[:roles]) if fh[:roles]
+      @filters << Filter.new(:host, fh[:host]) if fh[:host]
+      @filters << Filter.new(:role, fh[:role]) if fh[:role]
+    end
+
+    def add_cmdline_filter(type, values)
+      cmdline_filters << Filter.new(type, values)
+    end
+
+    def filter(list)
+      setup_filters if @filters.nil?
+      @filters.reduce(list) { |l, f| f.filter l }
+    end
+
+    def dry_run?
+      fetch(:sshkit_backend) == SSHKit::Backend::Printer
+    end
+
+    def install_plugin(plugin, load_hooks: true, load_immediately: false)
+      installer.install(plugin,
+                        load_hooks: load_hooks,
+                        load_immediately: load_immediately)
+    end
+
+    def scm_plugin_installed?
+      installer.scm_installed?
+    end
+
+    def servers
+      @servers ||= Servers.new
+    end
+
+    private
+
+    def cmdline_filters
+      @cmdline_filters ||= []
+    end
+
+    def installer
+      @installer ||= PluginInstaller.new
+    end
+
+    def configure_sshkit_output(sshkit)
+      format_args = [fetch(:format)]
+      format_args.push(fetch(:format_options)) if any?(:format_options)
+
+      sshkit.use_format(*format_args)
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/console.rb

@@ -0,0 +1 @@
+load File.expand_path("../tasks/console.rake", __FILE__)

data/capistrano-3.20.1/lib/capistrano/defaults.rb

@@ -0,0 +1,36 @@
+validate :application do |_key, value|
+  changed_value = value.gsub(/[^A-Z0-9\.\-]/i, "_")
+  if value != changed_value
+    warn %Q(The :application value "#{value}" is invalid!)
+    warn "Use only letters, numbers, hyphens, dots, and underscores. For example:"
+    warn "  set :application, '#{changed_value}'"
+    raise Capistrano::ValidationError
+  end
+end
+
+%i(git_strategy hg_strategy svn_strategy).each do |strategy|
+  validate(strategy) do |key, _value|
+    warn(
+      "[Deprecation Warning] #{key} is deprecated and will be removed in "\
+      "Capistrano 3.7.0.\n"\
+      "https://github.com/capistrano/capistrano/blob/master/UPGRADING-3.7.md"
+    )
+  end
+end
+
+# We use a special :_default_git value so that SCMResolver can tell whether the
+# default has been replaced by the user via `set`.
+set_if_empty :scm, Capistrano::Configuration::SCMResolver::DEFAULT_GIT
+set_if_empty :branch, "master"
+set_if_empty :deploy_to, -> { "/var/www/#{fetch(:application)}" }
+set_if_empty :tmp_dir, "/tmp"
+
+set_if_empty :default_env, {}
+set_if_empty :keep_releases, 5
+
+set_if_empty :format, :airbrussh
+set_if_empty :log_level, :debug
+
+set_if_empty :pty, false
+
+set_if_empty :local_user, -> { ENV["USER"] || ENV["LOGNAME"] || ENV["USERNAME"] }

data/capistrano-3.20.1/lib/capistrano/deploy.rb

@@ -0,0 +1,3 @@
+require "capistrano/framework"
+
+load File.expand_path("../tasks/deploy.rake", __FILE__)

data/capistrano-3.20.1/lib/capistrano/doctor/environment_doctor.rb

@@ -0,0 +1,19 @@
+require "capistrano/doctor/output_helpers"
+
+module Capistrano
+  module Doctor
+    class EnvironmentDoctor
+      include Capistrano::Doctor::OutputHelpers
+
+      def call
+        title("Environment")
+        puts <<-OUT.gsub(/^\s+/, "")
+          Ruby     #{RUBY_DESCRIPTION}
+          Rubygems #{Gem::VERSION}
+          Bundler  #{defined?(Bundler::VERSION) ? Bundler::VERSION : 'N/A'}
+          Command  #{$PROGRAM_NAME} #{ARGV.join(' ')}
+        OUT
+      end
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/doctor/gems_doctor.rb

@@ -0,0 +1,45 @@
+require "capistrano/doctor/output_helpers"
+
+module Capistrano
+  module Doctor
+    # Prints table of all Capistrano-related gems and their version numbers. If
+    # there is a newer version of a gem available, call attention to it.
+    class GemsDoctor
+      include Capistrano::Doctor::OutputHelpers
+
+      def call
+        title("Gems")
+        table(all_gem_names) do |gem, row|
+          row.yellow if update_available?(gem)
+          row << gem
+          row << installed_gem_version(gem)
+          row << "(update available)" if update_available?(gem)
+        end
+      end
+
+      private
+
+      def installed_gem_version(gem_name)
+        Gem.loaded_specs[gem_name].version
+      end
+
+      def update_available?(gem_name)
+        latest = Gem.latest_version_for(gem_name)
+        return false if latest.nil?
+        latest > installed_gem_version(gem_name)
+      end
+
+      def all_gem_names
+        core_gem_names + plugin_gem_names
+      end
+
+      def core_gem_names
+        %w(capistrano airbrussh rake sshkit net-ssh) & Gem.loaded_specs.keys
+      end
+
+      def plugin_gem_names
+        (Gem.loaded_specs.keys - ["capistrano"]).grep(/capistrano/).sort
+      end
+    end
+  end
+end

data/capistrano-3.20.1/lib/capistrano/doctor/output_helpers.rb

@@ -0,0 +1,79 @@
+module Capistrano
+  module Doctor
+    # Helper methods for pretty-printing doctor output to stdout. All output
+    # (other than `title`) is indented by four spaces to facilitate copying and
+    # pasting this output into e.g. GitHub or Stack Overflow to achieve code
+    # formatting.
+    module OutputHelpers
+      class Row
+        attr_reader :color
+        attr_reader :values
+
+        def initialize
+          @values = []
+        end
+
+        def <<(value)
+          values << value
+        end
+
+        def yellow
+          @color = :yellow
+        end
+      end
+
+      # Prints a table for a given array of records. For each record, the block
+      # is yielded two arguments: the record and a Row object. To print values
+      # for that record, add values using `row << "some value"`. A row can
+      # optionally be highlighted in yellow using `row.yellow`.
+      def table(records, &block)
+        return if records.empty?
+        rows = collect_rows(records, &block)
+        col_widths = calculate_column_widths(rows)
+
+        rows.each do |row|
+          line = row.values.each_with_index.map do |value, col|
+            value.to_s.ljust(col_widths[col])
+          end.join(" ").rstrip
+          line = color.colorize(line, row.color) if row.color
+          puts line
+        end
+      end
+
+      # Prints a title in blue with surrounding newlines.
+      def title(text)
+        # Use $stdout directly to bypass the indentation that our `puts` does.
+        $stdout.puts(color.colorize("\n#{text}\n", :blue))
+      end
+
+      # Prints text in yellow.
+      def warning(text)
+        puts color.colorize(text, :yellow)
+      end
+
+      # Override `Kernel#puts` to prepend four spaces to each line.
+      def puts(string=nil)
+        $stdout.puts(string.to_s.gsub(/^/, "    "))
+      end
+
+      private
+
+      def collect_rows(records)
+        records.map do |rec|
+          Row.new.tap { |row| yield(rec, row) }
+        end
+      end
+
+      def calculate_column_widths(rows)
+        num_columns = rows.map { |row| row.values.length }.max
+        Array.new(num_columns) do |col|
+          rows.map { |row| row.values[col].to_s.length }.max
+        end
+      end
+
+      def color
+        @color ||= SSHKit::Color.new($stdout)
+      end
+    end
+  end
+end