drain 0.1.0 → 0.2.0

data/test/test_graph.rb

@@ -0,0 +1,126 @@
+require 'helper'
+require 'dr/base/graph'
+
+# This segfaults in ruby-2.2.0, but seems corrected in ruby-2.3-dev
+describe DR::Graph do
+	before do
+		@graph=DR::Graph.new({"foo"=> ["bar","baz"], "bar" => "baz"})
+	end
+
+	it "builds the graph" do
+		@graph.nodes.length.must_equal 3
+	end
+
+	it "accepts :to_a" do
+		@graph.to_a.map(&:name).must_equal(["foo", "bar", "baz"])
+	end
+
+	it "accepts :to_hash" do
+		@graph.to_hash.first[1].keys.must_equal [:children, :parents, :attributes]
+	end
+	
+	it "can be converted to a hash" do
+		@graph.to_h.must_equal ({"foo"=> ["bar","baz"], "bar" => ["baz"], "baz" => []})
+	end
+
+	it "can give a node" do
+		@graph["foo"].class.must_equal DR::Node
+	end
+
+	it "can give descendants of a node" do
+		@graph["foo"].descendants.map(&:to_s).must_equal(["bar", "baz"])
+	end
+
+	it "can give ancestors of a node" do
+		@graph["baz"].ancestors.map(&:to_s).must_equal(["foo", "bar"])
+	end
+
+	it "can give the root nodes" do
+		@graph.roots.map(&:name).must_equal(["foo"])
+	end
+
+	it "can give the bottom nodes" do
+		@graph.bottom.map(&:name).must_equal(["baz"])
+	end
+
+	it "can show all ancestors of nodes" do
+		@graph.ancestors("baz","bar").map(&:to_s).must_equal(["baz", "bar", "foo"])
+		@graph.ancestors("baz","bar", ourselves: false).map(&:to_s).must_equal(["foo"])
+	end
+
+	it "can show all descendants of nodes" do
+		@graph.descendants("foo","bar").map(&:to_s).must_equal(["foo", "bar", "baz"])
+		@graph.descendants("foo","bar", ourselves: false).map(&:to_s).must_equal(["baz"])
+	end
+
+	it "can give a hash of children" do
+		@graph.to_children.must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>[]})
+	end
+
+	describe "build" do
+		it "accepts a Hash" do
+			@graph.build({"plim" => "foo"})
+		end
+	end
+
+	it "detects unneeded nodes" do
+		@graph.unneeded("foo","bar").map(&:name).must_equal ["foo","bar"]
+		@graph.unneeded("bar").map(&:name).must_equal []
+	end
+	it "detects unneeded descendants" do
+		@graph.unneeded_descendants("foo").map(&:name).must_equal ["foo", "bar", "baz"]
+	end
+
+	describe "It works with a cycle" do
+		before do
+			@graph=DR::Graph.new({"foo"=> ["bar","baz"], "bar" => ["baz"], "baz" => "foo"})
+		end
+
+		it "It builds the graph" do
+			@graph.nodes.length.must_equal 3
+		end
+	end
+
+	describe "It works with a lambda to describe the graph" do
+		before do
+			infos=-> (node) do
+				case node
+				when "foo"
+					return {children: ["bar","baz"]}
+				when "bar"
+					return {children: ["baz"]}
+				when "baz"
+					return {children: "foo", attributes: {real: true}}
+				end
+			end
+			@graph=DR::Graph.new(*["foo","bar","baz"],infos: infos)
+		end
+
+		it "It builds the graph" do
+			@graph.nodes.length.must_equal 3
+			@graph.to_h.must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>["foo"]})
+			@graph['baz'].attributes.must_equal(real: true)
+		end
+	end
+
+	describe "It can be merged with another graph" do
+		before do
+			@graph2=DR::Graph.new({"foo" => ["bar"], "baz" => ["bar", "qux"]})
+		end
+
+		it "Graph2 is well defined" do
+			@graph2.nodes.map(&:name).must_equal(%w(foo bar baz qux))
+		end
+
+		it "Can be merged in place" do
+			@graph | @graph2
+			@graph.to_h.must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>["bar", "qux"], "qux"=>[]})
+		end
+
+		it "Can be merged" do
+			@graph3 = @graph + @graph2
+			@graph.to_h.must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>[]})
+			@graph3.to_h.must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>["bar", "qux"], "qux"=>[]})
+		end
+	end
+end

data/test/test_meta.rb

@@ -0,0 +1,65 @@
+require "helper"
+require 'dr/ruby_ext/meta_ext'
+#Module.send :include, DR::Meta
+
+class TestMetaExt < Minitest::Test
+	def setup
+		@foo=Module.new do
+			extend DR::MetaModule
+			def foo
+				"foo"
+			end
+		end
+		@bar=Module.new do
+			def bar
+				"bar"
+			end
+		end
+		@baz=Module.new do
+			def baz
+				"baz"
+			end
+		end
+		@foo.includes_extends_host_with(@bar,@baz)
+	end
+	def test_includes
+		klass=@foo
+		test1=Class.new do
+			include klass
+		end
+		test1.new.foo
+		test1.new.bar
+		test1.baz
+	end
+	def test_extends
+		klass=@foo
+		test1=Class.new do
+			extend klass
+		end
+		test1.foo
+		test1.new.bar
+		test1.baz
+	end
+end
+
+describe DR::Meta do
+	## Does not work anymore in recent rubies (ruby 2.4+)
+	# it "Can convert a class to module" do
+	# 	(Class.new { include DR::Meta.refined_module(String) { def length; super+5; end } }).new("foo").length.must_equal(8)
+	# end
+
+	it "Can show all ancestors" do
+		DR::Meta.all_ancestors("foo").include?(String.singleton_class).must_equal(true)
+	end
+
+	it "Can generate bound methods" do
+		m=DR::Meta.get_bound_method("foo", :bar) do |x|
+			self+x
+		end
+		m.call("bar").must_equal("foobar")
+	end
+
+	it "Can apply unbound methods" do
+		DR::Meta.apply(method: String.instance_method(:length), to: "foo").must_equal(3)
+	end
+end

data/test/test_simple_parser.rb

@@ -0,0 +1,41 @@
+require 'helper'
+require 'dr/parse/simple_parser'
+
+describe DR::SimpleParser do
+	describe "parse_namevalue" do
+		it "parses a simple name value" do
+			DR::SimpleParser.parse_namevalue("foo:bar").must_equal([:foo,"bar"])
+		end
+		it "can let the name be a string" do
+			DR::SimpleParser.parse_namevalue("foo:bar",symbolize:false).must_equal(["foo","bar"])
+		end
+		it "only splits on the first ':'" do
+			DR::SimpleParser.parse_namevalue("foo:bar:baz").must_equal([:foo,"bar:baz"])
+		end
+		it "can change the separation" do
+			DR::SimpleParser.parse_namevalue("foo:bar!baz", sep: "!",symbolize:false).must_equal(["foo:bar","baz"])
+		end
+		it "can set a default" do
+			DR::SimpleParser.parse_namevalue("foo", default: 0).must_equal([:foo,0])
+		end
+		it "If the default is true then support 'no-foo'" do
+			DR::SimpleParser.parse_namevalue("no-foo", default: true).must_equal([:foo,false])
+		end
+		it "can set the default to true" do
+			DR::SimpleParser.parse_namevalue("foo", default: true, symbolize:false).must_equal(["foo",true])
+		end
+	end
+
+	describe "parse_strings" do
+		it "can parse several name values" do
+			DR::SimpleParser.parse_string("foo:bar,ploum:plim")[:values].must_equal({foo: "bar", ploum: "plim"})
+		end
+		it "can handle options" do
+			DR::SimpleParser.parse_string("name1:value1!option1=ploum!option2=plam!option3,name2:value2!!globalopt1=foo,globalopt2=bar").must_equal({
+			values: {name1: "value1", name2: "value2"},
+			local_opts: {name1: {option1:"ploum",option2:"plam",option3:true}, name2: {}},
+			global_opts: {globalopt1: "foo", globalopt2: "bar"},
+			opts: {name1: {option1:"ploum",option2:"plam",option3:true,globalopt1:"foo", globalopt2: "bar"}, name2:{globalopt1: "foo", globalopt2: "bar"}}})
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: drain
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Damien Robert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-24 00:00:00.000000000 Z
+date: 2018-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: rubygems-tasks
   requirement: !ruby/object:Gem::Requirement
@@ -63,38 +77,48 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- ".document"
 - ".gitignore"
+- ".travis.yml"
 - ".yardopts"
 - ChangeLog.md
+- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - drain.gemspec
 - gemspec.yml
+- lib/dr.rb
+- lib/dr/base.rb
+- lib/dr/base/bool.rb
+- lib/dr/base/converter.rb
+- lib/dr/base/encoding.rb
+- lib/dr/base/eruby.rb
+- lib/dr/base/functional.rb
+- lib/dr/base/graph.rb
+- lib/dr/base/utils.rb
+- lib/dr/parse.rb
+- lib/dr/parse/simple_parser.rb
+- lib/dr/parse/time_parse.rb
+- lib/dr/ruby_ext.rb
+- lib/dr/ruby_ext/core_ext.rb
+- lib/dr/ruby_ext/core_modules.rb
+- lib/dr/ruby_ext/meta_ext.rb
+- lib/dr/tools.rb
+- lib/dr/tools/gtk.rb
+- lib/dr/version.rb
 - lib/drain.rb
-- lib/drain/base.rb
-- lib/drain/base/bool.rb
-- lib/drain/base/encoding.rb
-- lib/drain/base/eruby.rb
-- lib/drain/base/functional.rb
-- lib/drain/base/graph.rb
-- lib/drain/parse.rb
-- lib/drain/parse/simple_parser.rb
-- lib/drain/parse/time_parse.rb
-- lib/drain/ruby_ext.rb
-- lib/drain/ruby_ext/core_ext.rb
-- lib/drain/ruby_ext/meta_ext.rb
-- lib/drain/tools.rb
-- lib/drain/tools/git.rb
-- lib/drain/tools/gtk.rb
-- lib/drain/version.rb
 - test/helper.rb
+- test/test_converter.rb
+- test/test_core_ext.rb
 - test/test_drain.rb
+- test/test_graph.rb
+- test/test_meta.rb
+- test/test_simple_parser.rb
 homepage: https://github.com/DamienRobert/drain#readme
 licenses:
 - MIT
-metadata: {}
+metadata:
+  yard.run: yri
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -111,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Use a drain for a dryer ruby!

data/.document

@@ -1,3 +0,0 @@
-- 
-ChangeLog.md
-LICENSE.txt

data/lib/drain/base/eruby.rb

@@ -1,28 +0,0 @@
-module DR
-	module Eruby
-		begin
-			require 'erubis'
-			Erb=::Erubis::Eruby
-		rescue LoadError
-			require 'erb'
-			Erb=::ERB
-		end
-		def erb_include(template, opt={})
-			opt={bind: binding}.merge(opt)
-			file=File.expand_path(template)
-			Dir.chdir(File.dirname(file)) do |cwd|
-				erb = Erb.new(File.read(file))
-				#if context is not empty, then we probably want to evaluate
-				if opt[:evaluate] or opt[:context]
-					r=erb.evaluate(opt[:context])
-				else
-					r=erb.result(opt[:bind])
-				end
-				#if using erubis, it is better to invoke the template in <%= =%> than
-				#to use chop=true
-				r=r.chomp if opt[:chomp]
-				return r
-			end
-		end
-	end
-end

data/lib/drain/base/graph.rb

@@ -1,213 +0,0 @@
-require 'set'
-#Originally inspired by depgraph: https://github.com/dcadenas/depgraph
-
-module DR
-	class Node
-		include Enumerable
-		attr_reader :graph
-		attr_accessor :name, :attributes, :parents, :children
-		def initialize(name, attributes: nil, graph: nil)
-			@name = name
-			@children = []
-			@parents = []
-			@attributes = attributes
-			@graph=graph
-			graph.nodes << self if @graph
-		end
-		def each
-			@children.each
-		end
-		def <=>(other)
-			return @name <=> other.name
-		end
-		#self.add_child(ploum) marks ploum as a child of self (ie ploum depends on self)
-		def add_child(*nodes)
-			nodes.each do |node|
-				if not @children.include?(node)
-					@children << node
-					node.parents << self
-				end
-			end
-		end
-		def rm_child(*nodes)
-			nodes.each do |node|
-				if @children.include?(node)
-					@children.delete(node)
-					node.parents.delete(self)
-				end
-			end
-		end
-		def add_parent(*nodes)
-			nodes.each do |node|
-				if not @parents.include?(node)
-					@parents << node
-					node.children << self
-				end
-			end
-		end
-		def rm_parent(*nodes)
-			nodes.each do |node|
-				if @parents.include?(node)
-					@parents.delete(node)
-					node.children.delete(self)
-				end
-			end
-		end
-
-		STEP = 4
-		def to_s
-			return @name
-		end
-		def to_graph(indent_level: 0)
-			sout = ""
-			margin = ''
-			0.upto(indent_level/STEP-1) { |p| margin += (p==0 ? ' ' : '|') + ' '*(STEP - 1) }
-			margin += '|' + '-'*(STEP - 2)
-			sout += margin + "#{@name}\n"
-			@children.each do |child|
-				sout += child.to_graph(indent_level: indent_level+STEP)
-			end
-			return sout
-		end
-		def to_dot
-			sout=["\""+name+"\""]
-			@children.each do |child|
-				sout.push  "\"#{@name}\" -> \"#{child.name}\""
-				sout += child.to_dot
-			end
-			return sout
-		end
-	end
-
-	class Graph
-		attr_accessor :nodes
-		include Enumerable
-		def initialize(g=nil)
-			@nodes=[]
-			if g #convert a hash to a graph
-				g.each do |name,children|
-					n=build(name)
-					n.add_child(*children)
-				end
-			end
-		end
-		def build(node, children: [], parents: [], **keywords)
-			graph_node=
-			case node
-			when Node
-				match = @nodes.find {|n| n == node} and return match
-				Node.new(node.name, graph: self, **keywords.merge({attributes: node.attributes||keywords[:attributes]}))
-				node.children.each do |c|
-					build(c,**keywords)
-				end
-			else
-				match = @nodes.find {|n| n.name == node}
-				match || Node.new(node, graph: self, **keywords)
-			end
-			graph_node.add_child(*children.map { |child| build(child) })
-			graph_node.add_parent(*parents.map { |child| build(child) })
-			return graph_node
-		end
-		def each
-			@nodes.each
-		end
-		def to_a
-			return @nodes
-		end
-		def all
-			@nodes.sort
-		end
-		def roots
-			@nodes.select{ |n| n.parents.length == 0}.sort
-		end
-		def dump(mode: :graph, nodes_list: :roots, **unused)
-			n=case nodes_list
-				when :roots; roots
-				when :all; all
-				when Symbol; nodes.select {|n| n.attributes[:nodes_list]}
-				else nodes_list.to_a
-			end
-			sout = ""
-			case mode
-			when :graph; n.each do |node| sout+=node.to_graph end
-			when :list; n.each do |i| sout+="- #{i}\n" end
-			when :dot;
-				sout+="digraph gems {\n"
-				sout+=n.map {|node| node.to_dot}.inject(:+).uniq!.join("\n")
-				sout+="}\n"
-			end
-			return sout
-		end
-
-		#return the connected set containing nodes (following the direction
-		#given)
-		def connected(*nodes, down:true, up:true)
-			r=Set.new()
-			nodes.each do |node|
-				unless r.include?(node)
-					new_nodes=Set.new()
-					new_nodes.merge(node.children) if down
-					new_nodes.merge(node.parents) if up
-					r.merge(connected(*new_nodes, down:down,up:up))
-				end
-			end
-			return r
-		end
-		#return all parents
-		def ancestors(*nodes)
-			connected(*nodes, up:true, down:false)
-		end
-		#return all childern
-		def descendants(*nodes)
-			connected(*nodes, up:false, down:true)
-		end
-
-		#from a list of nodes, return all nodes that are not descendants of
-		#other nodes in the graph
-		def unneeded(*nodes)
-			tokeep.merge(@nodes-nodes)
-			nodes.each do |node|
-				unneeded << node unless ancestors(node).any? {|c| tokeep.include?(c)}
-			end
-		end
-		#return all dependencies that are not needed by any more nodes.
-		#If some dependencies should be kept (think manual install), add them
-		#to the unneeded parameter
-		def unneeded_descendants(*nodes, needed:[])
-			needed-=nodes #nodes to delete are in priority
-			deps=descendants(*nodes)
-			deps-=needed #but for children nodes, needed nodes are in priority
-			unneeded(*deps)
-		end
-		#So to implement the equivalent of pacman -Rc packages
-		#it suffices to add the ancestors of packages
-		#For pacman -Rs, this is exactly unneeded_descendants
-		#and pacman -Rcs would be ancestors(unneeded_descendants)
-		#finally to clean all unneeded packages (provided we have a list of
-		#packages 'tokeep' to keep), either use unneeded(@nodes-tokeep)
-		#or unneeded_descendants(roots, needed:tokeep)
-
-		#return the subgraph containing all the nodes passed as parameters,
-		#and the complementary graph. The union of both may not be the full
-		#graph [edges] in case the components are not connected
-		def subgraph(*nodes)
-			subgraph=Graph.new()
-			compgraph=Graph.new()
-			@nodes.each do |node|
-				if nodes.include?(node)
-					n=subgraph.build(node.name)
-					node.children.each do |c|
-						n.add_child(c) if nodes.include?(c)
-					end
-				else
-					n=compgraph.build(node.name)
-					node.children.each do |c|
-						n.add_child(c) unless nodes.include?(c)
-					end
-				end
-			end
-			return subgraph, compgraph
-		end
-
-	end
-end