sus 0.1.0

data/lib/sus/describe.rb

@@ -0,0 +1,42 @@
+
+require_relative 'context'
+
+module Sus
+	module Describe
+		extend Context
+		
+		attr_accessor :subject
+		
+		def self.extended(base)
+			base.children = Hash.new
+		end
+		
+		def self.build(parent, subject, identity: nil, &block)
+			base = Class.new(parent)
+			base.extend(Describe)
+			base.subject = subject
+			base.description = subject.inspect
+			base.identity = identity || Identity.nested(parent.identity, base.description)
+			base.define_method(:subject, ->{subject})
+			
+			if block_given?
+				base.class_exec(&block)
+			end
+			
+			return base
+		end
+		
+		def print(output)
+			output.write(
+				"describe ", :describe, self.description, :reset,
+				# " ", self.identity.to_s
+			)
+		end
+	end
+	
+	module Context
+		def describe(...)
+			add Describe.build(self, ...)
+		end
+	end
+end

data/lib/sus/expect.rb

@@ -0,0 +1,88 @@
+
+module Sus
+	class Expect
+		def initialize(assertions, subject)
+			@assertions = assertions
+			@subject = subject
+			@inverted = false
+		end
+		
+		def not
+			self.dup.tap do |expect|
+				expect.instance_variable_set(:@inverted, !@inverted)
+			end
+		end
+		
+		def print(output)
+			output.write("expect ", :variable, @subject.inspect, :reset, " ")
+			
+			if @inverted
+				output.write(:failed, "to not", :reset)
+			else
+				output.write(:passed, "to", :reset)
+			end
+		end
+		
+		def to(predicate)
+			@assertions.nested(self, inverted: @inverted) do |assertions|
+				predicate.call(assertions, @subject)
+			end
+			
+			return self
+		end
+		
+		def to_throw(...)
+			predicate = ThrowException.new(...)
+			
+			@assertions.nested(self, inverted: @inverted) do |assertions|
+				predicate.call(assertions, @subject)
+			end
+			
+			return self
+		end
+	end
+	
+	class Base
+		def expect(subject)
+			Expect.new(@assertions, subject)
+		end
+	end
+	
+	class ThrowException
+		def initialize(exception_class, message = nil)
+			@exception_class = exception_class
+			@message = message
+		end
+		
+		def call(assertions, value)
+			assertions.nested(self) do |assertions|
+				begin
+					value.call
+					
+					# 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
+					else
+						raise
+					end
+				end
+			end
+		end
+		
+		def print(output)
+			output << "throw exception " << output.style(@exception_class, :variable)
+			
+			if @message
+				output << "with message " << output.style(@message, :variable)
+			end
+		end
+	end
+end

data/lib/sus/filter.rb

@@ -0,0 +1,73 @@
+
+module Sus
+	class Filter
+		class Index
+			def initialize
+				@contexts = {}
+			end
+			
+			attr :contexts
+			
+			def add(parent)
+				parent.children&.each do |identity, child|
+					insert(identity, child)
+					add(child)
+				end
+			end
+			
+			def insert(identity, context)
+				@contexts[identity.key] = context
+			end
+			
+			def [] key
+				@contexts[key]
+			end
+		end
+		
+		def initialize(registry: Registry.new)
+			@registry = registry
+			@index = nil
+			@keys = Array.new
+		end
+		
+		def load(target)
+			path, filter = target.split(':', 2)
+			
+			@registry.load(path)
+			
+			if filter
+				@keys << target
+			end
+		end
+		
+		def each(&block)
+			if @keys.any?
+				@index = Index.new
+				@index.add(@registry)
+				
+				@keys.each do |key|
+					if target = @index[key]
+						yield target
+					end
+				end
+			else
+				@registry.each(&block)
+			end
+		end
+		
+		def call(assertions = Assertions.default)
+			if @keys.any?
+				@index = Index.new
+				@index.add(@registry)
+				
+				@keys.each do |key|
+					@index[key]&.call(assertions)
+				end
+			else
+				@registry.call(assertions)
+			end
+			
+			return assertions
+		end
+	end
+end

data/lib/sus/identity.rb

@@ -0,0 +1,80 @@
+
+module Sus
+	class Identity
+		def self.nested(parent, name, location = nil, **options)
+			location ||= caller_locations(3...4).first
+			
+			self.new(location.path, name, location.lineno, parent, **options)
+		end
+		
+		def initialize(path, name = nil, line = nil, parent = nil, unique: true)
+			@path = path
+			@name = name
+			@line = line
+			@parent = parent
+			@unique = unique
+			
+			@key = nil
+		end
+		
+		attr :path
+		attr :name
+		attr :line
+		attr :parent
+		attr :unique
+		
+		def to_s
+			self.key
+		end
+		
+		def inspect
+			"\#<#{self.class} #{self.to_s}>"
+		end
+		
+		def match?(other)
+			if path = other.path
+				return false unless path === @path
+			end
+			
+			if name = other.name
+				return false unless name === @name
+			end
+			
+			if line = other.line
+				return false unless line === @line
+			end
+		end
+		
+		def each(&block)
+			@parent&.each(&block)
+			
+			yield self
+		end
+		
+		def key
+			unless @key
+				key = Array.new
+				
+				append_unique_key(key, false)
+				
+				@key = key.join(':')
+			end
+			
+			return @key
+		end
+		
+		protected
+		
+		def append_unique_key(key, unique = @unique)
+			if @parent
+				@parent.append_unique_key(key)
+			else
+				key << @path
+			end
+			
+			if @line
+				key << @line unless unique
+			end
+		end
+	end
+end

data/lib/sus/include_context.rb

@@ -0,0 +1,10 @@
+
+require_relative 'context'
+
+module Sus
+	module Context
+		def include_context(shared)
+			self.class_exec(&shared.block)
+		end
+	end
+end

data/lib/sus/it.rb

@@ -0,0 +1,45 @@
+
+require_relative 'context'
+
+module Sus
+	module It
+		def self.build(parent, description, &block)
+			base = Class.new(parent)
+			base.extend(It)
+			base.description = description
+			base.identity = Identity.nested(parent.identity, base.description)
+			
+			if block_given?
+				base.define_method(:call, &block)
+			end
+			
+			return base
+		end
+		
+		def leaf?
+			true
+		end
+		
+		def print(output)
+			self.superclass.print(output)
+			output.write(" it ", :it, self.description, :reset, " ", self.identity.to_s)
+		end
+		
+		def call(assertions)
+			sleep rand
+			assertions.nested(self, isolated: true) do |assertions|
+				instance = self.new(assertions)
+				
+				instance.around do
+					instance.call
+				end
+			end
+		end
+	end
+	
+	module Context
+		def it(...)
+			add It.build(self, ...)
+		end
+	end
+end

data/lib/sus/it_behaves_like.rb

@@ -0,0 +1,34 @@
+
+require_relative 'context'
+
+module Sus
+	module ItBehavesLike
+		extend Context
+		
+		attr_accessor :shared
+		
+		def self.extended(base)
+			base.children = Hash.new
+		end
+		
+		def self.build(parent, shared)
+			base = Class.new(parent)
+			base.extend(ItBehavesLike)
+			base.description = shared.name
+			base.identity = Identity.nested(parent.identity, base.description, unique: false)
+			base.class_exec(&shared.block)
+			return base
+		end
+		
+		def print(output)
+			self.superclass.print(output)
+			output.write(" it behaves like ", :describe, self.description, :reset)
+		end
+	end
+	
+	module Context
+		def it_behaves_like(shared)
+			add ItBehavesLike.build(self, shared)
+		end
+	end
+end

data/lib/sus/let.rb

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

data/lib/sus/output/bar.rb

@@ -0,0 +1,109 @@
+# 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
+		class Bar
+			BLOCK = [
+				" ",
+				"▏",
+				"▎",
+				"▍",
+				"▌",
+				"▋",
+				"▊",
+				"▉",
+				"█",
+			]
+			
+			def initialize(current = 0, total = 0, message = nil)
+				@maximum_message_width = 0
+				
+				@current = current
+				@total = total
+				@message = message
+			end
+			
+			def update(current, total, message)
+				@current = current
+				@total = total
+				@message = message
+			end
+			
+			def self.register(output)
+				output[:progress_bar] ||= output.style(:blue, :white)
+			end
+			
+			MINIMUM_WIDTH = 8
+			MESSAGE_SUFFIX = ": "
+			
+			def print(output)
+				width = output.width
+				
+				unless @total.zero?
+					value = @current.to_f / @total.to_f
+				else
+					value = 0.0
+				end
+				
+				if @message
+					message = @message + MESSAGE_SUFFIX
+					if message.size > @maximum_message_width
+						@maximum_message_width = message.size
+					end
+					
+					if @maximum_message_width < (width - MINIMUM_WIDTH)
+						width -= @maximum_message_width
+						message = message.rjust(@maximum_message_width)
+					else
+						@maximum_message_width = 0
+						message = nil
+					end
+				end
+				
+				if message
+					output.write(message)
+				end
+				
+				output.write(
+					:progress_bar, draw(value, width), :reset,
+				)
+				
+				output.puts
+			end
+			
+			private
+			
+			def draw(value, width)
+				blocks = width * value
+				full_blocks = blocks.floor
+				partial_block = ((blocks - full_blocks) * BLOCK.size).floor
+				
+				if partial_block.zero?
+					BLOCK.last * full_blocks
+				else
+					"#{BLOCK.last * full_blocks}#{BLOCK[partial_block]}"
+				end.ljust(width)
+			end
+		end
+	end
+end

data/lib/sus/output/buffered.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Copyright, 2019, 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 'io/console'
+require 'stringio'
+
+module Sus
+	# Styled output output.
+	module Output
+		class Buffered
+			def initialize(output)
+				@output = output
+				@buffer = Array.new
+			end
+			
+			attr :output
+			attr :buffer
+			
+			def append(output)
+				@buffer.each do |operation|
+					output.public_send(*operation)
+				end
+			end
+			
+			def string
+				io = StringIO.new
+				append(Text.new(io))
+				return io.string
+			end
+			
+			def indent
+				@buffer << [:indent]
+				@output.indent
+			end
+			
+			def outdent
+				@buffer << [:outdent]
+				@output.outdent
+			end
+			
+			def indented
+				self.indent
+				yield
+			ensure
+				self.outdent
+			end
+			
+			def write(*arguments)
+				@output.write(*arguments)
+				@buffer << [:write, *arguments]
+			end
+			
+			def puts(*arguments)
+				@output.puts(*arguments)
+				@buffer << [:puts, *arguments]
+			end
+		end
+	end
+end

data/lib/sus/output/lines.rb

@@ -0,0 +1,89 @@
+
+require 'io/console'
+
+module Sus
+	module Output
+		class Lines
+			def initialize(output)
+				@output = output
+				@lines = []
+				
+				@current_count = 0
+			end
+			
+			def height
+				@output.size.first
+			end
+			
+			def []= index, line
+				@lines[index] = line
+				
+				redraw(index)
+			end
+			
+			def clear
+				@lines.clear
+				write
+			end
+			
+			def redraw(index)
+				if index < @current_count
+					update(index, @lines[index])
+				else
+					write
+				end
+			end
+			
+			private
+			
+			def soft_wrap
+				@output.write("\e[?7l")
+				
+				yield
+			ensure
+				@output.write("\e[?7h")
+			end
+			
+			def origin
+				if @current_count > 0
+					@output.write("\e[#{@current_count}F\e[J")
+				end
+				
+				@current_count = 0
+			end
+			
+			def write
+				origin
+				
+				height = self.height
+				
+				soft_wrap do
+					@lines.each do |line|
+						break if (@current_count+1) >= height
+						
+						if line
+							line.print(@output)
+						else
+							@output.puts
+						end
+						
+						@current_count += 1
+					end
+				end
+			end
+			
+			def update(index, line)
+				offset = @current_count - index
+				
+				@output.write("\e[#{offset}F\e[K")
+				soft_wrap do
+					line.print(@output)
+				end
+				
+				if offset > 1
+					@output.write("\e[#{offset-1}E")
+				end
+			end
+		end
+	end
+end