drain 0.1.0 → 0.2.0

data/lib/dr/ruby_ext.rb

@@ -0,0 +1 @@
+lib/dr/base.rb

data/lib/dr/ruby_ext/core_ext.rb

@@ -0,0 +1,7 @@
+require 'dr/ruby_ext/core_modules'
+
+#automatically include the CoreExt modules in their class
+DR::CoreExt.constants.each do |c|
+	Module.const_get(c).module_eval {include Module.const_get("DR::CoreExt::#{c}")}
+end
+[Hash, Array].each {|m| m.include(Enumerable)} #to reinclude

data/lib/{drain/ruby_ext/core_ext.rb → dr/ruby_ext/core_modules.rb}

@@ -9,7 +9,7 @@ module DR
 				default=h[:default]
 				r={}
 				each do |el|
-					keys=invh.fetch(value,[default])
+					keys=invh.fetch(el,[default])
 					keys.each do |key|
 						(r[key]||=[]) << el
 					end
@@ -67,8 +67,10 @@ module DR
 			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
+			#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}
+			#h.invert #=> {2=>:plim, 3=>:plam}
+			#h.inverse #=> {2=>[:ploum, :plim], 3=>[:plam]}
 			def inverse
 				r={}
 				each_key do |k|
@@ -96,49 +98,83 @@ module DR
 			def keyed_value(key, sep: "/")
 				r=self.dup
 				return r if key.empty?
-				key.split(sep).each do |k|
+				key.to_s.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)
+			#take a key of the form ploum/plam/plim
+			#and return self[:ploum][:plam][:plim]=value
+			def set_keyed_value(key,value, sep: "/", symbolize: true)
+				r=self
+				*keys,last=key.to_s.split(sep)
+				keys.each do |k|
+					k=k.to_sym if (symbolize || r.key?(k.to_sym)) and !r.key?(k)
+					r[k]={} unless r.key?(k)
+					r=r[k]
 				end
+				last=last.to_sym if symbolize
+				r[last]=value
+				self
+			end
+
+			#from a hash {foo: [:bar, :baz], bar: [:plum, :qux]},
+			#then leaf [:foo] returns [:plum, :qux, :baz]
+			def leafs(nodes)
+				expanded=[] #prevent loops
+				r=nodes.dup
+				begin
+					s,r=r,r.map do |n|
+						if key?(n) && !expanded.include?(n)
+							expanded << n
+							fetch(n)
+						else
+							n
+						end
+					end.flatten
+				end until s==r
+				r
 			end
 		end
 
 		module UnboundMethod
 			#this should be in the stdlib...
+			#Note: this is similar to Symbol#to_proc which works like this:
+			#  foo=:foo.to_proc; foo.call(obj,*args) #=> obj.method(:foo).call(*args)
+			#  => :length.to_proc.call("foo") #=> 3
 			def to_proc
 				return lambda do |obj,*args,&b|
-					self.bind(obj).call(*args,&b)
+					bind(obj).call(*args,&b)
 				end
 			end
 			def call(*args,&b)
-				self.to_proc.call(*args,&b)
+				to_proc.call(*args,&b)
 			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 arity >= 0
+					case arity
+					when 0
+						call(**opts)
+					else
+						call(args[0...arity],**opts)
+					end
+				else
+					call(*args,**opts)
+				end
+			end
+
 			#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|
+				return ::Proc.new do |*a,&b|
 					self.call(*a,*args,&b)
 				end
 			end
@@ -147,7 +183,7 @@ module DR
 			#f.compose(g).(5,6)
 			def compose(g)
 				lambda do |*a,&b|
-					self.call(g.call(*a,&b))
+					self.call(*g.call(*a,&b))
 				end
 			end
 
@@ -183,6 +219,14 @@ module DR
 		end
 	end
 
+	module CoreRef
+		CoreExt.constants.select {|c| const_get("::#{c}").is_a?(Class)}.each do |c|
+			refine const_get("::#{c}") do
+				include CoreExt.const_get(c)
+			end
+		end
+	end
+
 	module Recursive
 		extend self
 		def recursive_constructor(klass)
@@ -194,10 +238,6 @@ module DR
 		end
 	end
 	RecursiveHash=Recursive.recursive_constructor(Hash)
+	#For an individual hash: hash = Hash.new {|h,k| h[k] = h.class.new(&h.default_proc) }
 	#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 → dr}/ruby_ext/meta_ext.rb

@@ -2,17 +2,28 @@ 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
+		#See also http://stackoverflow.com/questions/28649472/ruby-refinements-subtleties
+		#
 		#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)
+		#This uses the fact that a refining module of klass behaves as if it had
+		#klass has his direct ancestor
+		def refined_module(klass,&b)
 			klass=klass.singleton_class unless Module===klass
 			Module.new do
+				#including the module rather than just returning it allow us to
+				#still be able to use 'using' ('using' does not work directly on
+				#refining modules only on the enclosing ones)
 				include refine(klass) {
-					yield if block_given?
+					module_eval(&b) if block_given?
 				}
 			end
 		end
 
+		#find the ancestors of obj, its singleton class, its
+		#singleton_singleton_class. To avoid going to infinity, we only add a
+		#singleton_class when its ancestors contains new modules we have not
+		#seen.
 		def all_ancestors(obj)
 			obj=obj.singleton_class unless Module===obj
 			found=[]
@@ -28,25 +39,24 @@ module DR
 			return found
 		end
 
-		#add extend_ancestors and extend_complete to Object
+		# add extend_ancestors and full_extend to Object
 		def extend_object
 			include_ancestors=Meta.method(:include_ancestors)
-			include_complete=Meta.method(:include_complete)
+			include_complete=Meta.method(:full_include)
 			Object.define_method(:extend_ancestors) do |m|
 				include_ancestors.bind(singleton_class).call(m)
 			end
-			Object.define_method(:extend_complete) do |m|
+			Object.define_method(:full_extend) 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
+		#apply is a 'useless' wrapper to .call, but it also works for UnboundMethod.
+		#  See also dr/core_ext that adds 'UnboundMethod#call'
+		#=> 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'
+		#(note that in 'Meta.apply', the default option to 'to:' is self=Meta,
+		#that's why we need to put 'to: self' again)
 		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
@@ -55,6 +65,7 @@ module DR
 			when UnboundMethod
 				method=method.bind(to)
 			end
+			#We cannot call **opts if opts is empty in case of an empty args, cf https://bugs.ruby-lang.org/issues/10708
 			if opts.empty?
 				method.call(*args,&block)
 			else
@@ -68,6 +79,32 @@ module DR
 			obj.singleton_class.send(:remove_method,method_name)
 			method
 		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
+
+		#like get_unbound_method except we pass a strng rather than a block
+		def get_unbound_evalmethod(method_name, method_str, args: '')
+			module_eval <<-RUBY
+				def #{method_name}(#{args})
+					#{method_str}
+				end
+			RUBY
+			method = instance_method method_name
+			remove_method method_name
+			method
+		end
+
 	end
 
 	#helping with metaprograming facilities
@@ -96,7 +133,7 @@ module DR
 		end
 
 		#include_ancestor includes all modules ancestor, so one can do
-		#singleton_class.include_ancestors(m) to have a fully featured extend
+		#singleton_class.include_ancestors(String) to include the Module ancestors of String into the class
 		def include_ancestors(m)
 			ancestors=m.respond_to?(:ancestors) ? m.ancestors : m.singleton_class.ancestors
 			ancestors.reverse.each do |m|
@@ -104,8 +141,7 @@ module DR
 			end
 		end
 
-		#include a module and extend its singleton_class (along with its ancestors)
-		def include_complete(obj)
+		def include_all_ancestors(obj)
 			ancestors=Meta.all_ancestors(obj)
 			ancestors.reverse.each do |m|
 				include m if m.class==Module
@@ -113,11 +149,11 @@ module DR
 		end
 
 		# module Z
-		# 	def x; "x"; end
+		#		def x; "x"; end
 		# end
 		# module Enumerable
-		# 	extend MetaModule
-		# 	full_include Z
+		#		extend MetaModule
+		#		full_include Z
 		# end
 		# Array.new.x => "x"
 		def full_include other
@@ -130,19 +166,6 @@ module DR
 			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
@@ -167,6 +190,10 @@ module DR
 			end
 		end
 
+		#add_methods(method1, method2, ...)
+		#add_methods({name1: method1, name2: method2, ...})
+		#add_methods(aClass, :method_name1, :method_name2)
+		#add_methods(aClass, {new_name1: :method_name1, new_name2: :method_name2})
 		def add_methods(*args)
 			return if args.empty?
 			if Module === args.first

data/lib/dr/tools.rb

@@ -0,0 +1 @@
+lib/dr/base.rb

data/lib/dr/version.rb

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

data/lib/drain.rb

@@ -1 +1,2 @@
-require 'drain/version'
+require 'dr.rb'
+Drain=DR

data/test/helper.rb

@@ -1,2 +1,13 @@
-require 'rubygems'
 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
+  #Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+  #Minitest::Reporters.use! Minitest::Reporters::ProgressReporter.new
+rescue LoadError => error
+  warn "minitest/reporters not found, not changing minitest reporter: #{error}"
+end

data/test/test_converter.rb

@@ -0,0 +1,42 @@
+require 'helper'
+require 'dr/base/converter'
+
+describe DR::Converter do
+	before do
+		klass=Class.new do
+			attr_accessor :a, :h
+			def initialize(a,h)
+				@a=a
+				@h=h
+			end
+		end
+		@obj1=klass.new(["foo","bar"],{foo: :bar})
+		@obj2=klass.new([@obj1],{})
+		@obj3=klass.new([],{@obj1 => @obj2})
+		@obj3.a << @obj3
+	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}})
+	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})
+	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 => {}})
+	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}})
+	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}})
+	end
+
+end

data/test/test_core_ext.rb

@@ -0,0 +1,116 @@
+require 'helper'
+require 'dr/ruby_ext/core_modules'
+
+module TestCoreExtRefinements
+	using DR::CoreRef
+	# TODO make refinements work nicely
+end
+
+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]})
+			end
+		end
+
+		describe Hash do
+			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"]})
+			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"})
+			end
+
+			it "Implements Hash#inverse" do
+				h={ploum: 2, plim: 2, plam: 3}
+				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")
+			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"}})
+			end
+
+			it "Implements Hash#leafs" do
+				{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])
+			end
+			it "Can call" do
+				String.instance_method(:length).call("foo").must_equal(3)
+			end
+		end
+
+		describe Proc do
+			# fails due to ruby bug on double splat
+			# it "call_block does not worry about arity of lambda" do
+			# 	(->(x,y) {x+y}).call_block(1,2,3).must_equal(3)
+			# end
+
+			it "Can do rcurry" do
+				l=->(x,y) {"#{x}: #{y}"}
+				m=l.rcurry("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)
+			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)
+			end
+		end
+
+		describe Array do
+			it "Can be converted to proc (providing extra arguments)" do
+				["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)
+			end
+
+			it "and_this emulates the Maybe Monad" do
+				"foo".and_this {|s| s.size}.must_equal(3)
+				assert_nil nil.and_this {|s| s.size}
+			end
+		end
+
+		describe DR::RecursiveHash do
+			it "Generates keys when needed" do
+				h=DR::RecursiveHash.new
+				h[:foo][:bar]=3
+				h.must_equal({foo: {bar: 3}})
+			end
+		end
+	end
+end