drain 0.1.0

data/lib/drain/parse.rb

@@ -0,0 +1,5 @@
+#for the filename ploum.rb, load all ploum/*.rb files
+dir=File.expand_path(File.basename(__FILE__).chomp('.rb'), File.dirname(__FILE__))
+Dir.glob(File.expand_path('*.rb',dir)) do |file|
+	require file
+end

data/lib/drain/parse/simple_parser.rb

@@ -0,0 +1,61 @@
+module DR
+	#utilities to parse some strings into name values
+	module SimpleParser
+		extend self
+
+		#takes a string 'name:value' and return name and value
+		#can specify a default value; if the default is true we match
+		#no-name as name:false
+		def parse_namevalue(nameval, sep: ':', default: nil)
+			name,*val=nameval.split(sep)
+			if val.empty?
+				if default == true
+					#special case where if name begins by no- we return false
+					if name =~ /^no-(.*)$/
+						return $1, false
+					else
+						return name, true
+					end
+				else
+					return name, default
+				end
+			else
+				value=val.join(sep)
+				return name,value
+			end
+		end
+
+		#takes a string as "name:value!option1=ploum!option2=plam,name2:value2!!globalopt=plim,globalopt2=plam"
+		#and return the hash
+		#{values: {name: value, name2: value2},
+		# localopt: {name: {option1:ploum,option2:plam}},
+		# globalopt: {globalopt: plim, globalopt2: plam},
+		# opt: {name: {option1:ploum,option2:plam,globalopt: plim, globalopt2: plam}, name2:{{globalopt: plim, globalopt2: plam}}}
+		def parse_string(s)
+			r={values: {}, local_opts: {}, global_opts: {}, opts: {}}
+			args,*globopts=s.split('!!')
+			globopts.map {|g| g.split(',')}.flatten.each do |g|
+				name,value=parse_namevalue(g, sep: '=', default: true)
+				r[:global_opts][name]=value
+			end
+			args.split(',').each do |arg|
+				arg,*localopts=arg.split('!')
+				name,value=parse_namevalue(arg)
+				r[:values][name]=value
+				r[:local_opts][name]={}
+				localopts.each do |o|
+					oname,ovalue=parse_namevalue(o, sep: '=', default: true)
+					r[:local_opts][name][oname]=ovalue
+				end
+				r[:local_opts].each do |name,hash|
+					r[:opts][name]=r[:local_opts][name].dup
+					r[:global_opts].each do |k,v|
+						r[:opts][name][k]||=v
+					end
+				end
+			end
+			return r
+		end
+
+	end
+end

data/lib/drain/parse/time_parse.rb

@@ -0,0 +1,71 @@
+require 'chronic'
+require 'chronic_duration'
+require 'active_support/time'
+
+module DR
+	module TimeParse
+		extend self
+		def time_to_day_range(t)
+			return Chronic.parse(t.to_date, guess:false)
+		end
+		def parse(s, opt={})
+			return s if Date===s or Time===s
+
+			if !opt[:norange] && s=~/(.*)\.\.(.*)/
+				first=$1
+				second=$2
+				opt[:norange]=true
+				return Chronic::Span.new(self.parse(first, opt),self.parse(second,opt))
+			end
+
+			if not s.present?
+				t=Time.now
+			elsif s[0] =~ /[+-]/
+				#if s=+3.years-1.minutes
+				begin
+					t=eval(s)
+				rescue SyntaxError
+				#if s=3 years
+					t=ChronicDuration.parse(s[1...s.length])
+					t=-t if s[0]=='-'
+				end
+				case t
+					when Time
+				else
+					t=Time.now+t
+				end
+				return t
+			else
+
+				chronicopts=[:context,:now,:guess,:ambiguous_time_range,:endian_precedence,:ambiguous_year_future_bias]
+				chronicopt={hours24: true, ambiguous_time_range: 0, endian_precedence: [:little,:middle]}
+				chronicopt[:guess]=false if opt[:range]
+				chronicopt.update(opt.reject {|k,v| not chronicopts.include?(k)})
+				#puts chronicopt
+				t=Chronic.parse(s, chronicopt)
+				t=Time.parse(s) if not t
+			end
+			if opt[:range] && !opt[:norange] then
+				return time_to_day_range(t) unless Range === t
+			end
+			return t
+		end
+
+	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

data/lib/drain/ruby_ext.rb

@@ -0,0 +1,5 @@
+#for the filename ploum.rb, load all ploum/*.rb files
+dir=File.expand_path(File.basename(__FILE__).chomp('.rb'), File.dirname(__FILE__))
+Dir.glob(File.expand_path('*.rb',dir)) do |file|
+	require file
+end

data/lib/drain/ruby_ext/core_ext.rb

@@ -0,0 +1,203 @@
+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})
+			#=> {:odd=>[1, 3], :even=>[2, 4]}
+			def filter(h)
+				invh=h.inverse
+				default=h[:default]
+				r={}
+				each do |el|
+					keys=invh.fetch(value,[default])
+					keys.each do |key|
+						(r[key]||=[]) << el
+					end
+				end
+				return r
+			end
+		end
+
+		module Hash
+			# Returns a new hash with +self+ and +other_hash+ merged recursively.
+			#
+			#		h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
+			#		h2 = { x: { y: [7,8,9] }, z: 'xyz' }
+			#
+			#		h1.deep_merge(h2) #=> {x: {y: [7, 8, 9]}, z: "xyz"}
+			#		h2.deep_merge(h1) #=> {x: {y: [4, 5, 6]}, z: [7, 8, 9]}
+			#		h1.deep_merge(h2) { |key, old, new| Array.wrap(old) + Array.wrap(new) }
+			#		#=> {: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)
+			end
+
+			# Same as +deep_merge+, but modifies +self+.
+			def deep_merge!(other_hash, &block)
+				return unless other_hash
+				other_hash.each_pair do |k,v|
+					tv = self[k]
+					case
+					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
+							#hack: if the array begins with nil, we append the new
+							#value rather than overwrite it
+							v.shift
+							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
+							v.shift
+							self[k]=v
+						else
+							self[k] = block && tv ? block.call(k, tv, v) : v
+						end
+					else
+						self[k] = block && tv ? block.call(k, tv, v) : v
+					end
+				end
+				self
+			end
+
+			#from a hash {key: [values]} produce a hash {value: [keys]}
+			#there is already Hash#key which does that, but the difference here is
+			#that we flatten Enumerable values
+			def inverse
+				r={}
+				each_key do |k|
+					values=fetch(k)
+					values=[values] unless values.respond_to?(:each)
+					values.each do |v|
+						r[v]||=[]
+						r[v]<< k
+					end
+				end
+				return r
+			end
+
+			#sort the keys and the values of the hash
+			def sort_all
+				r=::Hash[self.sort]
+				r.each do |k,v|
+					r[k]=v.sort
+				end
+				return r
+			end
+
+			#take a key of the form ploum/plam/plim
+			#and return self[:ploum][:plam][:plim]
+			def keyed_value(key, sep: "/")
+				r=self.dup
+				return r if key.empty?
+				key.split(sep).each do |k|
+					k=k.to_sym if r.key?(k.to_sym) && !r.key?(k)
+					r=r[k]
+				end
+				return r
+			end
+		end
+
+		module Proc
+			# Safely call our block, even if the user passed in something of a
+			# different arity (lambda case)
+			def call_block(*args,**opts)
+				if block.arity >= 0
+					case block.arity
+					when 0
+						block.call(**opts)
+					else
+						block.call(args[0...block.arity],**opts)
+					end
+				else
+					block.call(*args,**opts)
+				end
+			end
+		end
+
+		module UnboundMethod
+			#this should be in the stdlib...
+			def to_proc
+				return lambda do |obj,*args,&b|
+					self.bind(obj).call(*args,&b)
+				end
+			end
+			def call(*args,&b)
+				self.to_proc.call(*args,&b)
+			end
+		end
+
+		module Proc
+			#similar to curry, but pass the provided arguments on the right
+			#(a difference to Proc#curry is that we pass the argument directly, not
+			#via .call)
+			def rcurry(*args,&b)
+				return Proc.new do |*a,&b|
+					self.call(*a,*args,&b)
+				end
+			end
+
+			#return self o g
+			#f.compose(g).(5,6)
+			def compose(g)
+				lambda do |*a,&b|
+					self.call(g.call(*a,&b))
+				end
+			end
+
+			#(->(x) {->(y) {x+y}}).uncurry.(2,3) #=> 5
+			#(->(x,y) {x+y}).curry.uncurry.(2,3) #=>5
+			def uncurry
+				lambda do |*a|
+					a.reduce(self) {|fun,v| fun.call(v)}
+				end
+			end
+		end
+
+		module Array
+			#allows to do things like
+			# ["ploum","plam"].map(&[:+,"foo"]) #=> ["ploumfoo", "plamfoo"]
+			def to_proc
+				ar=self.dup
+				method=ar.shift.to_proc
+				return method.rcurry(*ar)
+			end
+		end
+
+		module Object
+			#in ruby 2.2, 'Object#itself' only returns self
+			def this
+				return yield(self) if block_given?
+				return self
+			end
+			#simulate the Maybe monad
+			def and_this(&b)
+				nil? ? nil : this(&b)
+			end
+		end
+	end
+
+	module Recursive
+		extend self
+		def recursive_constructor(klass)
+			return Class.new(klass) do |rklass|
+				define_method :initialize do |*args,&b|
+					b ? super(*args,&b) : super(*args) { |h,k| h[k] = rklass.new }
+				end
+			end
+		end
+	end
+	RecursiveHash=Recursive.recursive_constructor(Hash)
+	#Arrays don't accept blocks in the same way as Hashs, we need to pass a length parameter, so we can't use DR::RecursiveHash(Array)
+end
+
+#automatically include the *Ext modules in their class
+DR::CoreExt.constants.each do |c|
+	Module.const_get(c).module_eval {include Module.const_get("DR::CoreExt::#{c}")}
+end

data/lib/drain/ruby_ext/meta_ext.rb

@@ -0,0 +1,211 @@
+module DR
+	module Meta
+		extend self
+		#from http://stackoverflow.com/questions/18551058/better-way-to-turn-a-ruby-class-into-a-module-than-using-refinements
+		#convert a class into a module using refinements
+		#ex: (Class.new { include Meta.refined_module(String) { def length; super+5; end } }).new("foo").length #=> 8
+		def refined_module(klass)
+			klass=klass.singleton_class unless Module===klass
+			Module.new do
+				include refine(klass) {
+					yield if block_given?
+				}
+			end
+		end
+
+		def all_ancestors(obj)
+			obj=obj.singleton_class unless Module===obj
+			found=[]
+			stack=[obj]
+			while !stack.empty? do
+				obj=stack.shift
+				next if found.include?(obj)
+				found<<obj
+				stack.push(* obj.ancestors.select {|m| !(stack+found).include?(m)})
+				sing=obj.singleton_class
+				stack << sing unless sing.ancestors.select {|m| m.class==Module}.reduce(true) {|b,m| b && found.include?(m)}
+			end
+			return found
+		end
+
+		#add extend_ancestors and extend_complete to Object
+		def extend_object
+			include_ancestors=Meta.method(:include_ancestors)
+			include_complete=Meta.method(:include_complete)
+			Object.define_method(:extend_ancestors) do |m|
+				include_ancestors.bind(singleton_class).call(m)
+			end
+			Object.define_method(:extend_complete) do |m|
+				include_complete.bind(singleton_class).call(m)
+			end
+		end
+
+		#If we don't want to extend a module with Meta, we can still do
+		#Meta.apply(String,method: Meta.instance_method(:include_ancestors),to: self)
+		#Note: another way is to use Symbold#to_proc which works like this:
+		#foo=:foo.to_proc; foo.call(obj,*args) #=> obj.method(:foo).call(*args)
+		#essentially apply is a 'useless' wrapper to .call, but it also works
+		#for UnboundMethod. See also dr/core_ext that add
+		#'UnboundMethod#call'
+		def apply(*args,method: nil, to: self, **opts,&block)
+			#note, in to self is Meta, except if we include it in another
+			#module so that it would make sense
+			method=method.unbind if method.class==Method
+			case method
+			when UnboundMethod
+				method=method.bind(to)
+			end
+			if opts.empty?
+				method.call(*args,&block)
+			else
+				method.call(*args,**opts,&block)
+			end
+		end
+
+		def get_bound_method(obj, method_name, &block)
+			obj.singleton_class.send(:define_method,method_name, &block)
+			method = obj.method method_name
+			obj.singleton_class.send(:remove_method,method_name)
+			method
+		end
+	end
+
+	#helping with metaprograming facilities
+	#usage: Module Foo; extend DR::MetaModule; include_complete Ploum; end
+	module MetaModule
+		#When included/extended (according to :hooks, add the following instance
+		#and class methods)
+		def includes_extends_host_with(instance_module=nil, class_module=nil, hooks: [:included,:extended])
+			@_include_module ||= []
+			@_extension_module ||= []
+			@_include_module << instance_module
+			@_extension_module << class_module
+			hooks.each do |hook|
+				define_singleton_method hook do |base|
+					#we use send here because :include is private in Module
+					@_include_module.each do |m|
+						m=const_get(m) if ! Module===m
+						base.send(:include, m)
+					end
+					@_extension_module.each do |m|
+						m=const_get(m) if ! Module===m
+						base.extend(m)
+					end
+				end
+			end
+		end
+
+		#include_ancestor includes all modules ancestor, so one can do
+		#singleton_class.include_ancestors(m) to have a fully featured extend
+		def include_ancestors(m)
+			ancestors=m.respond_to?(:ancestors) ? m.ancestors : m.singleton_class.ancestors
+			ancestors.reverse.each do |m|
+				include m if m.class==Module
+			end
+		end
+
+		#include a module and extend its singleton_class (along with its ancestors)
+		def include_complete(obj)
+			ancestors=Meta.all_ancestors(obj)
+			ancestors.reverse.each do |m|
+				include m if m.class==Module
+			end
+		end
+
+		# module Z
+		# 	def x; "x"; end
+		# end
+		# module Enumerable
+		# 	extend MetaModule
+		# 	full_include Z
+		# end
+		# Array.new.x => "x"
+		def full_include other
+			include other
+			if self.class == Module
+				this = self
+				ObjectSpace.each_object Module do |mod|
+					mod.send :include, this if mod < self
+				end
+			end
+		end
+
+		#Taken from sinatra/base.rb: return an unbound method from a block, with
+		#owner the current module
+		#Conversely, from a (bound) method, calling to_proc (hence &m) gives a lambda
+		#Note: rather than doing 
+		#m=get_unbound_method('',&block);m.bind(obj).call(args)
+		#one could do obj.instance_exec(args,&block)
+		def get_unbound_method(method_name, &block)
+			define_method(method_name, &block)
+			method = instance_method method_name
+			remove_method method_name
+			method
+		end
+
+		#essentially like define_method, but can pass a Method or an UnboundMethod
+		#see also dr/core_ext which add UnboundMethod#to_proc so we could
+		#instead use define_method(name,&method) and it would work
+		def add_method(name=nil,method)
+			name=method.name unless name
+			name=name.to_sym
+			#if we have a (bound) method, we can convert it to a proc, but the
+			#'self' inside it keeps being the 'self' of the original object (even
+			#in instance_eval).
+			#Since usually we'll want to change the self, it's better to unbind it
+			method=method.unbind if method.class==Method
+			case method
+			when UnboundMethod
+				#here the block passed is evaluated using instance_eval, so self is the
+				#object calling, not the current module
+				define_method name do |*args,&block|
+					method.bind(self).call(*args,&block)
+				end
+			else
+				#if method is a block/Proc, this is the same as define_method(name,method)
+				define_method(name,&method)
+			end
+		end
+
+		def add_methods(*args)
+			return if args.empty?
+			if Module === args.first
+				mod=args.shift
+				#we include methods from mod, the arguments should be method names
+				if args.size == 1 and Hash === args.first
+					#we have a hash {new_name => old_name}
+					args.first.each do |k,v|
+						add_method(k,mod.instance_method(v.to_sym))
+					end
+				else
+					args.each do |m|
+						add_method(mod.instance_method(m.to_sym))
+					end
+				end
+			else
+				if args.size == 1 and Hash === args.first
+					#we have a hash {new_name => method}
+					args.first.each do |k,v|
+						add_method(k,v)
+					end
+				else
+					args.each do |m|
+						add_method(m)
+					end
+				end
+			end
+		end
+	end
+
+	#DynamicModule.new(:methods_to_include) do ... end
+	class DynamicModule < Module
+		include MetaModule
+
+		def initialize(*args,&block)
+			super #call the block
+			add_methods(*args)
+		end
+
+	end
+end
+