mini-clean-kit 0.0.1

data/spring-4.7.0/lib/spring/client.rb

@@ -0,0 +1,48 @@
+require "spring/errors"
+require "spring/json"
+
+require "spring/client/command"
+require "spring/client/run"
+require "spring/client/help"
+require "spring/client/binstub"
+require "spring/client/stop"
+require "spring/client/status"
+require "spring/client/rails"
+require "spring/client/version"
+require "spring/client/server"
+
+module Spring
+  module Client
+    COMMANDS = {
+      "help"      => Client::Help,
+      "-h"        => Client::Help,
+      "--help"    => Client::Help,
+      "binstub"   => Client::Binstub,
+      "stop"      => Client::Stop,
+      "status"    => Client::Status,
+      "rails"     => Client::Rails,
+      "-v"        => Client::Version,
+      "--version" => Client::Version,
+      "server"    => Client::Server,
+    }
+
+    def self.run(args)
+      command_for(args.first).call(args)
+    rescue CommandNotFound
+      Client::Help.call(args)
+    rescue ClientError => e
+      $stderr.puts e.message
+      exit 1
+    end
+
+    def self.command_for(name)
+      COMMANDS[name] || Client::Run
+    end
+  end
+end
+
+# allow users to add hooks that do not run in the server
+# or modify start/stop
+if File.exist?("config/spring_client.rb")
+  require "./config/spring_client.rb"
+end

data/spring-4.7.0/lib/spring/command_wrapper.rb

@@ -0,0 +1,82 @@
+require "spring/configuration"
+
+module Spring
+  class CommandWrapper
+    attr_reader :name, :command
+
+    def initialize(name, command = nil)
+      @name    = name
+      @command = command
+      @setup   = false
+    end
+
+    def description
+      if command.respond_to?(:description)
+        command.description
+      else
+        "Runs the #{name} command"
+      end
+    end
+
+    def setup?
+      @setup
+    end
+
+    def setup
+      if !setup? && command.respond_to?(:setup)
+        command.setup
+        @setup = true
+        return true
+      else
+        @setup = true
+        return false
+      end
+    end
+
+    def call
+      if command.respond_to?(:call)
+        command.call
+      else
+        load exec
+      end
+    end
+
+    def gem_name
+      if command.respond_to?(:gem_name)
+        command.gem_name
+      else
+        exec_name
+      end
+    end
+
+    def exec_name
+      if command.respond_to?(:exec_name)
+        command.exec_name
+      else
+        name
+      end
+    end
+
+    def binstub
+      Spring.application_root_path.join(binstub_name)
+    end
+
+    def binstub_name
+      "bin/#{name}"
+    end
+
+    def exec
+      if binstub.exist?
+        binstub.to_s
+      else
+        Gem.bin_path(gem_name, exec_name)
+      end
+    end
+
+    def env(args)
+      if command.respond_to?(:env)
+        command.env(args)
+      end
+    end
+  end
+end

data/spring-4.7.0/lib/spring/commands/rails.rb

@@ -0,0 +1,112 @@
+module Spring
+  module Commands
+    class Rails
+      def call
+        ARGV.unshift command_name
+        load Dir.glob(::Rails.root.join("{bin,script}/rails")).first
+      end
+
+      def description
+        nil
+      end
+    end
+
+    class RailsConsole < Rails
+      def env(args)
+        return args.first if args.first && !args.first.index("-")
+
+        environment = nil
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "console"
+      end
+    end
+
+    class RailsGenerate < Rails
+      def command_name
+        "generate"
+      end
+    end
+
+    class RailsDestroy < Rails
+      def command_name
+        "destroy"
+      end
+    end
+
+    class RailsRunner < Rails
+      def call
+        ARGV.replace extract_environment(ARGV).first
+        super
+      end
+
+      def env(args)
+        extract_environment(args).last
+      end
+
+      def command_name
+        "runner"
+      end
+
+      def extract_environment(args)
+        environment = nil
+
+        args = args.select.with_index { |arg, i|
+          case arg
+          when "-e"
+            false
+          when /--environment=(\w+)/
+            environment = $1
+            false
+          else
+            if i > 0 && args[i - 1] == "-e"
+              environment = arg
+              false
+            else
+              true
+            end
+          end
+        }
+
+        [args, environment]
+      end
+    end
+
+    class RailsTest < Rails
+      def env(args)
+        environment = "test"
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "test"
+      end
+    end
+
+    Spring.register_command "rails_console",  RailsConsole.new
+    Spring.register_command "rails_generate", RailsGenerate.new
+    Spring.register_command "rails_destroy",  RailsDestroy.new
+    Spring.register_command "rails_runner",   RailsRunner.new
+    Spring.register_command "rails_test",     RailsTest.new
+  end
+end

data/spring-4.7.0/lib/spring/commands/rake.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Commands
+    class Rake
+      class << self
+        attr_accessor :environment_matchers
+      end
+
+      self.environment_matchers = {
+        :default     => "test",
+        /^test($|:)/ => "test"
+      }
+
+      def env(args)
+        # This is an adaption of the matching that Rake itself does.
+        # See: https://github.com/jimweirich/rake/blob/3754a7639b3f42c2347857a0878beb3523542aee/lib/rake/application.rb#L691-L692
+        if env = args.grep(/^(RAILS|RACK)_ENV=(.*)$/m).last
+          return env.split("=").last
+        end
+
+        self.class.environment_matchers.each do |matcher, environment|
+          return environment if matcher === (args.first || :default)
+        end
+
+        nil
+      end
+    end
+
+    Spring.register_command "rake", Rake.new
+  end
+end

data/spring-4.7.0/lib/spring/commands.rb

@@ -0,0 +1,57 @@
+require "spring/watcher"
+require "spring/command_wrapper"
+
+module Spring
+  @commands = {}
+
+  class << self
+    attr_reader :commands
+  end
+
+  def self.register_command(name, command = nil)
+    commands[name] = CommandWrapper.new(name, command)
+  end
+
+  def self.command?(name)
+    commands.include? name
+  end
+
+  def self.command(name)
+    commands.fetch name
+  end
+
+  require "spring/commands/rails"
+  require "spring/commands/rake"
+
+  # Load custom commands, if any.
+  # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("~/.spring.rb")
+  require config if File.exist?(config)
+
+  # We force the TTY so bundler doesn't show a backtrace in case gems are missing.
+  old_env = ENV["BUNDLER_FORCE_TTY"]
+  ENV["BUNDLER_FORCE_TTY"] = "true"
+  begin
+    # If the config/spring.rb contains requires for commands from other gems,
+    # then we need to be under bundler.
+    require "bundler/setup"
+  ensure
+    ENV["BUNDLER_FORCE_TTY"] = old_env
+  end
+
+  # Auto-require any Spring extensions which are in the Gemfile
+  Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
+    begin
+      require command
+    rescue LoadError => error
+      if error.message.include?(command)
+        require command.gsub("-", "/")
+      else
+        raise
+      end
+    end
+  end
+
+  config = File.expand_path("./config/spring.rb")
+  require config if File.exist?(config)
+end

data/spring-4.7.0/lib/spring/configuration.rb

@@ -0,0 +1,99 @@
+require "spring/errors"
+
+module Spring
+  @connect_timeout = 5
+  @boot_timeout = 20
+  @dangerously_allow_disabling_reloading = false
+
+  class << self
+    attr_accessor :application_root, :connect_timeout, :boot_timeout
+    attr_writer :quiet
+
+    # Opt-in: skip the `:ensure_reloading_is_enabled` initializer so Spring
+    # boots with `config.enable_reloading = false`. Default `false`. See
+    # README "Running Spring with reloading disabled" for what this gives up.
+    attr_accessor :dangerously_allow_disabling_reloading
+
+    def gemfile
+      require "bundler"
+
+      if /\s1.9.[0-9]/ ===  Bundler.ruby_scope.gsub(/[\/\s]+/,'')
+        Pathname.new(ENV["BUNDLE_GEMFILE"] || "Gemfile").expand_path
+      else
+        Bundler.default_gemfile
+      end
+    end
+
+    def gemfile_lock
+      case gemfile.to_s
+      when /\bgems\.rb\z/
+        gemfile.sub_ext('.locked')
+      else
+        gemfile.sub_ext('.lock')
+      end
+    end
+
+    def after_fork_callbacks
+      @after_fork_callbacks ||= []
+    end
+
+    def after_fork(&block)
+      after_fork_callbacks << block
+    end
+
+    def after_environment_load_callbacks
+      @after_environment_load_callbacks ||= []
+    end
+
+    def after_environment_load(&block)
+      after_environment_load_callbacks << block
+    end
+
+    def spawn_on_env
+      @spawn_on_env ||= []
+    end
+
+    def reset_on_env
+      @reset_on_env ||= []
+    end
+
+    def verify_environment
+      application_root_path
+    end
+
+    def application_root_path
+      @application_root_path ||= begin
+        if application_root
+          path = Pathname.new(File.expand_path(application_root))
+        else
+          path = project_root_path
+        end
+
+        raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
+        path
+      end
+    end
+
+    def project_root_path
+      @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
+    end
+
+    def quiet
+      @quiet || ENV.key?('SPRING_QUIET')
+    end
+
+    private
+
+    def find_project_root(current_dir)
+      if current_dir.join(gemfile).exist?
+        current_dir
+      elsif current_dir.root?
+        raise UnknownProject.new(Dir.pwd)
+      else
+        find_project_root(current_dir.parent)
+      end
+    end
+  end
+
+  self.quiet = false
+end

data/spring-4.7.0/lib/spring/env.rb

@@ -0,0 +1,115 @@
+require "pathname"
+
+require "spring/version"
+require "spring/configuration"
+
+module Spring
+  IGNORE_SIGNALS = %w(INT QUIT)
+  STOP_TIMEOUT = 2 # seconds
+
+  class Env
+    attr_reader :log_file
+
+    def initialize(options = {})
+      @root         = options[:root]
+      @project_root = options[:root]
+      @log_file     = options[:log_file] || File.open(ENV["SPRING_LOG"] || File::NULL, "a")
+    end
+
+    def root
+      @root ||= Spring.application_root_path
+    end
+
+    def project_root
+      @project_root ||= Spring.project_root_path
+    end
+
+    def version
+      Spring::VERSION
+    end
+
+    def tmp_path
+      require "tmpdir"
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
+      require "fileutils"
+      FileUtils.mkdir_p(path) unless path.exist?
+      path
+    end
+
+    def application_id
+      require "digest/md5"
+      ENV["SPRING_APPLICATION_ID"] || Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
+    end
+
+    def socket_path
+      Pathname.new(ENV["SPRING_SOCKET"] || tmp_path.join(application_id))
+    end
+
+    def socket_name
+      socket_path.to_s
+    end
+
+    def pidfile_path
+      Pathname.new(ENV["SPRING_PIDFILE"] || socket_path.dirname.join("#{socket_path.basename(".*")}.pid"))
+    end
+
+    def pid
+      pidfile_path.exist? ? pidfile_path.read.to_i : nil
+    rescue Errno::ENOENT
+      # This can happen if the pidfile is removed after we check it
+      # exists
+    end
+
+    def app_name
+      root.basename
+    end
+
+    def server_running?
+      pidfile = pidfile_path.open('r+')
+      !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+    rescue Errno::ENOENT
+      false
+    ensure
+      if pidfile
+        pidfile.flock(File::LOCK_UN)
+        pidfile.close
+      end
+    end
+
+    def log(message)
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
+      log_file.flush
+    end
+
+    def stop
+      if server_running?
+        timeout = Time.now + STOP_TIMEOUT
+        kill 'TERM'
+        sleep 0.1 until !server_running? || Time.now >= timeout
+
+        if server_running?
+          kill 'KILL'
+          :killed
+        else
+          :stopped
+        end
+      else
+        :not_running
+      end
+    end
+
+    def kill(sig)
+      pid = self.pid
+      Process.kill(sig, pid) if pid
+    rescue Errno::ESRCH
+      # already dead
+    end
+
+    def server_command
+      ENV["SPRING_SERVER_COMMAND"] || "#{File.expand_path("../../../bin/spring", __FILE__)} server --background"
+    end
+  end
+end

data/spring-4.7.0/lib/spring/errors.rb

@@ -0,0 +1,36 @@
+module Spring
+  class ClientError < StandardError; end
+
+  class UnknownProject < StandardError
+    attr_reader :current_dir
+
+    def initialize(current_dir)
+      @current_dir = current_dir
+    end
+
+    def message
+      "Spring was unable to locate the root of your project. There was no Gemfile " \
+        "present in the current directory (#{current_dir}) or any of the parent " \
+        "directories."
+    end
+  end
+
+  class MissingApplication < ClientError
+    attr_reader :project_root
+
+    def initialize(project_root)
+      @project_root = project_root
+    end
+
+    def message
+      "Spring was unable to find your config/application.rb file. " \
+        "Your project root was detected at #{project_root}, so Spring " \
+        "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
+        "configure the root of your application by setting Spring.application_root in " \
+        "config/spring.rb."
+    end
+  end
+
+  class CommandNotFound < ClientError
+  end
+end

data/spring-4.7.0/lib/spring/failsafe_thread.rb

@@ -0,0 +1,14 @@
+require 'thread'
+
+module Spring
+  class << self
+    def failsafe_thread
+      Thread.new {
+        begin
+          yield
+        rescue
+        end
+      }
+    end
+  end
+end