rspec-bash-x 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c43c7fbf3a490d9c1de3f55d518a1dfe6a368f3
+  data.tar.gz: 5825ea963d9d70acddb25193711f215260a715ea
+SHA512:
+  metadata.gz: 6feba6cddfa852151ab182b599bc33f77269b8caffb835b6c50d3fd44c7f06a6cadef43729f5956411979b3d3bc043031bcea386717922688efc65e29384d1fd
+  data.tar.gz: 9f5724c6fee93438e390ff151b6a34d0af3a13464f828721fca0e79dae967f3a77b6aff3898212083165a918ba8c5820dacc2fc881ed08536fd5b31016d93f7f

data/ext/rspec-mocks/space.rb

@@ -0,0 +1,24 @@
+require 'rspec/mocks'
+require 'rspec/mocks/space'
+
+require_relative '../../lib/rspec/bash/mocks/script_proxy'
+require_relative '../../lib/rspec/bash/script'
+
+module RSpec
+  module Mocks
+    class Space
+      alias __rspec_bash_proxy_for proxy_for
+
+      def proxy_for(object)
+        return __rspec_bash_proxy_for(object) unless object.is_a?(RSpec::Bash::Script)
+
+        proxy_mutex.synchronize do
+          id = id_for(object)
+          proxies.fetch(id) do
+            proxies[id] = RSpec::Bash::Mocks::ScriptProxy.new(object, @expectation_ordering)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash.rb

@@ -0,0 +1,25 @@
+require_relative './bash/configuration'
+require_relative './bash/fd'
+require_relative './bash/noisy_thread'
+require_relative './bash/open3'
+require_relative './bash/script'
+require_relative './bash/script_evaluator'
+require_relative './bash/support'
+require_relative './bash/version'
+require_relative './bash/mocks/doubles'
+require_relative './bash/mocks/matchers'
+require_relative './bash/mocks/script_message_expectation'
+require_relative './bash/mocks/script_proxy'
+require_relative '../../ext/rspec-mocks/space'
+
+module RSpec
+  module Bash
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configure(&block)
+      yield configuration
+    end
+  end
+end

data/lib/rspec/bash/configuration.rb

@@ -0,0 +1,19 @@
+module RSpec
+  module Bash
+    class Configuration
+      attr_accessor :allow_unstubbed_conditionals
+      attr_accessor :read_fd
+      attr_accessor :throttle
+      attr_accessor :verbose
+      attr_accessor :write_fd
+
+      def initialize()
+        @allow_unstubbed_conditionals = true
+        @throttle = 25 / 1000.0
+        @read_fd = 62
+        @write_fd = 63
+        @verbose = false
+      end
+    end
+  end
+end

data/lib/rspec/bash/controller.sh

@@ -0,0 +1,49 @@
+__rspec_bash_stub_body=""
+
+let r_fd=${BASHIT_R_FD:-4}
+let w_fd=${BASHIT_W_FD:-5}
+
+function __rspec_bash_write() {
+  builtin echo 1>&$w_fd $@
+}
+
+function __rspec_bash_read() {
+  builtin read -u $r_fd $@
+}
+
+function __rspec_bash_retrieve_stub() {
+  local name=$1
+
+  builtin shift 1
+
+  __rspec_bash_write $name $@
+  __rspec_bash_write "</rspec_bash::stub>"
+  __rspec_bash_read  __rspec_bash_stub_body
+  __rspec_bash_write "</rspec_bash::stub-body>"
+
+  builtin test -s "${__rspec_bash_stub_body}"
+}
+
+function __rspec_bash_run_stub() {
+  __rspec_bash_retrieve_stub $@
+
+  builtin . "${__rspec_bash_stub_body}" $@
+}
+
+function test() {
+  if __rspec_bash_retrieve_stub "conditional_expr" $@; then
+    builtin . "${__rspec_bash_stub_body}" $@
+  else
+    builtin test $@
+  fi
+}
+
+function [()(
+  local without_bracket="${@:1:$(($#-1))}"
+
+  if __rspec_bash_retrieve_stub "conditional_expr" "${without_bracket[@]}"; then
+    builtin . "${__rspec_bash_stub_body}" "${without_bracket[@]}"
+  else
+    builtin [ $@
+  fi
+)

data/lib/rspec/bash/fd.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Bash
+    module FD
+      def self.readable?(fd)
+        begin
+          !fd.closed? && !fd.eof?
+        rescue IOError => e
+          if e.to_s == "stream closed"
+            return false
+          else
+            throw
+          end
+        end
+      end
+
+      def self.poll(fd, throttle: 25 / 1000, &block)
+        while readable?(fd) do
+          begin
+            yield fd
+            sleep throttle if throttle > 0
+          rescue IO::WaitReadable
+            IO.select([ fd ])
+            retry
+          rescue IOError => e
+            if e.to_s == "stream closed" || e.to_s == "closed stream"
+              break
+            else
+              throw e
+            end
+          rescue EOFError
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/doubles.rb

@@ -0,0 +1,12 @@
+require_relative './doubles/abstract_double'
+require_relative './doubles/conditional_double'
+require_relative './doubles/function_double'
+
+module RSpec
+  module Bash
+    module Mocks
+      module Doubles
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/doubles/abstract_double.rb

@@ -0,0 +1,33 @@
+module RSpec
+  module Bash
+    module Mocks
+      module Doubles
+        class AbstractDouble
+          attr_accessor :body,
+            :call_original,
+            :calls,
+            :expected_call_count,
+            :expected_calls,
+            :subshell
+
+          def initialize(*)
+            @body = nil
+            @call_original = false
+            @calls = []
+            @expected_call_count = [:at_least, 1]
+            @expected_calls = []
+            @subshell = true
+          end
+
+          def apply
+            fail "NotImplemented"
+          end
+
+          def call_count
+            fail "NotImplemented"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/doubles/conditional_double.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Bash
+    module Mocks
+      module Doubles
+        class ConditionalDouble < AbstractDouble
+          def initialize(expr)
+            super()
+
+            @expr = expr
+          end
+
+          def apply(script)
+            script.stub_conditional(@expr, &body)
+          end
+
+          def call_count(script)
+            script.conditional_calls_for(@expr).count
+          end
+
+          def call_args(script)
+            script.conditional_calls_for(@expr).map { |x| x[:args] }
+          end
+
+          def to_s
+            @expr.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/doubles/function_double.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Bash
+    module Mocks
+      module Doubles
+        class FunctionDouble < AbstractDouble
+          def initialize(routine)
+            super()
+
+            @routine = routine
+          end
+
+          def apply(script)
+            script.stub(@routine, call_original: call_original, subshell: subshell, &body)
+          end
+
+          def call_count(script)
+            script.calls_for(@routine).count
+          end
+
+          def call_args(script)
+            script.calls_for(@routine).map { |x| x[:args] }
+          end
+
+          def to_s
+            @routine.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/matchers.rb

@@ -0,0 +1,18 @@
+require_relative './matchers/receive'
+require_relative './matchers/test'
+
+module RSpec
+  module Bash
+    module Mocks
+      module Matchers
+        def receive(*args)
+          Receive.new(*args)
+        end
+
+        def test(*args)
+          Test.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/matchers/base_matcher.rb

@@ -0,0 +1,101 @@
+require 'rspec/mocks'
+
+module RSpec
+  module Bash
+    module Mocks
+      module Matchers
+        # @private
+        class BaseMatcher
+          include ::RSpec::Mocks::Matchers::Matcher
+
+          attr_reader :double
+
+          def initialize()
+            fail "@double must be created by implementation" if @double.nil?
+            fail "@display_name must be specified by implementation" if @display_name.nil?
+          end
+
+          def name
+            @display_name
+          end
+
+          def with_args(args)
+            tap { @double.expected_calls << args }
+          end
+
+          def and_return(code)
+            tap { @double.body = lambda { |*| "return #{code}" } }
+          end
+
+          def and_yield(subshell: true, &block)
+            tap {
+              @double.body = block
+              @double.subshell = subshell
+            }
+          end
+
+          def exactly(n)
+            tap { @double.expected_call_count = [:exactly, n] }
+          end
+
+          def at_least(n)
+            tap { @double.expected_call_count = [:at_least, n] }
+          end
+
+          def at_most(n)
+            tap { @double.expected_call_count = [:at_most, n] }
+          end
+
+          def and_call_original
+            tap { @double.call_original = true }
+          end
+
+          def never
+            exactly(0)
+          end
+
+          def once
+            exactly(1)
+          end
+
+          def twice
+            exactly(2)
+          end
+
+          def thrice
+            exactly(3)
+          end
+
+          def times
+            self
+          end
+
+          # @private
+          #
+          # (RSpec::Bash::Script): RSpec::Bash::Mocks::ScriptMessageExpectation
+          def matches?(subject, &block)
+            proxy_for(subject).expect_message(
+              double: @double,
+              display_name: @display_name
+            )
+          end
+
+          # @private
+          #
+          # (RSpec::Bash::Script): RSpec::Bash::Mocks::ScriptMessageExpectation
+          def setup_allowance(subject, &block)
+            proxy_for(subject).allow_message(
+              double: @double
+            )
+          end
+
+          private
+
+          def proxy_for(subject)
+            ::RSpec::Mocks.space.proxy_for(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/matchers/receive.rb

@@ -0,0 +1,20 @@
+require_relative '../doubles'
+require_relative './base_matcher'
+
+module RSpec
+  module Bash
+    module Mocks
+      module Matchers
+        # @private
+        class Receive < BaseMatcher
+          def initialize(routine)
+            @double = Doubles::FunctionDouble.new(routine)
+            @display_name = "receive"
+
+            super()
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/matchers/test.rb

@@ -0,0 +1,20 @@
+require_relative '../doubles'
+require_relative './base_matcher'
+
+module RSpec
+  module Bash
+    module Mocks
+      module Matchers
+        # @private
+        class Test < BaseMatcher
+          def initialize(expr)
+            @double = Doubles::ConditionalDouble.new(expr)
+            @display_name = "test(#{expr})"
+
+            super()
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/script_message_expectation.rb

@@ -0,0 +1,78 @@
+require 'rspec/mocks'
+require 'rspec/mocks/argument_list_matcher'
+require 'rspec/mocks/matchers/expectation_customization'
+
+module RSpec
+  module Bash
+    module Mocks
+      class ScriptMessageExpectation
+        attr_reader :expected_args, :message
+
+        def initialize(double:, display_name:, error_generator:, backtrace_line: nil)
+          @double = double
+          @display_name = display_name
+          @error_generator = error_generator
+          @backtrace_line = backtrace_line
+          @expected_args = double.expected_calls
+          @message = @display_name
+        end
+
+        def invoke(*)
+        end
+
+        def matches?(*)
+        end
+
+        def called_max_times?(*)
+          false
+        end
+
+        def verify_messages_received(script)
+          type, expected_count = *@double.expected_call_count
+          actual_count = @double.call_count(script)
+
+          report = lambda {
+            @error_generator.raise_expectation_error(
+              @display_name,
+              expected_count,
+              ::RSpec::Mocks::ArgumentListMatcher::MATCH_ALL,
+              actual_count,
+              nil,
+              Array(@double.to_s),
+              @backtrace_line
+            )
+          }
+
+          case type
+          when :at_least
+            report[] if actual_count < expected_count
+          when :at_most
+            report[] if actual_count > expected_count
+          when :exactly
+            report[] if actual_count != expected_count
+          else
+            fail "Unrecognized call-count quantifier \"#{type}\""
+          end
+
+          @double.call_args(script).tap do |actual_args|
+            @double.expected_calls.each_with_index do |args, index|
+              expected = args
+              actual = actual_args[index]
+
+              if actual != expected
+                @error_generator.raise_unexpected_message_args_error(
+                  self,
+                  actual_args.map { |x| Array(x) },
+                )
+                break
+              end
+            end
+          end
+        end
+
+        def unadvise(*)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/mocks/script_proxy.rb

@@ -0,0 +1,45 @@
+require 'rspec/support'
+require 'rspec/support/caller_filter'
+require 'rspec/mocks'
+require 'rspec/mocks/proxy'
+
+require_relative './script_message_expectation'
+
+module RSpec
+  module Bash
+    module Mocks
+      class ScriptProxy < ::RSpec::Mocks::Proxy
+        def initialize(*)
+          @expectations = []
+          super
+        end
+
+        def reset
+          @expectations.clear
+          super
+        end
+
+        def verify
+          @expectations.each do |expectation|
+            expectation.verify_messages_received(@object)
+          end
+        end
+
+        def expect_message(double:, display_name:)
+          allow_message(double: double)
+
+          @expectations << ScriptMessageExpectation.new(
+            double: double,
+            display_name: display_name,
+            error_generator: @error_generator,
+            backtrace_line: ::RSpec::CallerFilter.first_non_rspec_line
+          )
+        end
+
+        def allow_message(double:)
+          double.apply(object)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/noisy_thread.rb

@@ -0,0 +1,11 @@
+module RSpec
+  module Bash
+    class NoisyThread < Thread
+      def initialize(**)
+        super.tap do
+          self.abort_on_exception = true
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/open3.rb

@@ -0,0 +1,41 @@
+require 'open3'
+
+module RSpec
+  module Bash
+    module Open3
+      # an extended version of Open3.popen3 which exposes two pipes for internal
+      # communication between the spawned process and ruby
+      #
+      # the descriptors are available as 62 (child read) and 63 (child write)
+      #
+      # @param [Array<String>] cmd
+      def self.popen3X(cmd, read_fd: 62, write_fd: 63, &block)
+        in_r, in_w = IO.pipe
+        out_r, out_w = IO.pipe
+        err_r, err_w = IO.pipe
+        b2r_r, b2r_w = IO.pipe
+        r2b_r, r2b_w = IO.pipe
+
+        opts = {}
+        opts[:in] = in_r
+        opts[:out] = out_w
+        opts[:err] = err_w
+        opts[read_fd] = r2b_r
+        opts[write_fd] = b2r_w
+
+        env = {
+          "BASHIT_R_FD" => "#{read_fd}",
+          "BASHIT_W_FD" => "#{write_fd}"
+        }
+
+        ::Open3.send(:popen_run,
+          [env] + cmd,
+          opts,
+          [in_r, out_w, err_w, r2b_r, b2r_w], # child_io
+          [in_w, out_r, err_r, r2b_w, b2r_r], # parent_io
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/rspec/bash/script.rb

@@ -0,0 +1,122 @@
+module RSpec
+  module Bash
+    class Script
+      MAIN_SCRIPT_FILE = File.expand_path('../controller.sh', __FILE__)
+      NOOP = lambda { |*| '' }
+
+      def self.load(path)
+        new(File.read(path))
+      end
+
+      attr_reader :source, :source_file, :stdout, :stderr, :exit_code
+
+      def initialize(source, path = 'Anonymous')
+        @conditional_stubs = []
+        @conditional_stub_calls = []
+        @source = source
+        @source_file = path
+        @stubs = {}
+        @stub_calls = Hash.new { |h, k| h[k] = [] }
+        @stdout = ""
+        @stderr = ""
+        @exit_code = nil
+      end
+
+      def to_s
+        to_bash_script
+      end
+
+      def inspect
+        "Script(\"#{File.basename(@source_file)}\")"
+      end
+
+      def stub(fn, call_original: false, subshell: true, &body)
+        @stubs[fn.to_sym] = {
+          body: (call_original || !body) ? NOOP : body,
+          subshell: subshell,
+          call_original: call_original
+        }
+      end
+
+      def stub_conditional(expr, &body)
+        @conditional_stubs << { expr: expr, body: body || NOOP }
+      end
+
+      def stubbed(name, args)
+        fail "#{name} is not stubbed" unless @stubs.key?(name.to_sym)
+
+        @stubs[name.to_sym][:body].call(args)
+      end
+
+      def stubbed_conditional(expr, args)
+        conditional_stub = @conditional_stubs.detect { |x| x[:expr] == expr }
+
+        if conditional_stub
+          conditional_stub[:body].call(args)
+        else
+          ""
+        end
+      end
+
+      def has_conditional_stubs?
+        @conditional_stubs.any?
+      end
+
+      def calls_for(name)
+        @stub_calls[name.to_sym]
+      end
+
+      def conditional_calls_for(expr)
+        @conditional_stub_calls.select { |x| x[:expr] == expr }
+      end
+
+      def track_call(name, args)
+        fail "#{name} is not stubbed" unless @stubs.key?(name.to_sym)
+
+        @stub_calls[name.to_sym].push({ args: args })
+      end
+
+      def track_conditional_call(expr, args)
+        @conditional_stub_calls.push({ expr: expr, args: args })
+      end
+
+      def track_exit_code(code)
+        @exit_code = code
+      end
+
+      private
+
+      def to_bash_script
+        buffer = ""
+        buffer << "builtin source '#{Script::MAIN_SCRIPT_FILE}'"
+        buffer << "\n"
+
+        @stubs.keys.each do |name|
+          stub_def = @stubs[name]
+
+          if stub_def[:call_original] then
+            buffer << <<-EOF
+              #{name}() {
+                __rspec_bash_run_stub '#{name}' $@
+
+                builtin #{name} $@
+              }
+            EOF
+          elsif stub_def[:subshell] == false then
+            buffer << <<-EOF
+              #{name}() {
+                __rspec_bash_run_stub '#{name}' $@
+              }
+            EOF
+          else
+            buffer << "#{name}()(__rspec_bash_run_stub '#{name}' $@)\n"
+          end
+        end
+
+        buffer << "\n"
+        buffer << @source
+        buffer
+      end
+    end
+  end
+end

data/lib/rspec/bash/script_evaluator.rb

@@ -0,0 +1,189 @@
+require 'open3'
+require 'expect'
+require 'tempfile'
+require_relative './fd'
+require_relative './open3'
+require_relative './noisy_thread'
+
+module RSpec
+  module Bash
+    class ScriptEvaluator
+      CONDITIONAL_EXPR_STUB = 'conditional_expr'.freeze
+      BLOCK_SIZE = 4096
+
+      # (String, Object?): Boolean
+      #
+      # @param [String] script
+      # @param [Hash?] options
+      # @param [Number?] options.read_fd
+      # @param [Number?] options.write_fd
+      # @param [Number?] options.throttle
+      def eval(script, args = [], **opts)
+        file = Tempfile.new('rspec_bash')
+        file.write(script.to_s)
+        file.close
+        verbose = opts.fetch(:verbose, Bash.configuration.verbose)
+
+        bus_file = Tempfile.new("rspec_bash#{File.basename(script.source_file).gsub(/\W+/, '_')}")
+        bus_file.close
+
+        Bash::Open3.popen3X([ '/usr/bin/env', 'bash', file.path ].concat(args), {
+          read_fd: opts.fetch(:read_fd, Bash.configuration.read_fd),
+          write_fd: opts.fetch(:write_fd, Bash.configuration.write_fd)
+        }) do |input, stdout, stderr, r2b, b2r, wait_thr|
+          workers = []
+
+          # transmit stdout
+          workers << NoisyThread.new do
+            FD.poll(stdout, throttle: Bash.configuration.throttle) do
+              buffer = stdout.read_nonblock(BLOCK_SIZE)
+
+              script.stdout << buffer
+
+              if verbose
+                STDOUT.write buffer
+                STDOUT.flush
+              end
+            end
+          end
+
+          # transmit stderr
+          workers << NoisyThread.new do
+            FD.poll(stderr, throttle: Bash.configuration.throttle) do
+              buffer = stderr.read_nonblock(BLOCK_SIZE)
+
+              script.stderr << buffer
+
+              if verbose
+                STDERR.write buffer
+                STDERR.flush
+              end
+            end
+          end
+
+          # accept & respond to prompts
+          workers << NoisyThread.new do
+            FD.poll(b2r, throttle: Bash.configuration.throttle) do
+              respond_to_prompts(r2b, b2r, script, bus_file)
+            end
+          end
+
+          # wait for the script to finish executing
+          wait_thr.join
+
+          # clean up
+          try_hard "close r2b" do r2b.close end
+          try_hard "close b2r" do b2r.close end
+          try_hard "shut off workers" do workers.map(&:join) end
+          try_hard "kill them all" do workers.map(&:kill) end
+          try_hard "clean up temp bus file" do bus_file.unlink end
+          try_hard "clean up source file" do file.unlink end
+
+          script.track_exit_code wait_thr.value.exitstatus
+
+          wait_thr.value.success?
+        end
+      end
+
+      private
+
+      def respond_to_prompts(fd_in, fd_out, script, bus_file)
+        fd_out.expect("</rspec_bash::stub>", 1) do |result|
+          break if result.nil?
+
+          prompts = result[0].split("\n").reject(&:empty?).reduce([]) do |acc, line|
+            if line == "</rspec_bash::stub>"
+              if acc[-1]
+                acc[-1].merge!(classify_stub(acc[-1][:buffer]))
+              else
+                puts "[WARN] cannot match stub entry: #{line} => #{acc}"
+              end
+            else
+              acc.push({ type: :unknown, buffer: line })
+            end
+
+            acc
+          end
+
+          prompts.each do |type:, buffer:, **stub|
+            case type
+            when :conditional
+              if !script.has_conditional_stubs? && !Bash.configuration.allow_unstubbed_conditionals
+                fail "conditional expressions are not stubbed!"
+              end
+
+              File.write(bus_file, script.stubbed_conditional(stub[:expr], stub[:args]))
+
+              fd_in.puts bus_file.path
+              fd_in.flush
+
+              fd_out.expect('</rspec_bash::stub-body>', 1)
+
+              script.track_conditional_call(stub[:expr], stub[:args])
+            when :function
+              routine = stub[:name]
+              args    = stub[:args]
+              body    = script.stubbed(routine, args)
+
+              File.write(bus_file, body)
+
+              fd_in.puts bus_file.path
+              fd_in.flush
+
+              fd_out.expect('</rspec_bash::stub-body>', 1)
+
+              script.track_call(routine, args)
+            when :unknown
+              STDERR.write "[err] unexpected message from bash: #{buffer}"
+            end
+          end
+        end
+      end
+
+      def classify_stub(command)
+        identifier, args = split_by_first_space(command)
+
+        case identifier
+        when CONDITIONAL_EXPR_STUB
+          expr, expr_args = split_by_first_space(args)
+
+          {
+            type: :conditional,
+            expr: expr,
+            args: expr_args,
+          }
+        else
+          {
+            type: :function,
+            name: identifier,
+            args: args,
+          }
+        end
+      end
+
+      def split_by_first_space(string)
+        delim = string.index(' ')
+
+        # single-argument expressions, this usually happens in unary tests
+        # where the argument evaluates to an empty string, a la:
+        #
+        #     test -z "${string}" => "-z"
+        if delim.nil?
+          return [ string, '' ]
+        end
+
+        [ string[0..delim - 1], string[delim + 1..-1] ]
+      end
+
+      def try_hard(what)
+        begin
+          yield
+        rescue StandardError => e
+          puts what
+          puts e
+          puts e.backtrace
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/support.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Bash
+    module Support
+      def run_script(script, args = [], **opts)
+        ScriptEvaluator.new.eval(script, args, opts)
+      end
+    end
+  end
+end

data/lib/rspec/bash/version.rb

@@ -0,0 +1,5 @@
+module RSpec
+  module Bash
+    VERSION = '1.0.0'
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rspec-bash-x
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ahmad Amireh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: 
+email: ahmad@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- ext/rspec-mocks/space.rb
+- lib/rspec/bash.rb
+- lib/rspec/bash/configuration.rb
+- lib/rspec/bash/controller.sh
+- lib/rspec/bash/fd.rb
+- lib/rspec/bash/mocks/doubles.rb
+- lib/rspec/bash/mocks/doubles/abstract_double.rb
+- lib/rspec/bash/mocks/doubles/conditional_double.rb
+- lib/rspec/bash/mocks/doubles/function_double.rb
+- lib/rspec/bash/mocks/matchers.rb
+- lib/rspec/bash/mocks/matchers/base_matcher.rb
+- lib/rspec/bash/mocks/matchers/receive.rb
+- lib/rspec/bash/mocks/matchers/test.rb
+- lib/rspec/bash/mocks/script_message_expectation.rb
+- lib/rspec/bash/mocks/script_proxy.rb
+- lib/rspec/bash/noisy_thread.rb
+- lib/rspec/bash/open3.rb
+- lib/rspec/bash/script.rb
+- lib/rspec/bash/script_evaluator.rb
+- lib/rspec/bash/support.rb
+- lib/rspec/bash/version.rb
+homepage: 
+licenses:
+- AGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Test Bash scripts with RSpec.
+test_files: []
+has_rdoc: