dry-web-roda 0.13.1 → 0.14.0

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-require "pry-byebug"
-
-SPEC_ROOT = Pathname(__dir__)
-TEST_APP_NAME = "test_app".freeze
-
-Dir[SPEC_ROOT.join("support/*.rb").to_s].each { |f| require f }
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-
-  config.example_status_persistence_file_path = "spec/examples.txt"
-
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  config.default_formatter = "doc" if config.files_to_run.one?
-
-  config.profile_examples = 10
-
-  config.order = :random
-  Kernel.srand config.seed
-end

data/spec/support/app.rb

@@ -1,64 +0,0 @@
-require "net/http"
-require "uri"
-require "waitutil"
-require_relative "silently"
-
-module RSpec
-  module Support
-    module App
-      private
-
-      class RunningApp
-        attr_reader :port
-
-        def initialize(port)
-          @port = port
-        end
-
-        def get(path)
-          Net::HTTP.get(uri(path))
-        end
-
-        private
-
-        def uri(path)
-          URI("http://0.0.0.0:#{port}#{path}")
-        end
-      end
-
-      def run_app(host: "0.0.0.0", port: "30333", timeout: 10)
-        cmd = "bundle exec rackup -o 0.0.0.0 -p #{port} config.ru"
-        out = Tempfile.new("dry-web-roda-out")
-
-        pid = fork {
-          Bundler.with_clean_env do
-            exec cmd, out: out.path, err: out.path
-          end
-        }
-
-        WaitUtil.wait_for_condition "app available on #{host}:#{port}", timeout_sec: timeout do
-          begin
-            result = WaitUtil.send(:is_tcp_port_open, host, port, WaitUtil::DEFAULT_DELAY_SEC)
-
-            result || begin
-              out.rewind
-              [false, "#{cmd} failed:\n#{out.read}"]
-            end
-          rescue SocketError
-            out.rewind
-            [false, "#{cmd} failed:\n#{out.read}"]
-          end
-        end
-
-        yield RunningApp.new(port)
-      ensure
-        Process.kill "TERM", pid
-        Process.wait pid
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::App, type: :cli
-end

data/spec/support/bundler.rb

@@ -1,113 +0,0 @@
-require 'open3'
-require 'pathname'
-require_relative 'env'
-require_relative 'silently'
-require_relative 'files'
-
-module RSpec
-  module Support
-    module Bundler
-      def self.root
-        Pathname.new(__dir__).join("..", "..")
-      end
-
-      def self.cache
-        root.join("vendor", "cache")
-      end
-
-      def self.setup
-        return if cache.exist?
-
-        with_clean_env do
-          RSpec::Support.silently "./script/setup"
-        end
-      end
-
-      def self.with_clean_env(&blk)
-        ::Bundler.with_clean_env(&blk)
-      end
-
-      private
-
-      attr_reader :out, :err, :exitstatus
-
-      def setup_gemfile(gems: [], exclude_gems: [], path: "Gemfile")
-        filtered_content = ::File.readlines(path).
-                             drop(1).
-                             reject { |l| exclude_gems.any? { |g| l.include?(g) } }
-
-        content = ["source 'file://#{cache}'\n"] + filtered_content + gems.map { |g| "gem #{g}\n" }
-
-        rewrite(path, content)
-      end
-
-      def bundle_install
-        bundle "install --local --no-cache --retry 0 --no-color"
-      end
-
-      def bundle_exec(cmd, env: nil, &blk)
-        bundle("exec #{cmd}", env: env, &blk)
-      end
-
-      def bundle(cmd, env: nil, &blk)
-        ruby_bin   = which("ruby")
-        bundle_bin = which("bundle")
-        rack_env = "RACK_ENV=#{env} " unless env.nil?
-
-        system_exec("#{rack_env}#{ruby_bin} -I#{load_paths} #{bundle_bin} #{cmd}", &blk)
-      end
-
-      # Adapted from Bundler source code
-      #
-      # Bundler is released under MIT license
-      # https://github.com/bundler/bundler/blob/master/LICENSE.md
-      #
-      # A special "thank you" goes to Bundler maintainers and contributors.
-      #
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
-      def system_exec(cmd)
-        Open3.popen3(RSpec::Support::Env.env, cmd) do |stdin, stdout, stderr, wait_thr|
-          yield stdin, stdout, wait_thr if block_given?
-          stdin.close
-
-          @exitstatus = wait_thr && wait_thr.value.exitstatus
-          @out = Thread.new { stdout.read }.value.strip
-          @err = Thread.new { stderr.read }.value.strip
-        end
-
-        (@all_output ||= "") << [
-          "$ #{cmd.to_s.strip}",
-          out,
-          err,
-          @exitstatus ? "# $? => #{@exitstatus}" : "",
-          "\n"
-        ].reject(&:empty?).join("\n")
-
-        @out
-      end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/AbcSize
-
-      def load_paths
-        [root.join('lib'), root.join('spec')].join(':')
-      end
-
-      def root
-        RSpec::Support::Bundler.root
-      end
-
-      def cache
-        RSpec::Support::Bundler.cache
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::Bundler, type: :cli
-
-  config.before(:all, type: :cli) do
-    RSpec::Support::Bundler.setup
-  end
-end

data/spec/support/cli.rb

@@ -1,47 +0,0 @@
-require "aruba"
-require "aruba/api"
-require "pathname"
-
-module RSpec
-  module Support
-    module Cli
-      def self.included(spec)
-        spec.before do
-          aruba = Pathname.new(Dir.pwd).join('tmp', 'aruba')
-          aruba.rmtree if aruba.exist?
-
-          setup_aruba
-        end
-      end
-
-      private
-
-      def run_command(cmd, output = nil, exit_status: 0)
-        run_simple "bundle exec #{cmd}", fail_on_error: false
-
-        match_output(output)
-        expect(last_command_started).to have_exit_status(exit_status)
-      end
-
-      def match_output(output)
-        case output
-        when String
-          expect(all_output).to include(output)
-        when Regexp
-          expect(all_output).to match(output)
-        when Array
-          output.each { |o| match_output(o) }
-        end
-      end
-
-      def all_output
-        all_commands.map(&:output).join("\n")
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include Aruba::Api,          type: :cli
-  config.include RSpec::Support::Cli, type: :cli
-end

data/spec/support/directories.rb

@@ -1,37 +0,0 @@
-require "fileutils"
-
-module RSpec
-  module Support
-    module Directory
-      private
-
-      def with_directory(directory)
-        current = Dir.pwd
-        target  = Pathname.new(Dir.pwd).join(directory)
-
-        Dir.chdir(target)
-        yield
-      ensure
-        Dir.chdir(current)
-      end
-
-      def with_tmp_directory
-        dir = Pathname.new("tmp").join("aruba")
-
-        with_directory(dir) do
-          yield
-        end
-      ensure
-        FileUtils.rm_rf(dir)
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::Directory, type: :cli
-
-  config.before :suite do
-    Pathname.new(Dir.pwd).join("tmp").mkpath
-  end
-end

data/spec/support/env.rb

@@ -1,84 +0,0 @@
-require 'singleton'
-require 'thread'
-
-module RSpec
-  module Support
-    class Env
-      include Singleton
-
-      def self.setup
-        instance.__send__(:setup)
-      end
-
-      def self.reset
-        instance.__send__(:setup)
-      end
-
-      def self.env
-        instance.to_h
-      end
-
-      def self.[](key)
-        instance[key]
-      end
-
-      def self.[]=(key, value)
-        instance[key] = value
-      end
-
-      def self.fetch_from_original(key)
-        instance.__send__(:original).fetch(key)
-      end
-
-      def initialize
-        @original = ENV.to_hash
-        @mutex    = Mutex.new
-        setup
-      end
-
-      def [](key)
-        synchronize do
-          env[key]
-        end
-      end
-
-      def []=(key, value)
-        synchronize do
-          env[key] = value
-        end
-      end
-
-      def to_h
-        env.dup
-      end
-
-      private
-
-      attr_reader :original, :env
-
-      def setup
-        synchronize do
-          @env = {}
-        end
-
-        self["GEM_ROOT"] = original["GEM_ROOT"]
-        self["GEM_HOME"] = original["GEM_HOME"]
-        self["GEM_PATH"] = original["GEM_PATH"]
-      end
-
-      def synchronize(&blk)
-        @mutex.synchronize(&blk)
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.before(:suite) do
-    RSpec::Support::Env.setup
-  end
-
-  config.after do
-    RSpec::Support::Env.reset
-  end
-end

data/spec/support/files.rb

@@ -1,59 +0,0 @@
-module RSpec
-  module Support
-    module Files
-      private
-
-      def write(path, *content)
-        Pathname.new(path).dirname.mkpath
-        open(path, ::File::CREAT | ::File::WRONLY, *content)
-      end
-
-      def rewrite(path, *content)
-        open(path, ::File::TRUNC | ::File::WRONLY, *content)
-      end
-
-      def replace(path, target, replacement)
-        content = ::File.readlines(path)
-        content[index(content, path, target)] = "#{replacement}\n"
-
-        rewrite(path, content)
-      end
-
-      def replace_last(path, target, replacement)
-        content = ::File.readlines(path)
-        content[-index(content.reverse, path, target) - 1] = "#{replacement}\n"
-
-        rewrite(path, content)
-      end
-
-      def unshift(path, line)
-        content = ::File.readlines(path)
-        content.unshift("#{line}\n")
-
-        rewrite(path, content)
-      end
-
-      def append(path, contents)
-        content = ::File.readlines(path)
-        content << "#{contents}\n"
-
-        rewrite(path, content)
-      end
-
-      def open(path, mode, *content)
-        ::File.open(path, mode) do |file|
-          file.write(Array(content).flatten.join)
-        end
-      end
-
-      def index(content, path, target)
-        content.index { |l| l.include?(target) } or
-          raise ArgumentError.new("Cannot find `#{target}' inside `#{path}'.")
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::Files, type: :cli
-end

data/spec/support/project.rb

@@ -1,60 +0,0 @@
-require "waitutil"
-require_relative 'env'
-require_relative 'silently'
-require_relative 'bundler'
-require_relative 'directories'
-
-module RSpec
-  module Support
-    module Project
-      private
-
-      KNOWN_ARGUMENTS = [:arch].freeze
-
-      def with_project(name = "sandbox", **args)
-        with_tmp_directory do
-          create_project name, args
-
-          within_project_directory(name) do
-            setup_gemfile gems: ["'dry-web-roda', path: '#{root}'"], exclude_gems: ['dry-web-roda']
-            bundle_install
-            yield
-          end
-        end
-      end
-
-      def within_project_directory(project)
-        cd(project.to_s) do
-          # Aruba resets ENV and its API to set new env vars is broken.
-          #
-          # We need to manually setup the following env vars:
-          #
-          # ENV["PATH"] is required by Capybara's selenium/poltergeist drivers
-          ENV["PATH"] = RSpec::Support::Env.fetch_from_original("PATH")
-          # Bundler on CI can't find HOME and it fails to run Hanami commands
-          ENV["HOME"] = RSpec::Support::Env.fetch_from_original("HOME")
-
-          yield
-        end
-      end
-
-      def create_project(name, args)
-        silently "dry-web-roda new #{name} #{_create_project_args(args)}"
-      end
-
-      def _create_project_args(args)
-        return if args.empty?
-
-        flags = args.dup.keep_if { |k, _| KNOWN_ARGUMENTS.include?(k) }
-
-        flags.map { |arg, value|
-          "--#{arg}=#{value}"
-        }.join(" ")
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::Project, type: :cli
-end