quickdraw 0.0.5 → 0.1.0

data/lib/quickdraw/matchers/boolean.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::Boolean
+	def to_be_truthy
+		assert(value) { "expected `#{value.inspect}` to be truthy" }
+	end
+
+	def to_be_falsy
+		refute(value) { "expected `#{value.inspect}` to be falsy" }
+	end
+end

data/lib/quickdraw/matchers/case_equality.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::CaseEquality
+	def ===(other)
+		assert value === other do
+			"expected `#{value.inspect}` to === `#{other.inspect}`"
+		end
+	end
+end

data/lib/quickdraw/matchers/change.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::Change
+	def to_change(from: Quickdraw::Null, to: Quickdraw::Null, by: Quickdraw::Null, &object)
+		original = object.call
+
+		if Quickdraw::Null != from
+			assert from === original do
+				"expected `#{original.inspect}` to be `#{from.inspect}`"
+			end
+		end
+
+		block.call
+
+		new = object.call
+
+		if new == original
+			failure! "expected `#{original.inspect}` to change"
+		end
+
+		if Quickdraw::Null != to
+			assert to === new do
+				"expected `#{new.inspect}` to be `#{to.inspect}`"
+			end
+		end
+
+		if Quickdraw::Null != by
+			assert by === (new - original) do
+				"expected `#{new.inspect}` to change by `#{by.inspect}`"
+			end
+		end
+	end
+end

data/lib/quickdraw/matchers/equality.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::Equality
+	def ==(other)
+		assert value == other do
+			"expected `#{value.inspect}` to == `#{other.inspect}`"
+		end
+	end
+
+	def !=(other)
+		assert value != other do
+			"expected `#{value.inspect}` to != `#{other.inspect}`"
+		end
+	end
+
+	def to_eql?(other)
+		assert value.eql?(other) do
+			"expected `#{value.inspect}` to eql? `#{other.inspect}`"
+		end
+	end
+
+	def not_to_eql?(other)
+		refute value.eql?(other) do
+			"expected `#{value.inspect}` not to eql? `#{other.inspect}`"
+		end
+	end
+
+	def to_equal?(other)
+		assert value.equal?(other) do
+			"expected `#{value.inspect}` to equal? `#{other.inspect}`"
+		end
+	end
+
+	def not_to_equal?(other)
+		refute value.equal?(other) do
+			"expected `#{value.inspect}` not to equal? `#{other.inspect}`"
+		end
+	end
+end

data/lib/quickdraw/matchers/include.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::Include
+	def to_include(other)
+		assert value.include?(other) do
+			"expected `#{value.inspect}` to include? `#{other.inspect}`"
+		end
+	end
+
+	def not_to_include(other)
+		refute value.include?(other) do
+			"expected `#{value.inspect}` to not include? `#{other.inspect}`"
+		end
+	end
+end

data/lib/quickdraw/matchers/predicate.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::Predicate
+	def to_be(predicate)
+		assert(value.send(predicate)) { "expected `#{value.inspect}` to be `#{predicate.inspect}`" }
+	end
+
+	def not_to_be(predicate)
+		refute(value.send(predicate)) { "expected `#{value.inspect}` to not be `#{predicate.inspect}`" }
+	end
+
+	alias_method :to_have, :to_be
+	alias_method :not_to_have, :not_to_be
+end

data/lib/quickdraw/matchers/respond_to.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::RespondTo
+	def to_respond_to(method)
+		assert value.respond_to?(method) do
+			"expected `#{value.inspect}` to respond to `#{method.inspect}`"
+		end
+	end
+
+	def not_to_respond_to(method)
+		refute value.respond_to?(method) do
+			"expected `#{value.inspect}` to not respond to `#{method.inspect}`"
+		end
+	end
+end

data/lib/quickdraw/matchers/to_be_a.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::ToBeA
+	def to_be_a(type)
+		assert type === value do
+			"expected `#{value.inspect}` to have the type `#{type.inspect}`"
+		end
+	end
+
+	def not_to_be_a(type)
+		refute type === value do
+			"expected `#{value.inspect}` to not have the type `#{type.inspect}`"
+		end
+	end
+
+	alias_method :to_be_an, :to_be_a
+	alias_method :not_to_be_an, :not_to_be_a
+end

data/lib/quickdraw/matchers/to_have_attributes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::ToHaveAttributes
+	def to_have_attributes(**attributes)
+		attributes.each do |k, v|
+			assert v === value.send(k) do
+				"expected `#{value.inspect}` to have the attribute `#{k.inspect}` equal to `#{v.inspect}`"
+			end
+		end
+	rescue NoMethodError => e
+		failure! { "expected `#{value.inspect}` to respond to `#{e.name}`" }
+	end
+end

data/lib/quickdraw/matchers/to_raise.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::ToRaise
+	def to_raise(error = ::Exception)
+		expectation_block = block
+
+		begin
+			expectation_block.call
+		rescue error => e
+			success!
+			yield(e) if block_given?
+			return
+		rescue ::Exception => e
+			return failure! { "expected `#{error.inspect}` to be raised but `#{e.class.inspect}` was raised" }
+		end
+
+		failure! { "expected #{error} to be raised but wasn't" }
+	end
+
+	def not_to_raise
+		block.call
+		success!
+	rescue ::Exception => e
+		failure! { "expected the block not to raise, but it raised `#{e.class}`" }
+	end
+end

data/lib/quickdraw/matchers/to_receive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Quickdraw::Matchers::ToReceive
+	def to_receive(method_name, &expectation_block)
+		__raise__ ::ArgumentError, "You can't use the `to_receive` matcher with a block expectation." if @block
+
+		interceptor = ::Module.new
+
+		# Define local variables so they're available from the block
+		expectation = self
+		context = @context
+
+		interceptor.define_method(method_name) do |*args, **kwargs, &block|
+			expectation.success!
+			super_block = -> (*a, &b) { (a.length > 0) || b ? super(*a, &b) : super(*args, **kwargs, &block) }
+			original_super = context.instance_variable_get(:@super)
+			begin
+				context.instance_variable_set(:@super, super_block)
+				result = expectation_block&.call(*args, **kwargs, &block)
+			ensure
+				context.instance_variable_set(:@super, original_super)
+			end
+
+			interceptor.define_method(method_name) { |*a, **k, &b| super(*a, **k, &b) }
+			result
+		end
+
+		value.singleton_class.prepend(interceptor)
+	end
+end

data/lib/quickdraw/matchers.rb

@@ -0,0 +1,13 @@
+module Quickdraw::Matchers
+	autoload :Boolean, "quickdraw/matchers/boolean"
+	autoload :CaseEquality, "quickdraw/matchers/case_equality"
+	autoload :Change, "quickdraw/matchers/change"
+	autoload :Equality, "quickdraw/matchers/equality"
+	autoload :Include, "quickdraw/matchers/include"
+	autoload :Predicate, "quickdraw/matchers/predicate"
+	autoload :RespondTo, "quickdraw/matchers/respond_to"
+	autoload :ToBeA, "quickdraw/matchers/to_be_a"
+	autoload :ToHaveAttributes, "quickdraw/matchers/to_have_attributes"
+	autoload :ToRaise, "quickdraw/matchers/to_raise"
+	autoload :ToReceive, "quickdraw/matchers/to_receive"
+end

data/lib/quickdraw/pipe.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Quickdraw::Pipe
+	def initialize
+		@reader, @writer = IO.pipe
+	end
+
+	def reader
+		@writer.close
+		@reader
+	end
+
+	def writer
+		@reader.close
+		@writer
+	end
+
+	def with_writer
+		@reader.close
+		yield(@writer).tap { @writer.close }
+	end
+
+	def with_reader
+		@writer.close
+		yield(@reader).tap { @reader.close }
+	end
+end

data/lib/quickdraw/queue.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Quickdraw::Queue
+	def initialize
+		@array = []
+		@mutex = Mutex.new
+	end
+
+	def <<(item)
+		@mutex.synchronize { @array << item }
+	end
+
+	def drain
+		yield(shift) until empty?
+	end
+
+	def pop
+		@mutex.synchronize { @array.pop }
+	end
+
+	def shift
+		@mutex.synchronize { @array.shift }
+	end
+
+	def empty?
+		@array.empty?
+	end
+
+	def size
+		@array.size
+	end
+end

data/lib/quickdraw/registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+
+# frozen_string_literal: true
+
+class Quickdraw::Registry
+	def initialize
+		@registered_matchers = Quickdraw::Map.new
+		@type_matchers = Quickdraw::Map.new
+		@shapes = Quickdraw::Map.new
+	end
+
+	# Register a new matcher for the given types.
+	def register(matcher, *types)
+		@registered_matchers[matcher] = types
+
+		# We need to clear this cache because the output of `slowly_find_matchers_for` might have changed.
+		@type_matchers.clear
+	end
+
+	# Given a value, find or build an expectation class that includes all the matchers for the value.
+	def expectation_for(value, matchers: nil)
+		if matchers
+			shape_for(
+				matchers + matchers_for(value)
+			)
+		else
+			shape_for(
+				matchers_for(value)
+			)
+		end
+	end
+
+	private
+
+	# A "shape" is a specialised Expectation class that includes the given matchers. It's cached against the list of matchers.
+	def shape_for(matchers)
+		@shapes[matchers] ||= Class.new(Quickdraw::Expectation) do
+			matchers.each { |m| include m }
+			freeze
+		end
+	end
+
+	# Given a value, find all the matchers that match it. This is cached against the class of the value.
+	def matchers_for(value)
+		@type_matchers[value.class] ||= slowly_find_matchers_for(value)
+	end
+
+	# If the above has a cache miss, we'll need to find the correct matchers slowly and then cache them.
+	def slowly_find_matchers_for(value)
+		[].tap do |matchers|
+			@registered_matchers.each do |matcher, types|
+				matchers << matcher if types.any? { |t| t === value }
+			end
+		end
+	end
+end

data/lib/quickdraw/run.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Quickdraw::Run
+	def initialize(number_of_processes:, number_of_threads: 1, test_files:)
+		@number_of_processes = number_of_processes
+		@number_of_threads = number_of_threads
+		@test_files = test_files.shuffle
+
+		@cluster = Quickdraw::Cluster.new
+		@batches = Array.new(@number_of_processes) { Quickdraw::Queue.new }
+
+		@test_files.each_with_index do |file, index|
+			@batches[index % @number_of_processes] << file
+		end
+	end
+
+	def call
+		report_time do
+			fork_processes
+			@results = @cluster.wait
+			puts_results
+		end
+	end
+
+	def report_time(&)
+		total_time = Quickdraw::Timer.time(&)
+		puts "Total time: #{total_time}"
+	end
+
+	def fork_processes
+		# Enable YJIT right before forking
+		RubyVM::YJIT.enable
+
+		@batches.each_with_index do |batch, index|
+			@cluster.fork do |writer|
+				results = @number_of_threads.times.map do
+					Thread.new { Quickdraw::Runner.call(batch) }
+				end.map(&:value)
+
+				results.each_with_index do |result, thread|
+					writer.write("\n")
+					writer.write("Process[#{index + 1}], Thread[#{thread + 1}]: #{result.successes.count} assertions passed in #{result.duration}. #{Quickdraw::SUCCESS_EMOJI.sample}")
+				end
+			end
+		end
+	end
+
+	def puts_results
+		puts
+		puts
+		puts "Collated results: \n#{@results.join("\n")}"
+	end
+end

data/lib/quickdraw/runner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Quickdraw::Runner
+	def self.call(queue)
+		tests = []
+
+		queue.drain do |f|
+			tests << [f, Class.new(Quickdraw::Context) do
+				class_eval(
+					File.read(f), f, 1
+				)
+			end]
+		end
+
+		new(tests).tap(&:call)
+	end
+
+	def initialize(tests = nil)
+		@tests = tests
+
+		@successes = []
+		@failures = []
+	end
+
+	attr_reader :successes, :failures, :duration
+
+	def call
+		@duration = Quickdraw::Timer.time do
+			@tests.each { |(f, t)| t.run(self, [f]) }
+		end
+	end
+
+	def success!(name)
+		@successes << [name]
+
+		Kernel.print "🟢 "
+		# ::Kernel.print "\e[32m⚬\e[0m"
+	end
+
+	def failure!(path, &message)
+		location = caller_locations.drop_while { |l| !l.path.include?(".test.rb") }
+
+		@failures << [message, location, path]
+
+		Kernel.print "🔴 "
+		# ::Kernel.print "\e[31m⚬\e[0m"
+	end
+end

data/lib/quickdraw/timer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Quickdraw::Timer
+	class Duration
+		def initialize(duration)
+			@duration = duration
+		end
+
+		def to_s
+      if @duration < 1_000
+      	"#{@duration}ns"
+			elsif @duration < 1_000_000
+				"#{@duration / 1_000}μs"
+			elsif @duration < 1_000_000_000
+				"#{@duration / 1_000_000}ms"
+			elsif @duration < 60_000_000_000
+				"#{@duration / 1_000_000_000}s"
+			else
+				"#{(@duration / 60_000_000_000)}m"
+			end
+    end
+	end
+
+	def self.time
+	  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+		yield
+		finish = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+		Duration.new(finish - start)
+	end
+end

data/lib/quickdraw/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quickdraw
-  VERSION = "0.0.5"
+	VERSION = "0.1.0"
 end

data/lib/quickdraw/worker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Quickdraw::Worker
+	def self.fork
+		pipe = Quickdraw::Pipe.new
+
+		pid = Process.fork do
+			pipe.with_writer do |writer|
+				yield(writer)
+			end
+		end
+
+		new(pid:, pipe:)
+	end
+
+	def initialize(pid:, pipe:)
+		@pid = pid
+		@pipe = pipe
+	end
+
+	def wait
+		Process.wait(@pid)
+
+		@pipe.with_reader do |reader|
+			reader.read
+		end
+	end
+end

data/lib/quickdraw.rb

@@ -1,33 +1,40 @@
-require "quickdraw/version"
-require 'pathname'
-require 'filepath'
+# frozen_string_literal: true
 
 module Quickdraw
+	autoload :Cluster, "quickdraw/cluster"
+	autoload :Configuration, "quickdraw/configuration"
+	autoload :Context, "quickdraw/context"
+	autoload :Expectation, "quickdraw/expectation"
+	autoload :Matchers, "quickdraw/matchers"
+	autoload :Pipe, "quickdraw/pipe"
+	autoload :Registry, "quickdraw/registry"
+	autoload :Run, "quickdraw/run"
+	autoload :Runner, "quickdraw/runner"
+	autoload :Timer, "quickdraw/timer"
+	autoload :Worker, "quickdraw/worker"
+	autoload :Queue, "quickdraw/queue"
+	autoload :Map, "quickdraw/map"
 
-	NOOPParser = Proc.new {|data, format| {} }
-	TIMER_RESET = 5 * 60 + 5
-	PERMIT_LOWER_LIMIT = 10
+	SUCCESS_EMOJI = %w[💃 🕺 🎉 🎊 💪 👏 🙌 ✨ 🥳 🎈 🌈 🎯 🏆]
 
-	def self.config
-		@config ||= if File.exist? 'config.yml'
-			            config = YAML.load(File.read('config.yml'))
-			            config
-			          else
-				          puts "config.yml does not exist!"
-				          {}
-			          end
-	end
+	Null = Object.new.freeze
+	Config = Configuration.new
 
-	def self.getwd
-		FilePath.getwd
-	end
+	module Error; end
 
-	def self.theme_dir
-		FilePath.getwd / 'theme'
+	class TestFailure < RuntimeError
+		include Error
 	end
 
-	def self.src_dir
-		FilePath.getwd / 'src'
+	class ArgumentError < ::ArgumentError
+		include Error
 	end
 
+	def self.configure(&block)
+		if block.arity == 0
+			Config.instance_eval(&block)
+		else
+			yield Config
+		end
+	end
 end