drain 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6705260fddd5fa51a51c2985c143400b89527c0ee0d2bffcc326f5fe2bbff6f3
-  data.tar.gz: 744ca23e60895094238628160e1dc3c3dfccdaa58d757013880835e96f3de21f
+  metadata.gz: 3dea94fa15923f71b70d9dc67df57c6ea196e0cd68e2b8bf68dca52af40b98cc
+  data.tar.gz: eef6894d11959d219f09bb3c6e9f8a81d04a1c35ff262ca61aca6fe16b44e0c9
 SHA512:
-  metadata.gz: b3fe3cfd0ea0d9f9bd10df890a97b958bc8652e33b0993692188481d4759e242a5603dedcb696f244cc2f1b2dd835ba0520e2620d9ab2490339f028c0bb504b5
-  data.tar.gz: e61a5c90fb6f6bd515fa101667f53e53ad780f712196f5db8418800e8bc8c00697196188cb6efde4f2ec2ceffd962c9be63280350eb37c9327bfac26ac91248d
+  metadata.gz: 21cbef6b4255d768f7c4b827edb317432e8c82c19aedc26cd11055c25883f5d09e8f53dc726432b0c0736465ed78800da0e2369a6d87bede7318905c7993eddb
+  data.tar.gz: 8ca316496349c54e69ef811b6eb2f90326c254d8a95c8b380a45509240d2d50bd0d5dc1765abac63a64ebb127e802224fd2cf4c5481d1b2c6ffe7af8dcbda74a

data/.github/workflows/ruby.yml

@@ -0,0 +1,25 @@
+name: Ruby
+
+on: [push]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+        ruby: [ 2.3, 2.4, 2.5, 2.6, 2.7, jruby, truffleruby ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: 'Git checkout'
+      uses: actions/checkout@v2
+    - name: 'Setup ruby'
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: 'Install bundler and gems'
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+    - name: "Run tests"
+      run: |
+        bundle exec rake test

data/.travis.yml

@@ -1,9 +1,13 @@
 ---
 language: ruby
 rvm:
-  - 2.5.1
-  - 2.4.4
-  - 2.3.7
+  - 2.7.0
+  - 2.6.5
+  - 2.5.7
+  - 2.4.9
+  - 2.3.8 #eol, but still used in debian
+  #- 2.2.10
+  #- 2.1.10
   #- ruby-head
   #- ruby-head-clang
 script: rake test

data/ChangeLog.md

@@ -1,3 +1,13 @@
+== Release v0.6.0 (2020-02-26) ==
+
+	* Add github actions for tests
+	* Add github action for tests
+	* Bump travis versions
+	* Fix ruby 2.7 warning
+	* graph.rb: add merge! and merge
+	* test: fix minitest warnings
+	* gemspec: add chronic and chronic_duration
+
 == Release v0.5.1 (2020-02-18) ==
 
 	* DR::URI -> DR::URIEscape

data/Gemfile

@@ -2,6 +2,9 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :development do
+group :extra_devel do
+  gem 'minitest-reporters', '~> 1.4'
+  gem 'yard', '~> 0.9'
   gem 'kramdown'
+  gem 'rubygems-tasks', '~> 0.2'
 end

data/README.md

@@ -3,9 +3,10 @@
 * [Homepage](https://github.com/DamienRobert/drain#readme)
 * [Issues](https://github.com/DamienRobert/drain/issues)
 * [Documentation](http://rubydoc.info/gems/drain)
-* [Email](mailto:Damien.Olivier.Robert+gems at gmail.com)
+* [Email](mailto:Damien.Olivier.Robert+gems@gmail.com)
 
 [![Gem Version](https://img.shields.io/gem/v/drain.svg)](https://rubygems.org/gems/drain)
+[![Ruby test result](https://github.com/DamienRobert/drain/workflows/Ruby/badge.svg)](https://github.com/DamienRobert/drain/actions?query=workflow%3ARuby)
 [![Build Status](https://travis-ci.org/DamienRobert/drain.svg?branch=master)](https://travis-ci.org/DamienRobert/drain)
 
 ## Description
@@ -17,15 +18,25 @@ The Api is far from stable yet, so use at your own risk!
 
   For now the API is experimental and some parts are not ready to use!
 
+## Examples
+
+    ~~~ ruby
+    require 'drain'
+    ~~~
+
+## Requirements
+
 ## Install
 
+    ~~~ sh
     $ gem install drain
+    ~~~
 
 ## Copyright
 
-Copyright © 2015–2018 Damien Robert
+Copyright © 2015–2020 Damien Robert
 
-MIT License. See [LICENSE.txt](./LICENSE.txt) for details.
+MIT License. See [`LICENSE.txt`](LICENSE.txt) for details.
 
 Some of the code is inspired by other project, in general I give proper
 acknowledgement in the corresponding file.

data/Rakefile

@@ -1,3 +1,9 @@
+## Uncomment to use `rake` directly rather than `bundle exec rake`
+#begin
+#  require 'bundler/setup'
+#rescue LoadError => e
+#  warn "Could not setup bundler: #{e.message}"
+#end
 require 'rake'
 
 require 'rake/testtask'
@@ -15,6 +21,7 @@ rescue LoadError => e
     warn e.message
   end
 end
+desc 'Generate docs'
 task :doc => :yard
 
 begin
@@ -24,3 +31,4 @@ rescue LoadError => e
   warn e.message
 end
 
+task :default => :test

data/drain.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |gem|
     end
   end
   gem.files = glob[gemspec['files']] if gemspec['files']
+  gem.files = gem.files + gemspec['extra_files'] if gemspec['extra_files']
 
   gem.executables = gemspec.fetch('executables') do
     glob['bin/*'].map { |path| File.basename(path) }

data/gemspec.yml

@@ -9,6 +9,6 @@ homepage: https://github.com/DamienRobert/drain#readme
 
 development_dependencies:
   minitest: "~> 5.0"
-  rake: "~> 10"
-  rubygems-tasks: "~> 0.2"
-  yard: "~> 0.8"
+  rake: ">= 10"
+  chronic: "~> 0.10"
+  chronic_duration: "~> 0.10"

data/lib/dr/base/graph.rb

@@ -225,14 +225,17 @@ module DR
 		end
 
 		# allow a hash too
-		def |(graph)
+		def merge!(graph)
 			graph=Graph.new(graph, **{}) unless Graph===graph
 			build(*graph.all, recursive: false)
 		end
-		def +(graph)
+		def merge(graph)
 			clone.|(graph)
 		end
 
+		alias | merge!
+		alias + merge
+
 		def dump(mode: :graph, nodes_list: :roots, show_attr: true, out: [], **_opts)
 			n=case nodes_list
 				when :roots; roots
@@ -377,7 +380,7 @@ module DR
 				while !new_nodes.empty?
 					g2=yield(*new_nodes)
 					g2=Graph.new(g2) unless g2.is_a?(Graph)
-					g|g2
+					g.merge!(g2)
 					nodes=nodes.concat(new_nodes)
 					new_nodesg.nodes.map(&:name)-nodes
 				end

data/lib/dr/parse/time_parse.rb

@@ -15,7 +15,7 @@ module DR
 				first=m[1]
 				second=m[2]
 				opt[:norange]=true
-				return Chronic::Span.new(self.parse(first, opt),self.parse(second,opt))
+				return Chronic::Span.new(self.parse(first, **opt),self.parse(second, **opt))
 			end
 
 			if s.match(/\A[[:space:]]*\z/) # blank

data/lib/dr/version.rb

@@ -1,4 +1,4 @@
 module DR
   # drain version
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/drain/version.rb

@@ -0,0 +1,4 @@
+module Drain
+  # drain version
+  VERSION = "0.1.0"
+end

data/test/helper.rb

@@ -1,11 +1,21 @@
+## Uncomment if you want to run a test directly without running
+## `bundle exec ruby -I test test/test_...rb`
+## (another solution if 'bundler/setup' is called on the Rakefile is to use
+## `rake test TEST=test/test_...rb`)
+# begin
+#   require 'bundler/setup'
+# rescue LoadError => error
+#   warn "Could not setup bundler: #{error.message}"
+# end
+
 require 'minitest/autorun'
 
 ## Uncomment to launch pry on a failure
 #require 'pry-rescue/minitest'
 
 begin
-  # require 'minitest/reporters'
-  # Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+  require 'minitest/reporters'
+  Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
   #Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
   #Minitest::Reporters.use! Minitest::Reporters::ProgressReporter.new
 rescue LoadError => error

data/test/test_converter.rb

@@ -17,26 +17,26 @@ describe DR::Converter do
 	end
 
 	it "Output a hash with the attributes" do
-		DR::Converter.to_hash(@obj1, methods: [:a,:h]).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}})
+		_(DR::Converter.to_hash(@obj1, methods: [:a,:h])).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}})
 	end
 
 	it ":compact compress the values when there is only one method" do
-		DR::Converter.to_hash(@obj1, methods: [:a,:h], compact: true).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}})
-		DR::Converter.to_hash(@obj1, methods: [:a], compact: true).must_equal({@obj1 => @obj1.a})
+		_(DR::Converter.to_hash(@obj1, methods: [:a,:h], compact: true)).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}})
+		_(DR::Converter.to_hash(@obj1, methods: [:a], compact: true)).must_equal({@obj1 => @obj1.a})
 	end
 
 	it ":check checks that the method exists" do
-		-> {DR::Converter.to_hash(@obj1, methods: [:none], check: false)}.must_raise NoMethodError
-		DR::Converter.to_hash(@obj1, methods: [:none], check: true).must_equal({@obj1 => {}})
+		_(-> {DR::Converter.to_hash(@obj1, methods: [:none], check: false)}).must_raise NoMethodError
+		_(DR::Converter.to_hash(@obj1, methods: [:none], check: true)).must_equal({@obj1 => {}})
 	end
 
 	it "accepts a list" do
-		DR::Converter.to_hash([@obj1,@obj2], methods: [:a,:h]).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}, @obj2 => {a: @obj2.a, h: @obj2.h}})
+		_(DR::Converter.to_hash([@obj1,@obj2], methods: [:a,:h])).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}, @obj2 => {a: @obj2.a, h: @obj2.h}})
 	end
 
 	#this test also test that cycles work
 	it ":recursive generate the hash on the values" do
-		DR::Converter.to_hash(@obj3, methods: [:a,:h], recursive: true).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}, @obj2 => {a: @obj2.a, h: @obj2.h}, @obj3 => {a: @obj3.a, h: @obj3.h}})
+		_(DR::Converter.to_hash(@obj3, methods: [:a,:h], recursive: true)).must_equal({@obj1 => {a: @obj1.a, h: @obj1.h}, @obj2 => {a: @obj2.a, h: @obj2.h}, @obj3 => {a: @obj3.a, h: @obj3.h}})
 	end
 
 end

data/test/test_core_ext.rb

@@ -11,7 +11,7 @@ module TestCoreExt
 	describe DR::CoreExt do
 		describe Enumerable do
 			it "Can classify enumerable" do
-				[1,2,3,4].classify({odd: [1,3], default: :even}).must_equal({:odd=>[1, 3], :even=>[2, 4]})
+				_([1,2,3,4].classify({odd: [1,3], default: :even})).must_equal({:odd=>[1, 3], :even=>[2, 4]})
 			end
 		end
 
@@ -19,48 +19,48 @@ module TestCoreExt
 			it "Implements Hash#deep_merge" do
 				h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
 				h2 = { x: { y: [7,8,9] }, z: 'xyz' }
-				h1.deep_merge(h2).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
-				h2.deep_merge(h1).must_equal({x: {y: [4, 5, 6]}, z: [7, 8, 9]})
-				h1.deep_merge(h2) { |key, old, new| Array(old) + Array(new) }.must_equal({:x=>{:y=>[4, 5, 6, 7, 8, 9]}, :z=>[7, 8, 9, "xyz"]})
+				_(h1.deep_merge(h2)).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
+				_(h2.deep_merge(h1)).must_equal({x: {y: [4, 5, 6]}, z: [7, 8, 9]})
+				_(h1.deep_merge(h2) { |key, old, new| Array(old) + Array(new) }).must_equal({:x=>{:y=>[4, 5, 6, 7, 8, 9]}, :z=>[7, 8, 9, "xyz"]})
 			end
 
 			it "Hash#deep_merge merge array when they start with nil" do
 				h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
 				h2 = { x: { y: [nil, 7,8,9] }, z: 'xyz' }
-				h1.deep_merge(h2).must_equal({x: {y: [4,5,6,7, 8, 9]}, z: "xyz"})
-				{x: { y: []} }.deep_merge(h2).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
-				{z: "foo"}.deep_merge(h2).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
+				_(h1.deep_merge(h2)).must_equal({x: {y: [4,5,6,7, 8, 9]}, z: "xyz"})
+				_({x: { y: []} }.deep_merge(h2)).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
+				_({z: "foo"}.deep_merge(h2)).must_equal({x: {y: [7, 8, 9]}, z: "xyz"})
 			end
 
 			it "Implements Hash#inverse" do
 				h={ploum: 2, plim: 2, plam: 3}
-				h.inverse.must_equal({2=>[:ploum, :plim], 3=>[:plam]})
+				_(h.inverse).must_equal({2=>[:ploum, :plim], 3=>[:plam]})
 			end
 			
 			it "Implements Hash#keyed_value" do
 				h = { x: { y: { z: "foo" } } }
-				h.keyed_value("x/y/z").must_equal("foo")
+				_(h.keyed_value("x/y/z")).must_equal("foo")
 			end
 
 			it "Implements Hash#set_keyed_value" do
 				h = { x: { y: { z: "foo" } } }
-				h.set_keyed_value("x/y/z","bar").must_equal({ x: { y: { z: "bar" } } })
-				h.set_keyed_value("x/y","bar2").must_equal({ x: { y: "bar2" } })
-				h.set_keyed_value("z/y","bar3").must_equal({ x: { y: "bar2" } , z: {y: "bar3"}})
+				_(h.set_keyed_value("x/y/z","bar")).must_equal({ x: { y: { z: "bar" } } })
+				_(h.set_keyed_value("x/y","bar2")).must_equal({ x: { y: "bar2" } })
+				_(h.set_keyed_value("z/y","bar3")).must_equal({ x: { y: "bar2" } , z: {y: "bar3"}})
 			end
 
 			it "Implements Hash#leafs" do
-				{foo: [:bar, :baz], bar: [:plum, :qux]}.leafs([:foo]).must_equal([:plum, :qux, :baz])
+				_({foo: [:bar, :baz], bar: [:plum, :qux]}.leafs([:foo])).must_equal([:plum, :qux, :baz])
 			end
 		end
 
 		describe UnboundMethod do
 			it "Can be converted to a proc" do
 				m=String.instance_method(:length)
-				["foo", "ploum"].map(&m).must_equal([3,5])
+				_(["foo", "ploum"].map(&m)).must_equal([3,5])
 			end
 			it "Can call" do
-				String.instance_method(:length).call("foo").must_equal(3)
+				_(String.instance_method(:length).call("foo")).must_equal(3)
 			end
 		end
 
@@ -73,34 +73,34 @@ module TestCoreExt
 			it "Can do rcurry" do
 				l=->(x,y) {"#{x}: #{y}"}
 				m=l.rcurry("foo")
-				m.call("bar").must_equal("bar: foo")
+				_(m.call("bar")).must_equal("bar: foo")
 			end
 
 			it "Can compose functions" do
 				somme=->(x,y) {x+y}
 				carre=->(x) {x*x}
-				carre.compose(somme).(2,3).must_equal(25)
+				_(carre.compose(somme).(2,3)).must_equal(25)
 			end
 
 			it "Can uncurry functions" do
-				(->(x) {->(y) {x+y}}).uncurry.(2,3).must_equal(5)
-				(->(x,y) {x+y}).curry.uncurry.(2,3).must_equal(5)
+				_((->(x) {->(y) {x+y}}).uncurry.(2,3)).must_equal(5)
+				_((->(x,y) {x+y}).curry.uncurry.(2,3)).must_equal(5)
 			end
 		end
 
 		describe Array do
 			it "Can be converted to proc (providing extra arguments)" do
-				["ploum","plam"].map(&[:+,"foo"]).must_equal(["ploumfoo", "plamfoo"])
+				_(["ploum","plam"].map(&[:+,"foo"])).must_equal(["ploumfoo", "plamfoo"])
 			end
 		end
 
 		describe Object do
 			it "this can change the object" do
-				"foo".this {|s| s.size}.+(1).must_equal(4)
+				_("foo".this {|s| s.size}.+(1)).must_equal(4)
 			end
 
 			it "and_this emulates the Maybe Monad" do
-				"foo".and_this {|s| s.size}.must_equal(3)
+				_("foo".and_this {|s| s.size}).must_equal(3)
 				assert_nil nil.and_this {|s| s.size}
 			end
 		end
@@ -109,7 +109,7 @@ module TestCoreExt
 			it "Generates keys when needed" do
 				h=DR::RecursiveHash.new
 				h[:foo][:bar]=3
-				h.must_equal({foo: {bar: 3}})
+				_(h).must_equal({foo: {bar: 3}})
 			end
 		end
 	end

data/test/test_date_parse.rb

@@ -12,18 +12,18 @@ describe DR::DateRange do
 	end
 
 	it "Can parse dates" do
-		@daterange.d.must_equal [["2014-01-02", "2014-01-03"], ["2014-01-05"], ["2014-02", :now]]
+		_(@daterange.d).must_equal [["2014-01-02", "2014-01-03"], ["2014-01-05"], ["2014-02", :now]]
 	end
 
 	it "Can output a date range" do
-		@daterange.to_s.must_equal "Jan. 2014 – Jan. 2014, Jan. 2014, Feb. 2014 – Present"
+		_(@daterange.to_s).must_equal "Jan. 2014 – Jan. 2014, Jan. 2014, Feb. 2014 – Present"
 	end
 
 	it "Can output a date range with full time information" do
-		@daterange.to_s(output_date_length: :all).must_equal "02 Jan. 2014 – 03 Jan. 2014, 05 Jan. 2014, Feb. 2014 – Present"
+		_(@daterange.to_s(output_date_length: :all)).must_equal "02 Jan. 2014 – 03 Jan. 2014, 05 Jan. 2014, Feb. 2014 – Present"
 	end
 
 	it "Has time information" do
-		@daterange.t[0].to_s.must_equal "[2014-01-02 00:00:00 +0000, 2014-01-03 00:00:00 +0000]".encode('US-ASCII')
+		_(@daterange.t[0].to_s).must_equal "[2014-01-02 00:00:00 +0000, 2014-01-03 00:00:00 +0000]".encode('US-ASCII')
 	end
 end

data/test/test_graph.rb

@@ -8,53 +8,53 @@ describe DR::Graph do
 	end
 
 	it "builds the graph" do
-		@graph.nodes.length.must_equal 3
+		_(@graph.nodes.length).must_equal 3
 	end
 
 	it "accepts :to_a" do
-		@graph.to_a.map(&:name).must_equal(["foo", "bar", "baz"])
+		_(@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]
+		_(@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" => []})
+		_(@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
+		_(@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"])
+		_(@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"])
+		_(@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"])
+		_(@graph.roots.map(&:name)).must_equal(["foo"])
 	end
 
 	it "can give the bottom nodes" do
-		@graph.bottom.map(&:name).must_equal(["baz"])
+		_(@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"])
+		_(@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"])
+		_(@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"=>[]})
+		_(@graph.to_children).must_equal({"foo"=>["bar", "baz"], "bar"=>["baz"], "baz"=>[]})
 	end
 
 	describe "build" do
@@ -64,11 +64,11 @@ describe DR::Graph do
 	end
 
 	it "detects unneeded nodes" do
-		@graph.unneeded("foo","bar").map(&:name).must_equal ["foo","bar"]
-		@graph.unneeded("bar").map(&:name).must_equal []
+		_(@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"]
+		_(@graph.unneeded_descendants("foo").map(&:name)).must_equal ["foo", "bar", "baz"]
 	end
 
 	describe "It works with a cycle" do
@@ -77,7 +77,7 @@ describe DR::Graph do
 		end
 
 		it "It builds the graph" do
-			@graph.nodes.length.must_equal 3
+			_(@graph.nodes.length).must_equal 3
 		end
 	end
 
@@ -97,9 +97,9 @@ describe DR::Graph do
 		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)
+			_(@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
 
@@ -109,18 +109,18 @@ describe DR::Graph do
 		end
 
 		it "Graph2 is well defined" do
-			@graph2.nodes.map(&:name).must_equal(%w(foo bar baz qux))
+			_(@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"=>[]})
+			@graph.merge!(@graph2) #alias @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"=>[]})
+			_(@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

@@ -49,17 +49,17 @@ describe DR::Meta do
 	# end
 
 	it "Can show all ancestors" do
-		DR::Meta.all_ancestors("foo").include?(String.singleton_class).must_equal(true)
+		_(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")
+		_(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)
+		_(DR::Meta.apply(method: String.instance_method(:length), to: "foo")).must_equal(3)
 	end
 end

data/test/test_simple_keywords.rb

@@ -10,27 +10,27 @@ describe DR::SimpleKeywordsParser do
 	end
 
 	it "Can parse keywords" do
-		@parser.parse("FOO(ploum, plam)").must_equal 'FOO: ["ploum", "plam"]'
+		_(@parser.parse("FOO(ploum, plam)")).must_equal 'FOO: ["ploum", "plam"]'
 	end
 
 	it "Can preserver spaces" do
-		@parser.parse("FOO( ploum , plam  )", space: true).must_equal "FOO: [\" ploum \", \" plam  \"]"
+		_(@parser.parse("FOO( ploum , plam  )", space: true)).must_equal "FOO: [\" ploum \", \" plam  \"]"
 	end
 
 	it "Can change delimiters" do
-		@parser.parse("FOO[ ploum , plam  ]", delims: '[]').must_equal "FOO: [\"ploum\", \"plam\"]"
+		_(@parser.parse("FOO[ ploum , plam  ]", delims: '[]')).must_equal "FOO: [\"ploum\", \"plam\"]"
 	end
 
 	it "Can have a one caracter delimiter" do
-		@parser.parse("FOO! ploum , plam  !", delims: '!').must_equal "FOO: [\"ploum\", \"plam\"]"
+		_(@parser.parse("FOO! ploum , plam  !", delims: '!')).must_equal "FOO: [\"ploum\", \"plam\"]"
 	end
 
 	it "Can parse keywords inside keywords" do
-		@parser.parse("FOO(ploum, BAR( foo, bar ))").must_equal "FOO: [\"ploum\", \"BAR: [\\\"foo\\\"\", \"\\\"bar\\\"]\"]"
+		_(@parser.parse("FOO(ploum, BAR( foo, bar ))")).must_equal "FOO: [\"ploum\", \"BAR: [\\\"foo\\\"\", \"\\\"bar\\\"]\"]"
 	end
 
 	it "Can add a keyword" do
 		@parser.keyword("PLOUM") { |a,b| a.to_i+b.to_i}
-		@parser.parse("Hello PLOUM(2,3)").must_equal 'Hello 5'
+		_(@parser.parse("Hello PLOUM(2,3)")).must_equal 'Hello 5'
 	end
 end

data/test/test_simple_parser.rb

@@ -4,34 +4,34 @@ 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"])
+			_(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"])
+			_(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"])
+			_(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"])
+			_(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])
+			_(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])
+			_(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])
+			_(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"})
+			_(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({
+			_(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"},

data/test/test_time_parse.rb

@@ -20,20 +20,20 @@ describe DR::TimeParse do
 	end
 
 	it "Can parse a range" do
-		DR::TimeParse.parse("+100..tomorrow").must_equal(
+		_(DR::TimeParse.parse("+100..tomorrow")).must_equal(
 			Time.parse("2000-01-01 00:01:40")..Time.parse("2000-01-02 12:00:00")
 		)
-		DR::TimeParse.parse("now..in seven days").must_equal(
+		_(DR::TimeParse.parse("now..in seven days")).must_equal(
 			Time.parse("2000-01-01 00:00:00")..Time.parse("2000-01-08 00:00:00")
 		)
 	end
 
 	it "Can parse a date" do
-		DR::TimeParse.parse("today").must_equal(Time.parse("2000-01-01-12:00:00"))
+		_(DR::TimeParse.parse("today")).must_equal(Time.parse("2000-01-01-12:00:00"))
 	end
 
 	it "Can put a date in a range" do
-		DR::TimeParse.parse("today", range: true).must_equal(
+		_(DR::TimeParse.parse("today", range: true)).must_equal(
 			Time.parse("2000-01-01-00:00:00")..Time.parse("2000-01-02-00:00:00")
 		)
 	end

data/test/test_uri.rb

@@ -3,33 +3,33 @@ require 'dr/base/uri'
 
 describe DR::URIWrapper do
 	before do
-		@uri=DR::URIWrapper.new(URI.escape("http://ploum:secret@plam:443/foo bar"))
+		@uri=DR::URIWrapper.new(DR::URIEscape.escape("http://ploum:secret@plam:443/foo bar"))
 	end
 	it "Wraps an uri element" do
-		@uri.scheme.must_equal "http"
+		_(@uri.scheme).must_equal "http"
 	end
 	it "Auto escapes attribute" do
-		@uri.path.must_equal "/foo bar"
+		_(@uri.path).must_equal "/foo bar"
 	end
 	it "Auto escape setting elements" do
 		@uri.user="ploum plam"
-		@uri.user.must_equal "ploum plam"
+		_(@uri.user).must_equal "ploum plam"
 	end
 	it "Can convert to a hash" do
-		@uri.to_h[:user].must_equal("ploum")
+		_(@uri.to_h[:user]).must_equal("ploum")
 	end
 	it "Can convert to json" do
 		require 'json'
-		@uri.to_json.must_equal("{\"uri\":\"http://ploum:secret@plam:443/foo%20bar\",\"scheme\":\"http\",\"userinfo\":\"ploum:secret\",\"host\":\"plam\",\"port\":443,\"path\":\"/foo bar\",\"user\":\"ploum\",\"password\":\"secret\"}")
+		_(@uri.to_json).must_equal("{\"uri\":\"http://ploum:secret@plam:443/foo%20bar\",\"scheme\":\"http\",\"userinfo\":\"ploum:secret\",\"host\":\"plam\",\"port\":443,\"path\":\"/foo bar\",\"user\":\"ploum\",\"password\":\"secret\"}")
 	end
 	it "Can remove password" do
-		@uri.to_public.must_equal("http://ploum@plam:443/foo%20bar")
+		_(@uri.to_public).must_equal("http://ploum@plam:443/foo%20bar")
 	end
 	it "Can be merged" do
-		@uri.soft_merge("foo://plim@").to_s.must_equal("foo://plim:secret@plam:443/foo%20bar")
+		_(@uri.soft_merge("foo://plim@").to_s).must_equal("foo://plim:secret@plam:443/foo%20bar")
 	end
 	it "Can be reverse merged" do
-		DR::URIWrapper.parse("//user@server").reverse_merge(@uri).to_s.must_equal("http://user:secret@server:443/foo%20bar")
+		_(DR::URIWrapper.parse("//user@server").reverse_merge(@uri).to_s).must_equal("http://user:secret@server:443/foo%20bar")
 	end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: drain
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Damien Robert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-18 00:00:00.000000000 Z
+date: 2020-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -28,44 +28,44 @@ dependencies:
   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
+  name: chronic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: chronic_duration
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.10'
 description: 'Drain is a small set of libraries that I use in my other gems.
 
   '
@@ -77,6 +77,7 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - ".yardopts"
@@ -112,6 +113,7 @@ files:
 - lib/dr/tools/gtk.rb
 - lib/dr/version.rb
 - lib/drain.rb
+- lib/drain/version.rb
 - test/helper.rb
 - test/test_converter.rb
 - test/test_core_ext.rb