manager 0.0.0 → 0.1.0

data/lib/manager/annotation

@@ -0,0 +1,96 @@
+#!ruby
+# frozen_string_literal: true
+
+# Copyright (c) 2016 sawa
+
+class Manager
+	class AnnotationExtractor
+		AnnotationLine = /#(?<scope>!{1,2})\s*(?:(?<tag>[^\s:]*):)?\s*(?<text>.+)?/
+		ContinuationOrCommentLine = /^#\s*(?<text>.+)?/
+		ContinuationLine = /^\s+#\s*(?<text>.+)?/
+		BlockCommentStart = /^=begin\s/
+		BlockCommentEnd = /^=end[\s\z]/
+		DebugCommand = /^puts\b|^p\b|\.intercept\b/
+
+		def initialize f
+			#! Annotation and block comment can expand for multiple lines, hence the need of flag.
+			@tag, @block_comment, @io, @f, @l = nil, nil, File.new(f), f, 0
+			@feature = []
+		end
+		def read_upto modul, type, alt, (f, l)
+			#! The reported event might not be directly defining a method, but instead, for example,
+			#   aliasing a method name to a method already defined at some other location. These
+			#   cases will occur with a combination of a file name and a line number that do not 
+			#   point toward a forward location relative to the current read point, and hence 
+			#   can be ignored.
+			return unless f == @f and l > @l
+			read_line until @l == l
+			case @feature.last &.[](1) when :instance, :singleton
+				@feature.pop
+			end
+			case type
+			when :module_end
+				@feature.pop
+			else
+				@feature.push([modul, type, Manager.main_method(alt)])
+			end
+		end
+		def close
+			read_line until @io.eof?
+			@io.close
+		end
+		def read_line
+			@l += 1
+			s = @io.gets
+			return if @feature.empty?
+			case s
+			when AnnotationLine
+				@global = $~[:scope].length == 2
+				@tag = $~[:tag] || Manager.current.counts[:annotation] += 1
+				text = $~[:text] &.strip
+			when DebugCommand
+				@tag = :debug
+				text = nil
+			when BlockCommentStart
+				@tag = :comment
+				@block_comment = true
+				text = nil
+			when BlockCommentEnd
+				@tag = :comment
+				@block_comment = nil
+				text = nil
+			when ContinuationOrCommentLine
+				case @tag
+				when String, Integer
+					text = $~[:text] &.strip
+				else
+					@tag = :comment
+					text = nil
+				end
+			when ContinuationLine
+				case @tag
+				when String, Integer
+					text = $~[:text] &.strip
+				else
+					@tag = nil
+					return
+				end
+			else
+				if @block_comment
+					@tag = :comment
+					text = nil
+				else
+					@tag = nil
+					return
+				end
+			end
+			feature = @tag.is_a?(String) && @global ? [Main, @f, nil] : @feature.last
+			a, s = (Manager.current.annotations[feature] ||= {})[@tag] ||= [[], +""]
+			a.push([@f, text.!.!, @l])
+			if text
+				s.concat(Render::Annotation::Joiner) unless s.empty?
+				s.concat(text)
+			end
+		end
+	end
+end

data/lib/manager/input

@@ -0,0 +1,189 @@
+#!ruby
+#frozen-string-literal: true
+
+# Copyright (c) 2016 sawa
+
+class String
+	def code lang = :ruby
+		Manager::Render::UserCode.new(self, lang)
+	end
+	def code! lang = :ruby
+		Manager::Render::DevCode.new(self, lang)
+	end
+	def setup
+		Manager::Setup.new(self, caller_locations.first)
+	end
+end
+
+module Manager::MethodSignatureItem
+	def | other
+		unless Manager::MethodSignatureItem === other
+			raise "Expecting a value, exception, or a `Class`: #{other}."
+		end
+		Manager::MethodSignatureAlternatives.new(self, other)
+	end
+end
+
+class Manager::MethodSignatureValue
+	def initialize obj; @obj = obj end
+	def to_s; "`#{@obj.inspect}`" end
+	include Manager::MethodSignatureItem
+end
+
+class Manager::MethodSignatureException
+	def initialize exception; @exception = exception end
+	def to_s; "raise #{@exception.inspect}" end
+	include Manager::MethodSignatureItem
+end
+
+class Class
+	include Manager::MethodSignatureItem
+end
+
+class Manager::MethodSignatureAlternatives
+	attr_reader :classes
+	def initialize *classes; @classes = classes end
+	def to_s; @classes.map(&:to_s).join(" | ") end
+	def | other
+		unless Manager::MethodSignatureItem === other
+			raise "Expecting a value, exception, or a `Class`: #{other}."
+		end
+		@classes.push(other)
+		self
+	end
+end
+
+#! Rather than defining the methods in `main` or in a common module and including that module in both `main.singleton_class` and `Module`, repeating this definition directly in `main.singleton_class` and `Module` so as to minimize pollution i.e. avoid poluting the main name space with these methods.
+
+def self.hide spec
+	Manager.current.hide(spec)
+end
+def self.move spec
+	Manager.current.move(spec)
+end
+def self.spec feature, *items, coda
+	Manager.current._spec(self, *Manager.validate_feature_call(self, feature, coda), items)
+end
+def self.coda; Manager::Coda end
+def self.value obj
+	Manager::MethodSignatureValue.new(obj)
+end
+def self.error klass = RuntimeError
+	unless Class === klass and klass <= Exception
+		raise "Expecting an `Exception` subclass: #{klass}."
+	end
+	Manager::MethodSignatureException.new(klass)
+end
+def self.image text, f, **style
+if style.empty? #!Ruby bug
+	Manager::Render::UserImage.new(text, f)
+else
+	Manager::Render::UserImage.new(text, f, style)
+end
+end
+def self.image! text, f, **style
+if style.empty? #!Ruby bug
+	Manager::Render::DevImage.new(text, f)
+else
+	Manager::Render::DevImage.new(text, f, style)
+end
+end
+def self.teardown; Manager::Render::Teardown end
+
+#! Unlike the other methods above, this one is not defined on `main.singleton_class` and `Module` because it should be callable from within `receiver.instance_eval{...}` environment inside a setup."
+def expr exp
+	raise "Expecting a string: `#{exp}`." unless String === exp
+	Manager::Expr.new(exp, caller_locations)
+end
+
+class Module
+	def hide spec
+		Manager.current.hide(spec)
+	end
+	def move spec
+		Manager.current.move(spec)
+	end
+	def spec feature, *items, coda
+		print "Reading #{caller_locations.first}:`spec`..."; $stdout.flush
+		Manager.current._spec(self, *Manager.validate_feature_call(self, feature, coda), items)
+		.tap{print "Done\r"; $stdout.flush}
+	end
+	def coda; Manager::Coda end
+	def value obj
+		Manager::MethodSignatureValue.new(obj)
+	end
+	def error klass = RuntimeError
+		unless Class === klass and klass <= Exception
+			raise "Expecting an `Exception` subclass: #{klass}."
+		end
+		Manager::MethodSignatureException.new(klass)
+	end
+	def image text, f, **style
+if style.empty? #!Ruby bug
+		Manager::Render::UserImage.new(text, f)
+else
+		Manager::Render::UserImage.new(text, f, style)
+end
+end
+	def image! text, f, **style
+if style.empty? #!Ruby bug
+		Manager::Render::DevImage.new(text, f)
+else
+		Manager::Render::DevImage.new(text, f, style)
+end
+	end
+	def teardown; Manager::Render::Teardown end
+end
+
+def self.gemspec f
+	f = File.expand_path(f, File.dirname(caller_locations.first.absolute_path))
+	Manager.current.gemspec(f)
+end
+def self.manage f
+	Manager.current.manage(f &&
+	File.expand_path(f, File.dirname(caller_locations.first.absolute_path)))
+end
+
+class BasicObject
+	using ::Manager::TesterRefinement
+
+	def UT *args, **kargs, &pr
+		::Manager::UnitTest.new(nil, self, [args, kargs, pr])
+	end
+	def BM *args, **kargs, &pr
+		::Manager::Benchmark.new(self, [args, kargs, pr])
+	end
+	UT = ::Manager::SanitizedObject.new
+	RETURN = ::Manager::SanitizedObject.new
+	RECEIVER = ::Manager::SanitizedObject.new
+	OUTPUT = ::Manager::SanitizedObject.new
+	BM = ::Manager::SanitizedObject.new
+	def UT.method_missing method, *args, **kargs, &pr
+if kargs.empty? #!Ruby bug
+		::Manager::UnitTest.new(nil, nil, nil).__send__(method, *args, &pr)
+else
+		::Manager::UnitTest.new(nil, nil, nil).__send__(method, *args, **kargs, &pr)
+end
+	end
+	def RETURN.method_missing method, *args, **kargs, &pr
+if kargs.empty? #!Ruby bug
+		::Manager::UnitTest.new(:return, nil, nil).__send__(method, *args, &pr)
+else
+		::Manager::UnitTest.new(:return, nil, nil).__send__(method, *args, **kargs, &pr)
+end
+	end
+	def RECEIVER.method_missing method, *args, **kargs, &pr
+if kargs.empty? #!Ruby bug
+		::Manager::UnitTest.new(:receiver, nil, nil).__send__(method, *args, &pr)
+else
+		::Manager::UnitTest.new(:receiver, nil, nil).__send__(method, *args, **kargs, &pr)
+end
+	end
+	def OUTPUT.method_missing method, *args, **kargs, &pr
+if kargs.empty? #!Ruby bug
+		::Manager::UnitTest.new(:output, nil, nil).__send__(method, *args, &pr)
+else
+		::Manager::UnitTest.new(:output, nil, nil).__send__(method, *args, **kargs, &pr)
+end
+	end
+end

data/lib/manager/js

@@ -0,0 +1,257 @@
+//-*-mode: javascript-*-
+
+// Copyright (c) 2014-2016 sawa
+
+var main;
+var scrollMargin;
+
+// Scroll to the anchor.
+window.onhashchange = function(e) {
+//	location.href = location.hash;
+//	main.scrollTop -= main.offsetHeight * 0.5 + scrollMargin;
+	main.scrollTop -= scrollMargin;
+};
+
+document.body.onload = function() {
+	main = document.getElementById('main');
+	//This line is needed to invoke `window.onhashchange` even when `location.hash`
+	//  is the same as the previous load.
+	location.hash = '';
+	//TODO. Import data from webstore.
+	//location.hash =
+	var joinQuery = function(obj, prefix, affix){
+		return prefix + obj.dataset.tags.split(' ').join(affix + ', ' + prefix) + affix;
+	}
+	var tagsumPrefix = '#tagsum-', tagsumAffix = ':not([style="opacity: 0.2;"])';
+	var i, obj, query;
+	query = '.feature:not([style="display: none;"]) .tag.';
+	for(i = 1; obj = document.getElementById('user-feature-navigation' + i); i++) {
+		obj.query = joinQuery(obj, query, '');
+		obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
+		initializeNavigation(obj);
+	}
+	for(i = 1; obj = document.getElementById('dev-feature-navigation' + i); i++) {
+		obj.query = joinQuery(obj, query, '');
+		obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
+		initializeNavigation(obj);
+	}
+	query = '\
+	.feature:not([style="display: none;"]):not([folded="true"]) \
+	.feature-contents > :not([style="display: none;"]) \
+	.anchor:not([style="display: none;"]) \
+	.tag.';
+	for(i = 1; obj = document.getElementById('anchor-navigation' + i); i++) {
+		obj.query = joinQuery(obj, query, '');
+		obj.tagsums = joinQuery(obj, tagsumPrefix, tagsumAffix);
+		initializeNavigation(obj);
+	}
+	var objs = document.getElementsByClassName('feature');
+	for(var i = 0; i < objs.length; i++) {
+		// TODO. copy from webstore if any.
+		objs[i].hiddenFor = {};
+//		hide(objs[i], Object.keys(objs[i].hiddenFor).length);
+	}
+	switch(document.body.id){
+		case 'user':
+			scrollMargin = 200;
+			// Click "Features" button.
+			document.getElementById('top').children[0].children[1].onclick();
+		break;
+		case 'dev':
+			// Approximates half of line height from experience. TODO: Do it logically.
+			scrollMargin = 200;
+			// Click "Full" button. (Neccessary to do this also for adding `folded` attribute)
+			document.getElementById('top').children[0].children[2].onclick();
+		break;
+	}
+	// Prevents feature toggling.
+	// Overwriting `onclick` does not interfere with linking to `href`; it is different from `onclick`.
+	var objs = document.getElementsByTagName('a');
+	for(var i = 0; i < objs.length; i++) objs[i].onclick = function(e) {e.stopPropagation();};
+};
+
+initializeNavigation = function(obj) {
+	obj.features = document.querySelectorAll(obj.query);
+	var sum = obj.features.length;
+	obj.querySelector('.sum').innerText = sum;
+	var excluded = -sum;
+	var objs = document.querySelectorAll(obj.tagsums);
+	for(var i = 0; i < objs.length; i++) excluded += parseInt(objs[i].innerText);
+	obj.querySelector('.excluded').innerText = excluded;
+	var current = obj.querySelector('.current');
+	if(sum == 0) {
+		current.innerText = 1;
+	} else {if(parseInt(current.innerText) > sum
+		) current.innerText = sum;
+	};
+};
+
+initializeNavigations = function() {
+	for(var i = 1, obj; obj = document.getElementById('user-feature-navigation' + i); i++
+	) initializeNavigation(obj);
+	for(var i = 1, obj; obj = document.getElementById('dev-feature-navigation' + i); i++
+	) initializeNavigation(obj);
+	for(var i = 1, obj; obj = document.getElementById('anchor-navigation' + i); i++
+	) initializeNavigation(obj);
+};
+
+getFeatureNodeFromId = function(id) {
+	var obj = document.getElementById(id);
+	if(!obj) return null;
+	while(true) {
+		if(obj.className == 'feature') return obj;
+		obj = obj.parentNode;
+		if(!obj) return null;
+	}
+};
+
+getIdFromObj = function(obj) {
+	while(true) {
+		if(obj.id) return obj.id;
+		obj = obj.parentNode;
+		if(!obj) return null;
+	}
+};
+
+hide = function(obj, bool) {obj.style.display = bool ? 'none' : null;};
+
+inactivate = function(obj, bool) {obj.style.opacity = bool ? 0.2 : null;};
+
+mark = function(obj, bool) {return obj.marking = bool;};
+
+toggleMarking = function(obj) {return obj.marking = !obj.marking;};
+
+hideByTag = function(obj, tag, bool) {
+	if(bool) {obj.hiddenFor[tag] = true;} else {delete obj.hiddenFor[tag];};
+	hide(obj, Object.keys(obj.hiddenFor).length);
+};
+
+foldModuleContents = function(obj, bool){
+	obj.firstChild.setAttribute('folded', bool);
+	var objs = obj.childNodes;
+	foldFeatureContents(objs[0], bool);
+	// From the second children.
+	for (var i = 1; i < objs.length; i++) hideByTag(objs[i], 'folded', bool);
+	return bool;
+};
+
+foldFeatureContents = function(obj, bool){
+	obj.setAttribute('folded', bool);
+	hide(obj.firstChild.nextSibling, bool);
+	return bool;
+};
+
+displayMode = function(bool1, bool2) {
+	var objs = document.getElementsByClassName('module');
+	for(var i = 0; i < objs.length; i++) foldModuleContents(objs[i], mark(objs[i], bool1));
+	// `[onclick]`: Features with `type` `:module_as_constant` are not clickable.
+	// `:not(:first-child)`: Don't fold module headers here.
+	var objs = document.querySelectorAll('.feature[onclick]:not(:first-child)');
+	for(var i = 0; i < objs.length; i++) foldFeatureContents(objs[i], mark(objs[i], bool2));
+	initializeNavigations();
+};
+
+toggleModuleContents = function(feature) {
+	var module = feature.parentNode;
+	var bool = foldModuleContents(module, toggleMarking(module));
+	if(bool) {
+		module.scrollIntoView();	
+		window.onhashchange();
+	}
+	initializeNavigations();
+};
+
+toggleFeatureContents = function(feature) {
+	var bool = foldFeatureContents(feature, toggleMarking(feature));
+	if(bool) {
+		feature.scrollIntoView();	
+		window.onhashchange();
+	}
+	initializeNavigations();
+};
+
+toggleUserItems = function(button) {
+	// recordScrollPosition();
+	var bool = toggleMarking(button);
+	inactivate(button, bool);
+	objs = document.getElementsByClassName('user-item');
+	for(i = 0; i < objs.length; i++) hide(objs[i], bool);
+	initializeNavigations();
+	// resumeScrollPosition();
+};
+
+toggleFeatures = function(button, tag, navigation) {
+	// recordScrollPosition();
+	var bool = toggleMarking(button);
+	inactivate(button, bool);
+	inactivate(document.getElementById('tagsum-' + tag), bool);
+	for(var i = 1, obj; obj = getFeatureNodeFromId(tag + i); i ++) hideByTag(obj, tag, bool);
+	navigation = document.getElementById(navigation);
+	initializeNavigations();
+	// resumeScrollPosition();
+};
+
+toggleAnchors = function(button, tag, navigation) {
+	// recordScrollPosition();
+	var bool = toggleMarking(button);
+	inactivate(button, bool);
+	inactivate(document.getElementById('tagsum-' + tag), bool);
+	for(var i = 1, obj; obj = document.getElementById(tag + i); i ++) hide(obj, bool);
+	navigation = document.getElementById(navigation);
+	initializeNavigation(navigation);
+	// resumeScrollPosition();
+};
+
+navigateTag = function(navigation, d) {
+	var n = navigation.features.length;
+	if(n == 0) return;
+	var old = document.getElementById('current');
+	if(old) old.removeAttribute('id');
+	var current = navigation.querySelector('.current');
+	current.id = 'current';
+	var i = parseInt(current.innerText) + d;
+	if(i < 1) i = 1;
+	if(i > n) i = n;
+	current.innerText = i;
+	location.hash = getIdFromObj(navigation.features[i - 1]);
+};
+
+//var lastToggled =
+//var lastViewPort =
+recordScrollPosition = function() {
+//	main.scrollTop = navigation.features[i - 1].offsetTop - main.offsetTop;
+/*
+foo = function(obj) {
+	var ref =  window.scrollY - window.pageYOffset + document.documentElement.clientTop;
+	var checkChildDivs = function() {
+		var children = obj.childNodes;
+		if (children.length) {[].forEach.call(children, function(e, i, a) {
+			if (e.toString() === "[object HTMLDivElement]") {
+				// the top of the div relative to the document
+				// minus the height of window hidden above the top of the screen
+				var top = e.getBoundingClientRect().top;
+				// top and bottom posns relative to the top of the screen
+				// the top and bottom distances of the element relative to the top of the screen
+				// the div overlaps the screen top
+				if ((top <= ref) && (ref <= top + e.offsetHeight)) {
+					obj = e;
+					checkChildDivs();
+					return false;
+				}
+			}
+		});}
+	};
+	checkChildDivs();
+	return obj;
+};
+*/
+};
+
+resumeScrollPosition = function() {
+};
+
+coverage = function(obj){
+	alert("Sorry, this function is not implemented.");
+//	alert(obj.nextSibling.contentDocument.querySelector('body').innerText);
+//	var f = obj.dataset.file;
+};