sus 0.7.0 → 0.9.0

data/lib/sus/expect.rb

@@ -1,11 +1,14 @@
 
 module Sus
 	class Expect
-		def initialize(assertions, subject)
+		def initialize(assertions, subject, inverted: false)
 			@assertions = assertions
 			@subject = subject
-			@inverted = false
+			@inverted = inverted
 		end
+
+		attr :subject
+		attr :inverted
 		
 		def not
 			self.dup.tap do |expect|
@@ -17,9 +20,9 @@ module Sus
 			output.write("expect ", :variable, @subject.inspect, :reset, " ")
 			
 			if @inverted
-				output.write(:failed, "to not", :reset)
+				output.write("to not", :reset)
 			else
-				output.write(:passed, "to", :reset)
+				output.write("to", :reset)
 			end
 		end
 		
@@ -30,14 +33,18 @@ module Sus
 			
 			return self
 		end
+
+		def and(predicate)
+			return to(predicate)
+		end
 	end
 	
 	class Base
-		def expect(subject = nil, &block)
+		def expect(subject = nil, **options, &block)
 			if block_given?
-				Expect.new(@assertions, block)
+				Expect.new(@__assertions__, block, **options)
 			else
-				Expect.new(@assertions, subject)
+				Expect.new(@__assertions__, subject, **options)
 			end
 		end
 	end

data/lib/sus/file.rb

@@ -7,9 +7,7 @@ Sus::TOPLEVEL_CLASS_EVAL = ->(klass, path){klass.class_eval(::File.read(path), p
 module Sus
 	module File
 		extend Context
-		
-		attr_accessor :path
-		
+				
 		def self.extended(base)
 			base.children = Hash.new
 		end
@@ -24,6 +22,10 @@ module Sus
 			
 			return base
 		end
+		
+		def print(output)
+			output.write("file ", :path, self.identity)
+		end
 	end
 	
 	module Context

data/lib/sus/filter.rb

@@ -1,4 +1,3 @@
-
 module Sus
 	class Filter
 		class Index
@@ -30,7 +29,7 @@ module Sus
 			end
 		end
 		
-		def initialize(registry: Registry.new)
+		def initialize(registry = Registry.new)
 			@registry = registry
 			@index = nil
 			@keys = Array.new

data/lib/sus/it.rb

@@ -22,11 +22,11 @@ module Sus
 		
 		def print(output)
 			self.superclass.print(output)
-			output.write(" it ", :it, self.description, :reset, " ", self.identity.to_s)
+			output.write(" it ", :it, self.description, :reset, " ", :identity, self.identity.to_s, :reset)
 		end
 		
 		def call(assertions)
-			assertions.nested(self, isolated: true) do |assertions|
+			assertions.nested(self, identity: self.identity, isolated: true, measure: true) do |assertions|
 				instance = self.new(assertions)
 				
 				instance.around do

data/lib/sus/let.rb

@@ -4,13 +4,13 @@ require_relative 'context'
 module Sus
 	module Context
 		def let(name, &block)
-			ivar = :"@#{name}"
+			instance_variable = :"@#{name}"
 			
 			self.define_method(name) do
-				if value = self.instance_variable_get(ivar)
-					return value
+				if self.instance_variable_defined?(instance_variable)
+					return self.instance_variable_get(instance_variable)
 				else
-					self.instance_variable_set(ivar, self.instance_exec(&block))
+					self.instance_variable_set(instance_variable, self.instance_exec(&block))
 				end
 			end
 		end

data/lib/sus/loader.rb

@@ -0,0 +1,11 @@
+module Sus
+	module Loader
+		def require_library(path)
+			require(::File.join(self.require_root, "lib", path))
+		end
+		
+		def require_fixture(path)
+			require(::File.join(self.require_root, "fixtures", path))
+		end
+	end
+end

data/lib/sus/mock.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Copyright, 2022, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'expect'
+
+module Sus
+	class Mock
+		def initialize(target)
+			@target = target
+			@interceptor = Module.new
+			
+			@target.singleton_class.prepend(@interceptor)
+		end
+		
+		attr :target
+		
+		def print(output)
+			output.write("mock ", :context, @target.inspect)
+		end
+		
+		def clear
+			@interceptor.instance_methods.each do |method_name|
+				@interceptor.remove_method(method_name)
+			end
+		end
+		
+		def replace(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				if execution_context == Thread.current
+					hook.call(*arguments, **options, &block)
+				else
+					super(*arguments, **options, &block)
+				end
+			end
+			
+			return self
+		end
+		
+		def before(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				hook.call(*arguments, **options, &block) if execution_context == Thread.current
+				super(*arguments, **options, &block)
+			end
+
+			return self
+		end
+
+		def after(method, &hook)
+			execution_context = Thread.current
+
+			@interceptor.define_method(method) do |*arguments, **options, &block|
+				result = super(*arguments, **options, &block)
+				hook.call(result, *arguments, **options, &block) if execution_context == Thread.current
+				return result
+			end
+
+			return self
+		end
+	end
+
+	module Mocks
+		def after
+			super
+			
+			@mocks&.each_value(&:clear)
+		end
+		
+		def mock(target)
+			validate_mock!(target)
+
+			mock = self.mocks[target]
+
+			if block_given?
+				yield mock
+			end
+
+			return mock
+		end
+		
+		private
+		
+		MockTargetError = Class.new(StandardError)
+
+		def validate_mock!(target)
+			if target.frozen?
+				raise MockTargetError, "Cannot mock frozen object #{target.inspect}!"
+			end
+		end
+
+		def mocks
+			@mocks ||= Hash.new{|h,k| h[k] = Mock.new(k)}.compare_by_identity
+		end
+	end
+
+	class Base
+		def mock(target, &block)
+			# Pull in the extra functionality:
+			self.singleton_class.prepend(Mocks)
+
+			# Redirect the method to the new functionality:
+			self.mock(target, &block)
+		end
+	end
+end

data/lib/sus/output/backtrace.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Sus
+	module Output
+		# Print out a backtrace relevant to the given test identity if provided.
+		class Backtrace
+			def self.first(identity = nil)
+				# This implementation could be a little more efficient.
+				self.new(caller_locations(1), identity&.path, 1)
+			end
+			
+			def self.for(exception, identity = nil)
+				self.new(exception.backtrace_locations, identity&.path)
+			end
+			
+			def initialize(stack, root = nil, limit = nil)
+				@stack = stack
+				@root = root
+				@limit = limit
+			end
+			
+			def filter(root = @root)
+				if @root
+					stack = @stack.select do |frame|
+						frame.path.start_with?(@root)
+					end
+				else
+					stack = @stack
+				end
+				
+				if @limit
+					stack = stack.take(@limit)
+				end
+				
+				return stack
+			end
+			
+			def print(output)
+				if @limit == 1
+					filter.each do |frame|
+						output.write " ", :path, frame.path, :line, ":", frame.lineno
+					end
+				else
+					output.indented do
+						filter.each do |frame|
+							output.puts :indent, :path, frame.path, :line, ":", frame.lineno, :reset, " ", frame.label
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/sus/output/buffered.rb

@@ -27,34 +27,55 @@ module Sus
 	# Styled output output.
 	module Output
 		class Buffered
-			def initialize(output)
-				@output = output
-				@buffer = Array.new
+			def initialize(tee = nil)
+				@chunks = Array.new
+				@tee = tee
 			end
 			
-			attr :output
-			attr :buffer
+			attr :chunks
+			attr :tee
 			
-			def append(output)
-				@buffer.each do |operation|
-					output.public_send(*operation)
+			def inspect
+				if @tee
+					"\#<#{self.class.name} #{@chunks.size} chunks -> #{@tee.class}>"
+				else
+					"\#<#{self.class.name} #{@chunks.size} chunks>"
 				end
 			end
 			
+			def buffered
+				self.class.new(self)
+			end
+			
+			attr :output
+			
+			def each(&block)
+				@chunks.each(&block)
+			end
+			
+			def append(buffer)
+				@chunks.concat(buffer.output)
+				@tee&.append(buffer)
+			end
+			
 			def string
 				io = StringIO.new
-				append(Text.new(io))
+				Text.new(io).append(@chunks)
 				return io.string
 			end
 			
+			INDENT = [:indent].freeze
+			
 			def indent
-				@buffer << [:indent]
-				@output.indent
+				@chunks << INDENT
+				@tee&.indent
 			end
 			
+			OUTDENT = [:outdent].freeze
+			
 			def outdent
-				@buffer << [:outdent]
-				@output.outdent
+				@chunks << OUTDENT
+				@tee&.outdent
 			end
 			
 			def indented
@@ -65,13 +86,13 @@ module Sus
 			end
 			
 			def write(*arguments)
-				@output.write(*arguments)
-				@buffer << [:write, *arguments]
+				@chunks << [:write, *arguments]
+				@tee&.write(*arguments)
 			end
 			
 			def puts(*arguments)
-				@output.puts(*arguments)
-				@buffer << [:puts, *arguments]
+				@chunks << [:puts, *arguments]
+				@tee&.puts(*arguments)
 			end
 		end
 	end

data/lib/sus/output/lines.rb

@@ -76,6 +76,7 @@ module Sus
 				offset = @current_count - index
 				
 				@output.write("\e[#{offset}F\e[K")
+				
 				soft_wrap do
 					line.print(@output)
 				end

data/lib/sus/output/null.rb

@@ -29,6 +29,15 @@ module Sus
 		class Null
 			def initialize
 			end
+			
+			def buffered
+				Buffered.new(nil)
+			end
+			
+			attr :options
+			
+			def append(buffer)
+			end
 
 			def indent
 			end

data/lib/sus/output/progress.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'bar'
+require_relative 'status'
+require_relative 'lines'
+
+module Sus
+	module Output
+		class Progress
+			def self.now
+				::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+			end
+			
+			def initialize(output, total = 0, minimum_output_duration: 1.0)
+				@output = output
+				@subject = subject
+				
+				@start_time = Progress.now
+				
+				if @output.interactive?
+					@bar = Bar.new
+					@lines = Lines.new(@output)
+					@lines[0] = @bar
+				end
+				
+				@current = 0
+				@total = total
+			end
+			
+			attr :subject
+			attr :current
+			attr :total
+			
+			def duration
+				Progress.now - @start_time
+			end
+			
+			def progress
+				@current.to_f / @total.to_f
+			end
+			
+			def remaining
+				@total - @current
+			end
+			
+			def average_duration
+				if @current > 0
+					duration / @current
+				end
+			end
+			
+			def estimated_remaining_time
+				if average_duration = self.average_duration
+					average_duration * remaining
+				end
+			end
+			
+			# Increase the amont of work done.
+			def increment(amount = 1)
+				@current += amount
+				
+				@bar&.update(@current, @total, self.to_s)
+				@lines&.redraw(0)
+				
+				return self
+			end
+			
+			# Increase the total size of the progress.
+			def expand(amount = 1)
+				@total += amount
+				
+				@bar&.update(@current, @total, self.to_s)
+				@lines&.redraw(0)
+				
+				return self
+			end
+			
+			def report(index, context, state)
+				@lines&.[]=(index+1, Status.new(state, context))
+				
+				return self
+			end
+			
+			def clear
+				@lines&.clear
+			end
+			
+			def to_s
+				if estimated_remaining_time = self.estimated_remaining_time
+					"#{@current}/#{@total} completed in #{formatted_duration(self.duration)}, #{formatted_duration(estimated_remaining_time)} remaining"
+				else
+					"#{@current}/#{@total} completed"
+				end
+			end
+			
+			private
+			
+			def formatted_duration(duration)
+				seconds = duration.floor
+				
+				if seconds < 60.0
+					return "#{seconds}s"
+				end
+				
+				minutes = (duration / 60.0).floor
+				seconds = (seconds - (minutes * 60)).round
+				
+				if minutes < 60.0
+					return "#{minutes}m#{seconds}s"
+				end
+				
+				hours = (minutes / 60.0).floor
+				minutes = (minutes - (hours * 60)).round
+				
+				if hours < 24.0
+					return "#{hours}h#{minutes}m"
+				end
+				
+				days = (hours / 24.0).floor
+				hours = (hours - (days * 24)).round
+				
+				return "#{days}d#{hours}h"
+			end
+		end
+	end
+end

data/lib/sus/output/text.rb

@@ -29,12 +29,23 @@ module Sus
 		class Text
 			def initialize(io)
 				@io = io
+				
 				@styles = {reset: self.reset}
 				
 				@indent = String.new
 				@styles[:indent] = @indent
 			end
 			
+			def buffered
+				Buffered.new(self)
+			end
+			
+			def append(buffer)
+				buffer.each do |operation|
+					self.public_send(*operation)
+				end
+			end
+			
 			attr :io
 			
 			INDENTATION = "\t"

data/lib/sus/output.rb

@@ -4,6 +4,7 @@ require_relative 'output/text'
 require_relative 'output/xterm'
 
 require_relative 'output/null'
+require_relative 'output/progress'
 
 module Sus
 	module Output
@@ -22,20 +23,25 @@ module Sus
 			
 			output[:context] = output.style(nil, nil, :bold)
 			
-			output[:describe] = output.style(:cyan, nil, :bold)
+			output[:describe] = output.style(:cyan)
 			output[:it] = output.style(:cyan)
 			output[:with] = output.style(:cyan)
 			
 			output[:variable] = output.style(:blue, nil, :bold)
 			
-			output[:passed] = output.style(:green, nil, :bold)
-			output[:failed] = output.style(:red, nil, :bold)
+			output[:path] = output.style(:yellow)
+			output[:line] = output.style(:yellow)
+			output[:identity] = output.style(:yellow)
+			
+			output[:passed] = output.style(:green)
+			output[:failed] = output.style(:red)
+			output[:error] = output.style(:red)
 			
 			return output
 		end
 		
 		def self.buffered
-			Buffered.new(Null.new)
+			Buffered.new
 		end
 	end
 end

data/lib/sus/raise_exception.rb

@@ -12,17 +12,12 @@ module Sus
 					
 					# Didn't throw any exception, so the expectation failed:
 					assertions.assert(false, self)
-				rescue => exception
-					# Did we throw the right kind of exception?
-					if exception.is_a?(@exception_class)
-						# Did it have the right message?
-						if @message
-							assertions.assert(@message === exception.message)
-						else
-							assertions.assert(true, self)
-						end
+				rescue @exception_class => exception
+					# Did it have the right message?
+					if @message
+						assertions.assert(@message === exception.message)
 					else
-						raise
+						assertions.assert(true, self)
 					end
 				end
 			end