Bryton 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 515b6e28901538ec80a86cae04da951149a4c5e726d57869c86386ca34e8928f
+  data.tar.gz: c28f2fe9fb9962eef207fecdca9853e9b3489e0144a15d938bb38fbc784b7f47
+SHA512:
+  metadata.gz: 49faf782a0a7b691a854fea4211e1038fca60df54c7000a0cae5bbbb298ba75530ba8688f2db878e1709e9b5dc53fbf2f7d7352812ec65461d4bb9d04a3405a7
+  data.tar.gz: 219c8f0a8106fb9715ecd05375d78346d7a2530b721680beb70ac80eb465669defb13ad9b76e96a8b51fd135dedcdb786468cd0b3fd7b66235e36835184b5501

data/README.md

@@ -0,0 +1,23 @@
+# Bryton
+
+Bryton is a file based testing protocol. Each file contains one or more tests.
+The results of the tests are reported in STDOUT as a JSON Object.
+
+Bryton is not ready for use yet. Just sharing online for a few collaborators.
+
+## Install
+
+```
+gem install bryton
+```
+
+## Author
+
+Mike O'Sullivan
+mike@idocs.com
+
+## History
+
+| version  | date         | notes           |
+|----------|--------------|-----------------|
+| 1.0      | May 16, 2023 | Initial upload. |

data/lib/bryton/runner.rb

@@ -0,0 +1,459 @@
+#!/usr/bin/ruby -w
+require 'timeout'
+require 'json'
+require 'fso'
+require 'hash/digger'
+require 'talk-to-me'
+
+
+#===============================================================================
+# Bryton
+#
+module Bryton
+end
+#
+# Bryton
+#===============================================================================
+
+
+# load bryton xeme classes
+require 'bryton/xeme'
+
+
+#===============================================================================
+# Bryton::FSO
+# Just initializing namespace.
+#
+module Bryton::FSO
+end
+#
+# Bryton::FSO
+#===============================================================================
+
+
+#===============================================================================
+# Bryton::FSO::Dir
+#
+class Bryton::FSO::Dir < FSO::Dir
+	attr_reader :xeme
+	attr_accessor :stop_on_fail
+	attr_accessor :verbose
+	attr_accessor :run_tests
+	
+	#---------------------------------------------------------------------------
+	# classes
+	#
+	def self.classes
+		return {
+			'dir'=>Bryton::FSO::Dir,
+			'file'=>Bryton::FSO::File
+		};
+	end
+	#
+	# classes
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_path='./')
+		super(p_path)
+		@settings = nil
+		@children = nil
+		@stop_on_fail = false
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# settings
+	#
+	def settings
+		# cache bryton.json if necessary
+		if not @settings
+			settings_path = "#{path}/bryton.json"
+			@settings = {'active'=>true}
+			
+			# slurp in settings file
+			if ::File.exist?(settings_path)
+				explicit = ::File.read(settings_path)
+				explicit = JSON.parse(explicit)
+				@settings = @settings.merge(explicit)
+			end
+		end
+		
+		# return
+		return @settings
+	end
+	#
+	# settings
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# meta
+	#
+	def meta
+		return settings['meta'] || {}
+	end
+	#
+	# meta
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# children
+	#
+	def children(opts={})
+		# cache @children if it's not already defined
+		if not @children
+			chdir do
+				@children = []
+				
+				# special case: files element exists but is false
+				if settings.has_key?('files') and (not settings['files'])
+					return @children
+				end
+				
+				# build list of child files
+				children_explicit opts
+				children_implicit super(), opts
+			end
+		end
+		
+		# return
+		return @children
+	end
+	#
+	# children
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# children_explicit
+	#
+	def children_explicit(opts)
+		explicits = settings['files'] || {}
+		
+		explicits.each do |child_path, child_settings|
+			if child_settings
+				if child = self.class.existing(child_path)
+					if child.settings['active']
+						@children.push child
+					end
+				else
+					raise 'non-existent-file-in-list: ' + child_path
+				end
+			end
+		end
+	end
+	#
+	# children_explicit
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# children_implicit
+	# skips dev.* files
+	#
+	def children_implicit(kids, opts)
+		# early exit: if filter is true, don't import implicit children
+		settings['listed-only'] and return
+		
+		kids.each do |child|
+			if not child_names.include?(child.name)
+				unless child.name.match(/\Adev\./mu)
+					if child.dir?
+						@children.push child
+					elsif child.executable?
+						@children.push child
+					end
+				end
+			end
+		end
+	end
+	#
+	# children_implicit
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# child_names
+	#
+	def child_names
+		return @children.map{|child| child.name}
+	end
+	#
+	# child_names
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run
+	#
+	def run(opts={})
+		opts = {'nested'=>0}.merge(opts)
+		xeme = Xeme.new()
+		
+		# verbosify
+		unless opts['first']
+			TTM.puts title(opts)
+		end
+		
+		# operate in own directory
+		chdir() do
+			TTM.indent('skip'=>opts.delete('first')) do
+				run_children xeme, opts
+				run_commands xeme, opts
+			end
+		end
+		
+		# At this point, all tests in the have been run. Attempt to succeed.
+		xeme.try_succeed
+		
+		# if set as not ready, fail anyway
+		if xeme.success?
+			if meta.has_key?('ready') and (not meta['ready'])
+				xeme['success-but-not-ready'] = true
+				xeme.fail
+			end
+		end
+		
+		# return xeme
+		return xeme
+	end
+	#
+	# run
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run_children
+	#
+	def run_children(xeme, opts)
+		children.each do |child|
+			if child.executable? or child.dir? and child.settings['active']
+				send_opts = opts.clone
+				send_opts['nested'] += 1 
+				
+				# run child, add to nested if any results
+				if nest = child.run(send_opts)
+					xeme['nested'].push nest
+					
+					if nest.failure? and @stop_on_fail
+						return
+					end
+				end
+			end
+		end
+	end
+	#
+	# run_children
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run_commands
+	#
+	def run_commands(xeme, opts)
+		commands = settings['commands'] || []
+		commands.empty? and return
+		
+		# load EzCapture
+		require 'ezcapture'
+		
+		# loop through commands
+		commands.each do |cmd|
+			nest = run_command(cmd)
+			xeme['nested'].push nest
+			
+			# exit if error
+			if nest.failure? and @stop_on_fail
+				return
+			end
+		end
+	end
+	#
+	# run_commands
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run_command
+	#
+	def run_command(cmd)
+		capture = EzCapture.new(*cmd)
+		xeme = Xeme.last_line(capture.stdout)
+		
+		# if no stdout, return failure xeme
+		if not xeme
+			xeme = Xeme.new()
+			xeme.error 'did-not-get-xeme-in-stdout'
+			return xeme
+		end
+		
+		# return
+		return xeme
+	end
+	#
+	# run_command
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# title
+	# Determines the string that should be displayed when this file is listed
+	# when verbose setting is true.
+	#
+	def title(opts)
+		# if defined name for this directory
+		if explicit = settings.digger('meta', 'title')
+			return explicit
+		
+		# else return the name of the directory
+		else
+			return name
+		end
+	end
+	#
+	# title
+	#---------------------------------------------------------------------------
+end
+#
+# Bryton::FSO::Dir
+#===============================================================================
+
+
+#===============================================================================
+# Bryton::FSO::File
+#
+class Bryton::FSO::File < FSO::File
+	#---------------------------------------------------------------------------
+	# classes
+	#
+	def self.classes
+		return {
+			'file' => Bryton::FSO::File,
+			'dir'  => Bryton::FSO::Dir
+		};
+	end
+	#
+	# classes
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(*opts)
+		super(*opts)
+		@children = nil
+		@settings = nil
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# settings
+	#
+	def settings()
+		# cache if necessary
+		if not @settings
+			default = {'active'=>true}
+			explicit = dir.settings.digger('files', name)
+			
+			# If no explicit definition of the file, initialize to empty hash.
+			if explicit.nil?
+				explicit = {}
+				
+			# If explicit is defined but is not a hash, the non-hash value is
+			# assumed to be the "active" value.
+			elsif not explicit.is_a?(Hash)
+				explicit = {'active'=>explicit}
+			end
+			
+			# by this point explicit is a hash
+			
+			# merge explicit and default
+			@settings = default.merge(explicit)
+		end
+		
+		# return
+		return @settings
+	end
+	#
+	# settings
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run
+	#
+	def run(opts={})
+		# If the file is not active, do nothing - don't even print the name.
+		if not settings['active']
+			return nil
+		end
+		
+		# verbosify
+		if opts['verbose']
+			TTM.puts title(opts)
+			
+			# message before running
+			if before = @settings.digger('messages', 'before')
+				TTM.indent do
+					TTM.puts before
+				end
+			end
+		end
+		
+		# run and return xeme if necessary
+		unless opts['list_only']
+			return run_test(opts)
+		end
+	end
+	#
+	# run
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# run_test
+	#
+	def run_test(opts)
+		capture = execute()
+		xeme = Xeme.last_line(capture.stdout)
+		
+		# if no stdout, return failure xeme
+		if not xeme
+			xeme = Xeme.new()
+			xeme.error 'did-not-get-xeme-in-stdout'
+			return xeme
+		end
+		
+		# return
+		return xeme
+	end
+	#
+	# run_test
+	#---------------------------------------------------------------------------
+		
+	
+	#---------------------------------------------------------------------------
+	# title
+	#
+	def title(opts)
+		return name
+	end
+	#
+	# title
+	#---------------------------------------------------------------------------
+end
+#
+# Bryton::FSO::File
+#===============================================================================

data/lib/bryton/tools.rb

@@ -0,0 +1,394 @@
+require 'xeme'
+require 'talk-to-me'
+
+
+#===============================================================================
+# Bryton
+#
+module Bryton
+	# instance properties
+	@exit_on_fail = false
+	@ready = true
+	@keep_count = true
+	@line_comments = false
+	
+	
+	#---------------------------------------------------------------------------
+	# accessors
+	#
+	class << self
+		attr_accessor :exit_on_fail
+		attr_accessor :ready
+		attr_accessor :keep_count
+		attr_accessor :xeme
+		attr_accessor :line_comments
+	end
+	#
+	# accessors
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# accessor methods
+	#
+	def self.verbose
+		return TTM.io ? true : false
+	end
+	
+	def self.verbose=(bool)
+		if bool
+			TTM.io = STDERR
+		else
+			TTM.io = nil
+		end
+	end
+	#
+	# accessor methods
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# reset
+	#
+	def self.reset()
+		self.verbose= true
+		@xeme = Xeme.new()
+		@xeme['count'] = 0
+	end
+	
+	reset()
+	#
+	# reset
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# pause_counting
+	#
+	def self.pause_counting
+		hold_keep_count = @keep_count
+		@keep_count = false
+		yield
+	ensure
+		@keep_count = hold_keep_count
+	end
+	#
+	# pause_counting
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# increment_count
+	#
+	def self.increment_count
+		if @keep_count
+			@xeme['count'] += 1
+		end
+	end
+	#
+	# increment_count
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# succeed
+	#
+	def self.succeed
+		if not @ready
+			@xeme.error 'not-ready'
+		end
+		
+		# set success to true
+		@xeme.try_succeed()
+		
+		# output
+		puts xeme.to_json()
+	end
+	#
+	# succeed
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# line_error
+	#
+	def self.line_error(level=1)
+		loc = caller_locations[level]
+		error = @xeme.error('line-' + loc.lineno.to_s)
+		
+		# get line comment if there is one
+		line_comment error, loc
+		
+		# exit if exiting on first fail
+		maybe_exit_on_fail()
+	end
+	#
+	# line_error
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# line_comment
+	#
+	def self.line_comment(error, loc)
+		@line_comments or return
+		
+		# KLUDGE: I don't understand why loc.lineno and the line number are two
+		# apart.
+		idx = 2
+		
+		# read file
+		File.foreach(loc.path) do |line|
+			if idx == loc.lineno
+				if line.sub!(/\A\s*\#\#\s*/mu, '')
+					if line.match(/\S/mu)
+						line = line.sub(/\s+\z/mu, '')
+						error['comment'] = line
+					end
+				end
+				
+				# we're done
+				return
+			end
+			
+			# increment current line number
+			idx += 1
+		end
+	end
+	#
+	# line_comment
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# maybe_exit_on_fail
+	#
+	def self.maybe_exit_on_fail
+		if @exit_on_fail
+			puts xeme.to_json()
+			exit
+		end
+	end
+	#
+	# maybe_exit_on_fail
+	#---------------------------------------------------------------------------
+	
+	
+	### tests
+	
+	
+	#---------------------------------------------------------------------------
+	# pass, fail
+	#
+	def self.pass
+		Bryton.increment_count()
+	end
+	
+	def self.fail
+		increment_count()
+		line_error()
+	end
+	#
+	# pass, fail
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# structure comparisons
+	#
+	def self.compare(should, is)
+		TTM.hrm
+		return Bryton::StructureComp.compare(should, is)
+	end
+	#
+	# structure comparisons
+	#---------------------------------------------------------------------------
+	
+	
+	#-------------------------------------------------------------------------------
+	# isa
+	#
+	def self.isa(obj, clss)
+		Bryton.increment_count()
+		
+		# success
+		if obj.is_a?(clss)
+			return true
+		
+		# failure
+		else
+			Bryton.line_error(2)
+			return false
+		end
+	end
+	#
+	# isa
+	#-------------------------------------------------------------------------------
+end
+#
+# Bryton
+#===============================================================================
+
+
+#===============================================================================
+# Bryton::ExceptionTest
+#
+class Bryton::ExceptionTest
+	attr_accessor :err_class
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize
+		@err_class = nil
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# exec
+	#
+	def exec
+		Bryton.increment()
+		success = false
+		e = nil
+		
+		# Run the block. If it runs successfully then it fails the test.
+		begin
+			yield
+			success = true
+			
+			# verbosify
+			TTM.puts 'block-did-not-fail'
+			
+		# We want to get to this rescue block because that means the block
+		# failed, which is what it's supposed to do.
+		rescue => e
+			# verbosify if necessary
+			
+			TTM.puts "error class: #{e.class.to_s}"
+			TTM.puts "error:       #{e}"
+			
+			# if error id, add that
+			if e.respond_to?('id')
+				TTM.puts "error id:    #{e}"
+			end
+		
+			
+			# check error class
+			if @err_class
+				if not e.class == @err_class
+					if @verbose
+						puts "error class was #{e.class.to_s} but should have been #{@err_class.to_s}"
+					end
+					
+					Bryton.line_error(2)
+				end
+			end
+		end
+		
+		# if yield succeeded, then an exception did not occur
+		if success
+			Bryton.line_error()
+		end
+		
+		# return error
+		return e
+	end
+	#
+	# exec
+	#---------------------------------------------------------------------------
+end
+#
+# Bryton::ExceptionTest
+#===============================================================================
+
+
+#===============================================================================
+# Bryton::StructureComp
+#
+module Bryton::StructureComp
+	#-------------------------------------------------------------------------------
+	# array_comp
+	#
+	def self.array_comp(should, is, opts={'recurse'=>true})
+		should.each_with_index do |should_el, idx|
+			element_comp should_el, is[idx], opts
+		end
+	end
+	#
+	# array_comp
+	#-------------------------------------------------------------------------------
+	
+	
+	#-------------------------------------------------------------------------------
+	# hash_comp
+	#
+	def self.hash_comp(should, is, opts={})
+		Bryton.increment()
+		opts = {'recurse'=>true}.merge(opts)
+		
+		
+		# early exit: is is null
+		defined is
+		is or return
+		
+		# is a hash
+		isa is, Hash
+		is.is_a?(Hash) or return
+		
+		# if not a hash, return
+		if not is.is_a?(Hash)
+			return false
+		end
+		
+		# should be of same length
+		eq should.length, is.length
+		
+		# loop through keys
+		should.keys.each do |should_k|
+			element_comp should[should_k], is[should_k], opts
+		end
+	end
+	#
+	# hash_comp
+	#-------------------------------------------------------------------------------
+	
+	
+	#-------------------------------------------------------------------------------
+	# compare
+	#
+	def self.compare(should, is, opts)
+		Bryton.increment_count()
+		
+		# should be same classes
+		if not Bryton.isa(is, should.class)
+			return
+		end
+		
+		# pause counting and recurse
+		Bryton.pause_counting do
+			# if should element is a hash
+			if should.is_a?(Hash)
+				return hash_comp(should, is, opts)
+				
+			# if should is an array
+			elsif should.is_a?(Array)
+				return array_comp(should, is, opts)
+				
+			# if should is a string
+			elsif should.is_a?(String)
+				return Bryon.eq(should, is)
+			end
+		end
+	end
+	#
+	# compare
+	#-------------------------------------------------------------------------------
+end
+#
+# Bryton::StructureComp
+#===============================================================================

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: Bryton
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Mike O'Sullivan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-16 00:00:00.000000000 Z
+dependencies: []
+description: File based testing protocol.
+email: mike@idocs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bryton/runner.rb
+- lib/bryton/tools.rb
+homepage: https://github.com/mikosullivan/bryton
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Bryton
+test_files: []