drain 0.3.0 → 0.7.0

data/lib/dr/parse/simple_keywords.rb

@@ -20,7 +20,7 @@ module DR
 			edelim= delims[1] || bdelim
 			keywords=@keywords.keys
 			keywords_r="(?:"+keywords.map {|k| "(?:"+k+")"}.join("|")+")"
-			reg = %r{(?<kw>#{keywords_r})(?<re>#{'\\'+bdelim}(?:(?>[^#{'\\'+bdelim}#{'\\'+edelim}]+)|\g<re>)*#{'\\'+edelim})}
+			reg = %r{(?<kw>#{keywords_r})(?<re>#{'\\'+bdelim}(?:(?>[^#{'\\'+bdelim}#{edelim == bdelim ? '' : '\\'+edelim}]+)|\g<re>)*#{'\\'+edelim})}
 			if (m=reg.match(msg))
 				arg=m[:re][1...m[:re].length-1]
 				arg=parse(arg, **opts)

data/lib/dr/parse/time_parse.rb

@@ -1,6 +1,6 @@
 require 'chronic'
 require 'chronic_duration'
-require 'active_support/time'
+# require 'active_support/time'
 
 module DR
 	module TimeParse
@@ -8,17 +8,17 @@ module DR
 		def time_to_day_range(t)
 			return Chronic.parse(t.to_date, guess:false)
 		end
-		def parse(s, opt={})
+		def parse(s, **opt)
 			return s if Date===s or Time===s
 
-			if !opt[:norange] && s=~/(.*)\.\.(.*)/
-				first=$1
-				second=$2
+			!opt[:norange] and s.match(/(.*)\.\.(.*)/) do |m|
+				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 not s.present?
+			if s.match(/\A[[:space:]]*\z/) # blank
 				t=Time.now
 			elsif s[0] =~ /[+-]/
 				#if s=+3.years-1.minutes
@@ -53,19 +53,25 @@ module DR
 
 	end
 end
-#Examples:
-#DR::TimeParse.parse("+100..tomorrow")
-#first: +100, second: tomorrow
-#=> 2014-08-22 11:20:31 +0200..2014-08-23 12:00:00 +0200
-#[74] pry(main)> DR::TimeParse.parse("now..in seven days")
-#first: now, second: in seven days
-#=> 2014-08-22 11:20:25 +0200..2014-08-29 11:20:25 +0200
-#[75] pry(main)> DR::TimeParse.parse("today")
-#=> 2014-08-22 17:30:00 +0200
-#[76] pry(main)> DR::TimeParse.parse("today",range: true)
-#=> 2014-08-22 11:00:00 +0200..2014-08-23 00:00:00 +0200
-#[181] pry(main)> DR::TimeParse.parse("-3 years 2 minutes")
-#-94672920
-#=> 2011-08-22 20:01:34 +0200
-#[182] pry(main)> DR::TimeParse.parse("+3.years+2.days")
-#=> 2017-08-24 14:04:08 +0200
+
+=begin Examples:
+
+DR::TimeParse.parse("+100..tomorrow") #first: +100, second: tomorrow
+=> 2014-08-22 11:20:31 +0200..2014-08-23 12:00:00 +0200
+
+DR::TimeParse.parse("now..in seven days") #first: now, second: in seven days
+=> 2014-08-22 11:20:25 +0200..2014-08-29 11:20:25 +0200
+
+DR::TimeParse.parse("today")
+=> 2014-08-22 17:30:00 +0200
+
+DR::TimeParse.parse("today",range: true)
+=> 2014-08-22 11:00:00 +0200..2014-08-23 00:00:00 +0200
+
+DR::TimeParse.parse("-3 years 2 minutes") #-94672920
+=> 2011-08-22 20:01:34 +0200
+
+require 'active_support/time'
+DR::TimeParse.parse("+3.years+2.days")
+=> 2017-08-24 14:04:08 +0200
+=end

data/lib/dr/ruby_ext/core_modules.rb

@@ -2,9 +2,9 @@ module DR
 	module CoreExt
 		#[Hash, Array].each {|m| m.include(Enumerable)} #to reinclude
 		module Enumerable
-			#Ex: [1,2,3,4].filter({odd: [1,3], default: :even})
+			#Ex: [1,2,3,4].classify({odd: [1,3], default: :even})
 			#=> {:odd=>[1, 3], :even=>[2, 4]}
-			def filter(h)
+			def classify(h)
 				invh=h.inverse
 				default=h[:default]
 				r={}
@@ -36,7 +36,7 @@ module DR
 
 			# Same as +deep_merge+, but modifies +self+.
 			def deep_merge!(other_hash, append: :auto, &block)
-				return unless other_hash
+				return self unless other_hash
 				other_hash.each_pair do |k,v|
 					tv = self[k]
 					case
@@ -301,6 +301,8 @@ module DR
 	end
 
 	module CoreRef
+		# warning, this only works for methods that don't need to call other
+		# refined methods
 		CoreExt.constants.select {|c| const_get("::#{c}").is_a?(Class)}.each do |c|
 			refine const_get("::#{c}") do
 				include CoreExt.const_get(c)

data/lib/dr/version.rb

@@ -1,4 +1,4 @@
 module DR
   # drain version
-  VERSION = "0.3.0"
+  VERSION = "0.7.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

@@ -10,8 +10,8 @@ module TestCoreExt
 	require 'dr/ruby_ext/core_ext'
 	describe DR::CoreExt do
 		describe Enumerable do
-			it "Can filter enumerable" do
-				[1,2,3,4].filter({odd: [1,3], default: :even}).must_equal({:odd=>[1, 3], :even=>[2, 4]})
+			it "Can classify enumerable" do
+				_([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

@@ -3,23 +3,27 @@ require 'dr/parse/date_parse'
 
 describe DR::DateRange do
 	before do
+		@tz=ENV['TZ']
 		ENV['TZ']='GMT'
 		@daterange=DR::DateRange.parse("2014-01-02 -> 2014-01-03, 2014-01-05, 2014-02 -> :now")
 	end
+	after do
+		ENV['TZ']=@tz
+	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