drain 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a6165b74687b54296ee9b273eac4465746de73b9774eb5466fd550031897cba
-  data.tar.gz: 915728a74d0050b45fec8167e51e2b08c3657defb5fc3187b25b4aca2ff18fb4
+  metadata.gz: 5c577f08df5d0dd378a335824250d97008d3eb24896d101ecc1ed51a2281a1f0
+  data.tar.gz: f35b4fd99afb4870ddb44991b776ef8e5621739d7d83d7ba4d9ae851b2713df1
 SHA512:
-  metadata.gz: f1c013bdb8158298fec2a204063d142a328840e9f3bea214036932ddc59f696aca94549190df72b95b3110dbea295f7a2e240bd69dbb3ed7264911a201517297
-  data.tar.gz: 4cdffbe87293046d6752bd64a0e7e17224b16786d39cb5ff4f4537a5ed3da6722060acf44475774c4bc788f4b09abbb66cf85833e8027cc990fb79fc862f001c
+  metadata.gz: a889f20d3499a98ddc6da50f8cc14201881cf695271b250730ebc26024e657f2af2f7764f5e078979029559dd1dea3745a60a9df9c40ae8d5fc64f7903948a1e
+  data.tar.gz: 1a95a1661230282f9339258e1b6a241bd4fe2e503fbb9f43ea20c220e220a093903356cd8e78fd36e62899189b919a5a4ee50a3261951fdfde1bceebb91cbae1

data/.travis.yml

@@ -1,10 +1,9 @@
 ---
 language: ruby
 rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.6
-  - 2.1.10
-  - ruby-head
-  - ruby-head-clang
+  - 2.5.1
+  - 2.4.4
+  - 2.3.7
+  #- ruby-head
+  #- ruby-head-clang
 script: rake test

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright © 2015–2017 Damien Robert
+Copyright © 2015–2018 Damien Robert
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -23,7 +23,7 @@ The Api is far from stable yet, so use at your own risk!
 
 ## Copyright
 
-Copyright © 2015–2017 Damien Robert
+Copyright © 2015–2018 Damien Robert
 
 MIT License. See [LICENSE.txt](./LICENSE.txt) for details.
 

data/lib/dr/base/bool.rb

@@ -1,15 +1,16 @@
 module DR
   module Bool
     extend(self)
-    def to_bool(el, default=nil)
+    def to_bool(el, default=nil, allow_nil: true, string_fallback: true)
       case el
       when String
         string=el.chomp
         return true if string =~ (/(true|t|yes|y|1)$/i)
         return false if string.empty? || string =~ (/(false|f|no|n|0)$/i)
-      when Fixnum
+        return el if string_fallback
+      when Integer
         return ! (el == 0)
-      when Process::Status
+      when ::Process::Status
         exitstatus=el.exitstatus
         return exitstatus == 0
       else
@@ -18,7 +19,9 @@ module DR
         #we don't return !!el because we don't want nil to be false but to
         #give an error
       end
+      return el if string_fallback and el.is_a?(Symbol)
       return default unless default.nil?
+      return nil if el.nil? and allow_nil
       raise ArgumentError.new("Invalid value for Boolean: \"#{el}\"")
     end
   end

data/lib/dr/base/graph.rb

@@ -83,24 +83,24 @@ module DR
 		def inspect
 			"#{self.class}: #{to_s(show_attr: true)}"+(graph.nil? ? "" : " (#{graph})")
 		end
-		def to_graph(indent_level: 0, show_attr: true)
-			sout = ""
+		# output like a graph
+		def to_graph(indent_level: 0, show_attr: true, out: [])
 			margin = ''
 			0.upto(indent_level/STEP-1) { |p| margin += (p==0 ? ' ' : '|') + ' '*(STEP - 1) }
 			margin += '|' + '-'*(STEP - 2)
-			sout += margin + "#{to_s(show_attr: show_attr)}\n"
+			out << margin + "#{to_s(show_attr: show_attr)}"
 			@children.each do |child|
-				sout += child.to_graph(indent_level: indent_level+STEP, show_attr: show_attr)
+				child.to_graph(indent_level: indent_level+STEP, show_attr: show_attr, out: out)
 			end
-			return sout
+			return out
 		end
-		def to_dot
-			sout=["\""+name+"\""]
+		def to_dot(out: [])
+			out << "\""+name+"\""
 			@children.each do |child|
-				sout.push  "\"#{@name}\" -> \"#{child.name}\""
-				sout += child.to_dot
+				out <<  "\"#{@name}\" -> \"#{child.name}\""
+				child.to_dot(out: out)
 			end
-			return sout
+			return out
 		end
 	end
 
@@ -109,6 +109,7 @@ module DR
 		include Enumerable
 		def initialize(*nodes, attributes: {}, infos: nil)
 			@nodes=[]
+			# a node can be a Hash or a Node
 			build(*nodes, attributes: {}, infos: infos)
 		end
 		def each(&b)
@@ -214,30 +215,32 @@ module DR
 			@nodes.select{ |n| n.children.length == 0}.sort
 		end
 
+		# allow a hash too
 		def |(graph)
+			graph=Graph.new(graph) unless Graph===graph
 			build(*graph.all, recursive: false)
 		end
 		def +(graph)
 			clone.|(graph)
 		end
 
-		def dump(mode: :graph, nodes_list: :roots, show_attr: true, **unused)
+		def dump(mode: :graph, nodes_list: :roots, show_attr: true, out: [], **_opts)
 			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(show_attr: show_attr) end
-			when :list; n.each do |i| sout+="- #{i}\n" end
+			when :graph; n.each do |node| node.to_graph(show_attr: show_attr, out: out) end
+			when :list; n.each do |i| out << "- #{i}" end
 			when :dot;
-				sout+="digraph gems {\n"
-				sout+=n.map {|node| node.to_dot}.inject(:+).uniq!.join("\n")
-				sout+="}\n"
+				out << "digraph gems {"
+				#out << n.map {|node| node.to_dot}.inject(:+).uniq!.join("\n")
+				n.map {|node| node.to_dot(out: out)}
+				out << "}"
 			end
-			return sout
+			return out
 		end
 
 		def to_nodes(*nodes)

data/lib/dr/base/uri.rb

@@ -0,0 +1,201 @@
+require "uri"
+require "delegate"
+
+module URI
+	# From https://github.com/packsaddle/ruby-uri-ssh_git
+	module Ssh
+		extend self
+		# @example
+		#		url = URI::SshGit.parse('git@github.com:packsaddle/ruby-uri-ssh_git.git')
+		#		#=> #<URI::SshGit::Generic git@github.com:packsaddle/ruby-uri-ssh_git.git>
+		#		url.scheme #=> nil
+		#		url.userinfo #=> 'git'
+		#		url.user #=> 'git'
+		#		url.password #=> nil
+		#		url.host #=> 'github.com'
+		#		url.port #=> nil
+		#		url.registry #=> nil
+		#		url.path #=> 'packsaddle/ruby-uri-ssh_git.git'
+		#		url.opaque #=> nil
+		#		url.query #=> nil
+		#		url.fragment #=> nil
+		# @see http://docs.ruby-lang.org/en/2.2.0/URI/Generic.html
+		# @param url [String] git repository url via ssh protocol
+		# @return [Generic] parsed object
+		protected def internal_parse(uri_string)
+			host_part, path_part = uri_string&.split(':', 2)
+			# There may be no user, so reverse the split to make sure host always
+			# is !nil if host_part was !nil.
+			host, userinfo = host_part&.split('@', 2)&.reverse
+			Generic.build(userinfo: userinfo, host: host || uri_string, path: path_part)
+		end
+
+		# @param url [String] git repository-ish url
+		# @return [URI::Generic] if url starts ssh
+		# @return [URI::HTTPS] if url starts https
+		# @return [URI::SshGit] if url is ssh+git e.g git@example.com:schacon/ticgit.git
+		def parse(url, force: false)
+			(ssh_git_url?(url) || force)? URI::Ssh.internal_parse(url) : URI.parse(url)
+		end
+
+		## From: https://github.com/packsaddle/ruby-git_clone_url
+		# @param url [String] git repository-ish url
+		# @return [Boolean] true if url is git via ssh protocol
+		def ssh_git_url?(url)
+			!generic_url?(url)
+		end
+
+		# @param url [String] git repository-ish url
+		# @return [Boolean] true if url is https, ssh protocol
+		def generic_url?(url)
+			match = %r{\A(\w*)://}.match(url)
+			!match.nil?
+		end
+
+		class Generic < ::URI::Generic
+			# check_host returns `false` for 'foo_bar'
+			# but in ssh config this can be a valid host
+			def check_host(v)
+				return true
+			end
+			# @example
+			#		Generic.build(
+			#			userinfo: 'git',
+			#			host: 'github.com',
+			#			path: 'packsaddle/ruby-uri-ssh_git.git'
+			#		).to_ssh
+			#		#=> 'git@github.com:packsaddle/ruby-uri-ssh_git.git'
+			#
+			# @return [String] git repository url via ssh protocol
+			def to_ssh(show_path: true)
+				str = ''
+				str << "#{user}@" if user && !user.empty?
+				str << "#{host}"
+				str << ":#{path}" if path and show_path
+				str
+			end
+		end
+	end
+end
+
+module DR
+	module MailToHelper
+		 # TODO: wrap to= to add user= and host=
+	end
+
+	module URIlikeWrapper
+		def to_h
+			h = { uri: uri }
+			components = uri.component
+			components += %i[user password] if components.include?(:userinfo)
+			components.each do |m|
+				v = uri.public_send(m)
+				v && h[m] = v
+			end
+			h
+		end
+
+		def to_json(_state = nil)
+			to_h.to_json
+		end
+
+		def to_public
+			pub = dup
+			pub.password = nil
+			pub.to_s
+		end
+
+		# uri=u2.merge(uri) does not work if uri is absolute
+		def reverse_merge(u2)
+			# return self unless uri.scheme
+			u2 = u2.clone
+			u2 = self.class.new(u2) unless u2.is_a?(self.class)
+			if opaque.nil? == u2.opaque.nil?
+				u2.soft_merge(self)
+			else
+				self
+			end
+		end
+
+		# merge(u2) replace self by u2 if u2 is aboslute
+		# soft_merge looks at each u2 components
+		def soft_merge(u2)
+			# we want automatic unescaping of u2 components
+			u2 = self.class.new(u2) unless u2.is_a?(self.class)
+			# only merge if we are both opaque or path like
+			if opaque.nil? == u2.opaque.nil?
+				components = uri.component
+				if components.include?(:userinfo)
+					components += %i[user password]
+					components.delete(:userinfo)
+				end
+				components.each do |m|
+					# path returns "" by default but we don't want to merge in this case
+					if u2.respond_to?(m) && (v = u2.public_send(m)) && !((v == "") && (m == :path))
+						uri.public_send(:"#{m}=", v)
+					end
+				end
+			end
+			self
+		end
+	end
+
+	class URIWrapper < SimpleDelegator
+		def uri
+			 __getobj__
+		end
+
+		def uri=(uri)
+			__setobj__(transform_uri(uri))
+		end
+
+		include URIlikeWrapper
+
+		def self.parse(s)
+			new(URI.parse(s))
+		end
+
+		def self.get_uri_object(uri)
+			uri = self.parse(uri.to_s) unless uri.is_a?(URI)
+			uri
+		end
+
+		private def transform_uri(uri)
+			# wrap the components around escape/unescape
+			uri = self.class.get_uri_object(uri)
+			if uri.is_a?(URI)
+				components = uri.component
+				components += %i[user password] if components.include?(:userinfo)
+				components.each do |m|
+					uri.define_singleton_method(m) do
+						r = super()
+						r && r.is_a?(String) ? URI.unescape(r) : r
+					end
+					uri.define_singleton_method(:"#{m}=") do |v|
+						begin
+							super(v && v.is_a?(String) ? URI.escape(v) : v)
+						rescue URI::InvalidURIError => e
+							warn "#{e} in (#{self}).#{m}=#{v}"
+							 # require 'pry'; binding.pry
+						end
+					end
+					uri.extend(MailToHelper) if uri.is_a?(URI::MailTo)
+				end
+			end
+			uri
+		end
+
+		# recall that '//user@server' is an uri while 'user@server' is just a path
+		def initialize(uri)
+			super
+			self.uri = uri
+		end
+
+		class Ssh < URIWrapper
+			def self.parse(s)
+				new(URI::Ssh.parse(s))
+			end
+		end
+	end
+
+end

data/lib/dr/base/utils.rb

@@ -5,10 +5,10 @@ module DR
 			case format.to_s
 			when "json"
 				require 'json'
-				return pretty_print(string.to_json)
+				return pretty_print(string.to_json, pretty: pretty)
 			when "yaml"
 				require "yaml"
-				return pretty_print(string.to_yaml)
+				return pretty_print(string.to_yaml, pretty: pretty)
 			end
 			if pretty.to_s=="color"
 				begin
@@ -24,5 +24,29 @@ module DR
 				puts string
 			end
 		end
+
+		# stolen from active support
+		def to_camel_case(s)
+			s.sub(/^[a-z\d]*/) { |match| match.capitalize }.
+				gsub(/(?:_|(\/))([a-z\d]*)/i) {"#{$1}#{$2.capitalize}"}.
+				gsub("/", "::")
+		end
+		def to_snake_case(s)
+			# convert from caml case to snake_case
+			s.gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
+				gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+		end
+
+		def rsplit(s, sep, num=nil)
+			if num.nil? or num==0
+				s.split(sep)
+			else
+				components=s.split(sep)
+				components+=[nil]*[(num-components.length), 0].max
+				a=components[0..(components.length-num)]
+				b=components[(components.length-num+1)..(components.length-1)]
+				return [a.join(sep), *b]
+			end
+		end
 	end
 end

data/lib/dr/formatter/simple_formatter.rb

@@ -0,0 +1,154 @@
+module DR
+	class Formatter
+		module Helpers
+			def localize(msg, lang: :en, **_opts)
+				case msg
+				when Hash
+					Array(lang).each do |l|
+						if msg.key?(l)
+							yield(msg[l]) if block_given?
+							return msg[l]
+						end
+					end
+				else
+					msg
+				end
+			end
+
+			def wrap(content, pre:nil, post:nil)
+				return content if content.nil? or content.empty?
+				pre.to_s+content.to_s+post.to_s
+			end
+
+			def join(*args, pre: "", post: "", pre_item: "", post_item: "", join: :auto, **_opts)
+				args=Array(args)
+				list=args.compact.map {|i| wrap(i, pre: pre_item, post: post_item)}.delete_if {|i| i.empty?}
+				r=list.shift
+				list.each do |s|
+					if join==:auto
+						if r[-1]=="\n" or s[1]=="\n"
+							r+=s
+						else
+							r+=" "+s
+						end
+					else
+						r+=join+s
+					end
+				end
+				r=pre+r+post unless r.nil? or r.empty?
+				r
+			end
+		end
+		extend Helpers
+
+		attr_accessor :opts, :meta
+		def initialize(meta={}, **opts)
+			@meta=meta
+			@opts=opts
+		end
+
+		def localize(msg, **opts)
+			self.class.localize(msg, **@opts.merge(opts))
+		end
+
+		def join(*args, **opts)
+			opts=@opts.merge(opts)
+			args=Array(args).map {|i| try_expand_symbol(i,**opts)}
+			self.class.localize(*args, **opts)
+		end
+
+		private def metainfo_from_symbol(sym, meta: @meta, **opts)
+			return sym if opts[:meta_symbol]==:never
+			content=case meta
+			when Hash
+				warn "#{sym} not found in #{meta}" unless meta.key?(sym)
+				meta[sym]
+			when Proc
+				meta.call(sym, **opts)
+			else
+				sym
+			end
+			if block_given?
+				yield content, **opts
+			else
+				content
+			end
+		end
+
+		private def get_symbol(sym)
+			case sym
+			when Symbol
+				return sym
+			when String
+				return sym[1...sym.length].to_sym if sym[0] == ':'
+			end
+			nil
+		end
+		private def try_get_symbol(sym,**opts)
+			if (key=get_symbol(sym))
+				expand_symbol(key,**opts)
+			else
+				sym
+			end
+		end
+
+		def expand(msg, **opts)
+			recursive=opts[:recursive]
+			#if recursive is :first, then we only expand once ore
+			if recursive.is_a?(Integer)
+				opts[:recursive]=recursive-1
+				recursive=false if recursive <= 0
+			end
+			case msg
+			when Hash
+				Array(opts[:merge]).each do |key|
+					if msg.key?(key)
+						msg=msg.merge(msg[key])
+						msg.delete(key)
+					end
+				end
+				# we localize after merging potential out types
+				localize(msg, **opts) do |lmsg|
+					# localization do not count as a recursive step
+					return expand(lmsg, **opts)
+				end
+				if recursive
+					msg_exp={}
+					msg.each do |k,v|
+						msg_exp[k]=expand(v,**opts)
+					end
+					#expand may have introduced nil values
+					clean_nil=opts.fetch(:clean_nil,true)
+					msg_exp.delete_if {|_k,v| v==nil} if clean_nil
+					msg_exp
+				else
+					msg
+				end
+			when Symbol
+				opts[:symbol]||=:never
+				msg=metainfo_from_symbol(msg,**opts)
+				recursive ? expand(msg, **opts) : msg
+			when Array
+				msg=msg.map {|i| expand(i,**opts)} if recursive
+				opts[:join] ? join(msg, **opts) : msg
+			when String
+				(nmsg=try_get_symbol(msg,**opts)) and return nmsg
+				if block_given?
+					yield(msg, **opts)
+				else
+					msg
+				end
+			when nil
+				nil
+			else
+				if block_given?
+					yield(msg, **opts)
+				else
+					#expand(msg.to_s,**opts)
+					msg
+				end
+			end
+		end
+
+	end
+end

data/lib/dr/parse/date_parse.rb

@@ -0,0 +1,157 @@
+require 'dr/formatter/simple_formatter'
+
+module DR
+	module DateRangeParser
+		extend self
+		#in: 2014-01-02 -> 2014-01-03, 2014-01-05, 2014-02 -> :now
+		#out: [[2014-01-02,2014-01-03],[2014-01-05],[2014-02,:now]]
+		def parse(date)
+			return date if date.kind_of?(self)
+			r=[]
+			dates = date.to_s.chomp.split(/,\s*/)
+			dates.each do |d|
+				r << d.split(/\s*->\s*/).map {|i| i == ":now" ? :now : i }
+			end
+			return DateRange.new(r)
+		end
+	end
+
+	module DateOutput
+		extend self
+		#BUG: années bissextiles...
+		Months_end={1 => 31, 2 => 28, 3 => 31, 4 => 30,
+			5 => 31, 6 => 30, 7 => 31, 8 => 31,
+			9 => 30, 10 => 31, 11 => 30, 12 => 31}
+
+		# Convert a Date/string into a Time
+		def to_time(datetime, complete_date: :first, **opts)
+			require 'time'
+			return Time.now if datetime == :now
+			begin
+				fallback=Time.new(0) #supply the missing components
+				return Time.parse(datetime,fallback)
+			rescue ArgumentError
+				year,month,day,time=split_date(datetime)
+				case complete_date
+				when :first
+					month="01" if month == nil
+					day="01" if day == nil
+					time="00:00:00" if day == nil
+				when :last
+					month="12" if month == nil
+					day=Months_end[month.to_i].to_s if day == nil
+					time="23:59:59" if day == nil
+				end
+				return Time.parse("#{year}-#{month}-#{day}T#{time}",fallback)
+			end
+		end
+
+		#ex: split 2014-07-28T19:26:20+0200 into year,month,day,time
+		def split_date(datetime)
+			datetime=Time.now.iso8601 if datetime == :now
+			date,time=datetime.to_s.split("T")
+			year,month,day=date.split("-")
+			return year,month,day,time
+		end
+
+		Months_names={en: {
+			1 => 'January', 2 => 'February', 3 => 'March',
+			4 => 'April', 5 => 'May', 6 => 'June',
+			7 => 'July', 8 => 'August', 9 => 'September',
+			10 => 'October', 11 => 'November', 12 => 'December'},
+			fr: {
+			1 => 'Janvier', 2 => 'Février', 3 => 'Mars',
+			4 => 'Avril', 5 => 'Mai', 6 => 'Juin',
+			7 => 'Juillet', 8 => 'Août', 9 => 'Septembre',
+			10 => 'Octobre', 11 => 'Novembre', 12 => 'Décembre'}}
+
+		private def abbr_month(month, lang: :en, **_opts)
+			return month if month.length <= 4
+			return month[0..2]+(lang==:en ? '.' : '')
+		end
+
+		# output_date_length: granularity :year/:month/:day/:all
+		# output_date: :num, :string, :abbr
+		def output_date(datetime, output_date: :abbr, output_date_length: :month,
+			**opts)
+			lang=opts[:lang]||:en
+			year,month,day,time=split_date(datetime)
+			month=nil if output_date_length==:year
+			day=nil if output_date_length==:month
+			time=nil if output_date_length==:day
+			return Formatter.localize({en: 'Present', fr: 'Présent'},**opts) if datetime==:now
+			r=year
+			case output_date
+			when :num
+				month.nil? ? (return r) : r+="-"+month
+				day.nil? ? (return r) : r+="-"+day
+				time.nil? ? (return r) : r+="T"+time
+			when :abbr,:string
+				return r if month.nil?
+				month_name=Months_names[lang][month.to_i]
+				month_name=abbr_month(month_name) if output_date==:abbr
+				r=month_name+" "+r
+				return r if day.nil?
+				r=day+" "+r
+				return r if time.nil?
+				r+=" "+time
+			end
+			r
+		end
+	end
+
+	class DateRange
+		extend DateRangeParser
+		extend DateOutput
+
+		attr_accessor :d, :t
+		def initialize(d)
+			@d=d
+			@t=d.map do |range|
+				case range.length
+				when 1
+					[DateRange.to_time(range[0], complete_date: :first),
+					DateRange.to_time(range[0], complete_date: :last)]
+				when 2
+					[DateRange.to_time(range[0], complete_date: :first),
+					DateRange.to_time(range[1], complete_date: :last)]
+				else
+					range.map {|i| DateRange.to_time(i)}
+				end
+			end
+		end
+
+		#sort_date_by :first or :last
+		def <=>(d2, sort_date_by: :last,**_opts)
+			d1=@t; d2=d2.t
+			sel=lambda do |d|
+				case sort_date_by
+				when :last
+					return d.map {|i| i.last}
+				when :first
+					return d.map {|i| i.first}
+				end
+			end
+			best=lambda do |d|
+				case sort_date_by
+				when :last
+					return d.max
+				when :first
+					return d.min
+				end
+			end
+			b1=best.call(sel.call(d1))
+			b2=best.call(sel.call(d2))
+			return b1 <=> b2
+		end
+
+		def to_s(join: ", ", range_join: " – ", **opts)
+			r=@d.map do |range|
+				range.map do |d|
+					DateRange.output_date(d,**opts)
+				end.join(range_join)
+			end.join(join)
+			r.empty? ? nil : r
+		end
+	end
+end

data/lib/dr/parse/simple_keywords.rb

@@ -0,0 +1,56 @@
+module DR
+	class SimpleKeywordsParser
+		attr_accessor :opts, :keywords
+
+		def initialize(hash, **opts)
+			@opts=opts
+			@keywords=hash
+		end
+
+		def keyword(name, &b)
+			@keywords[name]=b
+		end
+
+		def parse(msg, **opts)
+			opts=@opts.merge(opts)
+			sep=opts[:sep] || ','
+			# Warning: the delims must take only one char
+			delims= opts[:delims] || '()'
+			bdelim= delims[0]
+			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})}
+			if (m=reg.match(msg))
+				arg=m[:re][1...m[:re].length-1]
+				arg=parse(arg, **opts)
+				args=arg.split(sep)
+				args=args.map {|a| a.strip} unless opts[:space]
+				key=keywords.find {|k| /#{k}/ =~ m[:kw]}
+				r=@keywords[key].call(*args).to_s
+				msg=m.pre_match+r+parse(m.post_match,**opts)
+				msg=keywords(msg,@keywords,**opts) if opts[:recursive]
+			end
+			return msg
+		end
+		# re = %r{
+		#   (?<re>
+		#     \(
+		#       (?:
+		#         (?> [^()]+ )
+		#         |
+		#         \g<re>
+		#       )*
+		#     \)
+		#   )
+		# }x
+		#(?<re> name regexp/match
+		#\g<re> reuse regexp
+		#\k<re> reuse match
+		#(?: grouping without capturing
+		#(?> atomic grouping
+		#x whitespace does not count
+		# -> match balanced groups of parentheses
+
+	end
+end

data/lib/dr/parse/simple_parser.rb

@@ -24,6 +24,24 @@ module DR
 			return name,value
 		end
 
+		# parse opt1=value1:opt2=value2...
+		def parse_options(options, arg_split:':', valuesep: '=', opt_default: true, keyed_sep: "/")
+			return {} unless options
+			parsed_options={}
+			options=options.split(arg_split) unless options.is_a?(Enumerable)
+			options.each do |optvalue|
+				opt,value=DR::SimpleParser.parse_namevalue(optvalue,sep: valuesep, default: opt_default)
+				parsed_options.set_keyed_value(opt,value, sep: keyed_sep)
+			end
+			return parsed_options
+		end
+
+		# parse name:opt1=value1:opt2=value2...
+		def parse_name_options(name, arg_split:':', **keywords)
+			name,*options=name.split(arg_split)
+			return name, parse_options(options, arg_split: arg_split, **keywords)
+		end
+
 		#takes a string as "name:value!option1=ploum!option2=plam,name2:value2!!globalopt=plim,globalopt2=plam!!globalopt3=plom,globalopt4=plim"
 		#and return the hash
 		#{values: {name: value, name2: value2},

data/lib/dr/parse/time_parse.rb

@@ -30,7 +30,7 @@ module DR
 					t=-t if s[0]=='-'
 				end
 				case t
-					when Time
+				when Time
 				else
 					t=Time.now+t
 				end

data/lib/dr/ruby_ext/core_modules.rb

@@ -30,12 +30,12 @@ module DR
 			#		#=> {:x=>{:y=>[4, 5, 6, 7, 8, 9]}, :z=>[7, 8, 9, "xyz"]}
 			#
 			#		Adapted from active support
-			def deep_merge(other_hash, &block)
-				dup.deep_merge!(other_hash, &block)
+			def deep_merge(other_hash, **opts, &block)
+				dup.deep_merge!(other_hash, **opts, &block)
 			end
 
 			# Same as +deep_merge+, but modifies +self+.
-			def deep_merge!(other_hash, &block)
+			def deep_merge!(other_hash, append: :auto, &block)
 				return unless other_hash
 				other_hash.each_pair do |k,v|
 					tv = self[k]
@@ -43,17 +43,19 @@ module DR
 					when tv.is_a?(Hash) && v.is_a?(Hash)
 						self[k] = tv.deep_merge(v, &block)
 					when tv.is_a?(Array) && v.is_a?(Array)
-						if v.length > 0 && v.first.nil? then
+						if append==:auto and v.length > 0 && v.first.nil? then
 							#hack: if the array begins with nil, we append the new
 							#value rather than overwrite it
 							v.shift
 							self[k] += v
+						elsif append && append != :auto
+							self[k] += v
 						else
 							self[k] = block && tv ? block.call(k, tv, v) : v
 						end
 					when tv.nil? && v.is_a?(Array)
 						#here we still need to remove nil (see above)
-						if v.length > 0 && v.first.nil? then
+						if append==:auto and v.length > 0 && v.first.nil? then
 							v.shift
 							self[k]=v
 						else
@@ -66,6 +68,13 @@ module DR
 				self
 			end
 
+			def reverse_merge(other_hash)
+				other_hash.merge(self)
+			end
+			def reverse_deep_merge(other_hash)
+				other_hash.deep_merge(self)
+			end
+
 			#from a hash {key: [values]} produce a hash {value: [keys]}
 			#there is already Hash#invert using Hash#key which does that, but the difference here is that we flatten Enumerable values
 			#h={ploum: 2, plim: 2, plam: 3}
@@ -137,6 +146,78 @@ module DR
 				end until s==r
 				r
 			end
+
+			# Adapted from File activesupport/lib/active_support/core_ext/hash/slice.rb, line 22
+			# Note that ruby has Hash#slice, but if the key does not exist, we
+			# cannot configure a default
+			def slice_with_default(*keys, default: nil)
+				keys.each_with_object(::Hash.new) do |k, hash| 
+					if has_key?(k) || default == :default_proc
+						hash[k] = self[k] 
+					else
+						hash[k] = default
+					end
+				end
+			end
+
+			def dig_with_default(*args, default: nil)
+				r=dig(*args)
+				return default if r.nil?
+				r
+			end
+
+			def has_keys?(*keys, key)
+				i=self
+				keys.each do |k|
+					i.key?(k) or return false
+					i=i[k]
+				end
+				i.key?(key)
+			end
+
+			def set_key(*keys, key, value)
+				i=self
+				keys.each do |k|
+					i.key?(k) or i[k]={}
+					i=i[k]
+				end
+				i[key]=value
+				# self
+			end
+			# like set_key, but only set the value if it does not exist
+			def add_key(*keys, key, value)
+				i=self
+				keys.each do |k|
+					i.key?(k) or i[k]={}
+					i=i[k]
+				end
+				i.key?(key) or i[key]=value
+				# self
+				i[key]
+			end
+			#like add_key, but consider the value is an Array and add to it
+			def add_to_key(*keys, key, value, overwrite: false, uniq: true, deep: false)
+				i=self
+				keys.each do |k|
+					i.key?(k) or i[k]={}
+					i=i[k]
+				end
+				if value.is_a?(Hash)
+					v=i[key] || {}
+					if deep
+						overwrite ? v.deep_merge!(value) : v=value.deep_merge(v)
+					else
+						overwrite ? v.merge!(value) : v=value.merge(v)
+					end
+				else
+					v=i[key] || []
+					v += Array(value)
+					v.uniq! if uniq
+				end
+				i[key]=v
+				# self
+			end
+
 		end
 
 		module UnboundMethod

data/lib/dr/version.rb

@@ -1,4 +1,4 @@
 module DR
   # drain version
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/helper.rb

@@ -4,8 +4,8 @@ require 'minitest/autorun'
 #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_date_parse.rb

@@ -0,0 +1,25 @@
+require 'helper'
+require 'dr/parse/date_parse'
+
+describe DR::DateRange do
+	before do
+		ENV['TZ']='GMT'
+		@daterange=DR::DateRange.parse("2014-01-02 -> 2014-01-03, 2014-01-05, 2014-02 -> :now")
+	end
+
+	it "Can parse dates" do
+		@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"
+	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"
+	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')
+	end
+end

data/test/test_simple_keywords.rb

@@ -0,0 +1,36 @@
+require 'helper'
+require 'dr/parse/simple_keywords'
+
+describe DR::SimpleKeywordsParser do
+	before do
+		@parser=DR::SimpleKeywordsParser.new({
+			'FOO' => lambda { |*args|  "FOO: #{args}" },
+			'BAR' => lambda { |*args|  "BAR: #{args}" },
+		})
+	end
+
+	it "Can parse keywords" do
+		@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  \"]"
+	end
+
+	it "Can change delimiters" do
+		@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\"]"
+	end
+
+	it "Can parse keywords inside keywords" do
+		@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'
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: drain
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Damien Robert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-01 00:00:00.000000000 Z
+date: 2018-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -95,8 +95,12 @@ files:
 - lib/dr/base/eruby.rb
 - lib/dr/base/functional.rb
 - lib/dr/base/graph.rb
+- lib/dr/base/uri.rb
 - lib/dr/base/utils.rb
+- lib/dr/formatter/simple_formatter.rb
 - lib/dr/parse.rb
+- lib/dr/parse/date_parse.rb
+- lib/dr/parse/simple_keywords.rb
 - lib/dr/parse/simple_parser.rb
 - lib/dr/parse/time_parse.rb
 - lib/dr/ruby_ext.rb
@@ -110,9 +114,11 @@ files:
 - test/helper.rb
 - test/test_converter.rb
 - test/test_core_ext.rb
+- test/test_date_parse.rb
 - test/test_drain.rb
 - test/test_graph.rb
 - test/test_meta.rb
+- test/test_simple_keywords.rb
 - test/test_simple_parser.rb
 homepage: https://github.com/DamienRobert/drain#readme
 licenses:
@@ -135,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Use a drain for a dryer ruby!