drain 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4801bbbd9081149ae66059ccabf69e10a6002c16
+  data.tar.gz: bd24d077d42a458160c61e985a8f3e2e1d14f323
+SHA512:
+  metadata.gz: f6c18209c458007657d6bc26e79d34f64a50de127c4db0b4d1dd525f3de950eb3d2cf8543a816aaddb4f322fc146e7bde45645f0af0bc95dd01360afe4fd3015
+  data.tar.gz: 0f64e58698354e4b75385aaa8127eedad9d55d6413fe141f3dea621eeacffb94cc531d3f80ea892ab16465134e28d9879c10884a835f43376de8bc609a615947

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,2 @@
+doc/
+pkg/

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown -M kramdown --title "drain Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2015-02-24
+
+* Initial release:
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Damien Robert
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+# drain
+
+* [Homepage](https://github.com/DamienRobert/drain#readme)
+* [Gems]("https://rubygems.org/gems/drain)
+* [Issues](https://github.com/DamienRobert/drain/issues)
+* [Documentation](http://rubydoc.info/gems/drain/frames)
+* [Email](mailto:Damien.Olivier.Robert+gems at gmail.com)
+
+## Description
+
+Drain is a small set of libraries that I use in my other gems.
+The Api is far from stable yet, so use at your own risk!
+
+## Install
+
+    $ gem install drain
+
+## Copyright
+
+Copyright (c) 2015 Damien Robert
+
+MIT License. See {file: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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard

data/drain.gemspec

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'drain/version'
+                  Drain::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/gemspec.yml

@@ -0,0 +1,13 @@
+name: drain
+summary: "Use a drain for a dryer ruby!"
+description: |
+  Drain is a small set of libraries that I use in my other gems.
+license: MIT
+authors: Damien Robert
+email: Damien.Olivier.Robert+gems@gmail.com
+homepage: https://github.com/DamienRobert/drain#readme
+
+development_dependencies:
+  minitest: ~> 5.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/lib/drain.rb

@@ -0,0 +1 @@
+require 'drain/version'

data/lib/drain/base.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/base/bool.rb

@@ -0,0 +1,25 @@
+module DR
+  module Bool
+    extend(self)
+    def to_bool(el, default=nil)
+      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 == 0)
+      when Process::Status
+        exitstatus=el.exitstatus
+        return exitstatus == 0
+      else
+        return true if el == true
+        return false if el == false
+        #we don't return !!el because we don't want nil to be false but to
+        #give an error
+      end
+      return default unless default.nil?
+      raise ArgumentError.new("Invalid value for Boolean: \"#{el}\"")
+    end
+  end
+end

data/lib/drain/base/encoding.rb

@@ -0,0 +1,43 @@
+require 'iconv' unless String.method_defined?(:encode)
+#cf http://stackoverflow.com/questions/2982677/ruby-1-9-invalid-byte-sequence-in-utf-8
+module DR
+  module Encoding
+    module_function
+    #if a mostly utf8 has some mixed in latin1 characters, replace the
+    #invalid characters
+    def fix_utf8(s=nil)
+      s=self if s.nil? #if we are included
+      if String.method_defined?(:scrub)
+        #Ruby 2.1
+        #cf http://ruby-doc.org/core-2.1.0/String.html#method-i-scrub
+        return s.scrub {|bytes| '<'+bytes.unpack('H*')[0]+'>' }
+      else
+        return DR::Encoding.to_utf8(s)
+      end
+    end
+
+    def to_utf8(s=nil,from:nil)
+      s=self if s.nil? #if we are included
+      from=s.encoding if from.nil?
+      if String.method_defined?(:encode)
+        #Ruby 1.9
+        return s.encode('UTF-8',from, :invalid => :replace, :undef => :replace,
+                 :fallback => Proc.new { |bytes| '<'+bytes.unpack('H*')[0]+'>' }
+               )
+      else
+        #Ruby 1.8
+        ic = Iconv.new(from, 'UTF-8//IGNORE')
+        return ic.iconv(s)
+      end
+    end
+
+    #assume ruby>=1.9 here
+    def to_utf8!(s=nil,from:nil)
+      s=self if s.nil? #if we are included
+      from=s.encoding if from.nil?
+      return s.encode!('UTF-8',from, :invalid => :replace, :undef => :replace,
+               :fallback => Proc.new { |bytes| '<'+bytes.unpack('H*')[0]+'>' }
+             )
+    end
+  end
+end

data/lib/drain/base/eruby.rb

@@ -0,0 +1,28 @@
+module DR
+	module Eruby
+		begin
+			require 'erubis'
+			Erb=::Erubis::Eruby
+		rescue LoadError
+			require 'erb'
+			Erb=::ERB
+		end
+		def erb_include(template, opt={})
+			opt={bind: binding}.merge(opt)
+			file=File.expand_path(template)
+			Dir.chdir(File.dirname(file)) do |cwd|
+				erb = Erb.new(File.read(file))
+				#if context is not empty, then we probably want to evaluate
+				if opt[:evaluate] or opt[:context]
+					r=erb.evaluate(opt[:context])
+				else
+					r=erb.result(opt[:bind])
+				end
+				#if using erubis, it is better to invoke the template in <%= =%> than
+				#to use chop=true
+				r=r.chomp if opt[:chomp]
+				return r
+			end
+		end
+	end
+end

data/lib/drain/base/functional.rb

@@ -0,0 +1,41 @@
+module DR
+	module Lambda
+		extend self
+		#standard ruby: col.map(&f)
+		#Here: Lambda.map(f,col1,col2,...)
+		#Other implementation:
+		#(shift cols).zip(cols).map {|a| f.call(*a)}
+		#but our implementation stops as soon as a collection is empty
+		#whereas the zip implementation use the length of the first collection
+		#and pads with nil
+		def map(f,*cols)
+			cols=cols.map(&:each)
+			r=[]
+			loop do
+				r<<f.call(*cols.map(&:next))
+			end
+			r
+		rescue StopIteration
+		end
+
+		#like map but return an enumerator
+		def enum_map(f,*cols)
+			cols=cols.map(&:each)
+			Enumerator.new do |y|
+				loop do
+					y<<f.call(*cols.map(&:next))
+				end
+			end
+		end
+
+		#compose a list of functions
+		def compose(*f)
+			f.reverse!
+			first=f.shift
+			return lambda do |*args,&b|
+				v=first.call(*args,&b)
+				f.reduce(v) {|v,fun| fun.call(v)}
+			end
+		end
+	end
+end

data/lib/drain/base/graph.rb

@@ -0,0 +1,213 @@
+require 'set'
+#Originally inspired by depgraph: https://github.com/dcadenas/depgraph
+
+module DR
+	class Node
+		include Enumerable
+		attr_reader :graph
+		attr_accessor :name, :attributes, :parents, :children
+		def initialize(name, attributes: nil, graph: nil)
+			@name = name
+			@children = []
+			@parents = []
+			@attributes = attributes
+			@graph=graph
+			graph.nodes << self if @graph
+		end
+		def each
+			@children.each
+		end
+		def <=>(other)
+			return @name <=> other.name
+		end
+		#self.add_child(ploum) marks ploum as a child of self (ie ploum depends on self)
+		def add_child(*nodes)
+			nodes.each do |node|
+				if not @children.include?(node)
+					@children << node
+					node.parents << self
+				end
+			end
+		end
+		def rm_child(*nodes)
+			nodes.each do |node|
+				if @children.include?(node)
+					@children.delete(node)
+					node.parents.delete(self)
+				end
+			end
+		end
+		def add_parent(*nodes)
+			nodes.each do |node|
+				if not @parents.include?(node)
+					@parents << node
+					node.children << self
+				end
+			end
+		end
+		def rm_parent(*nodes)
+			nodes.each do |node|
+				if @parents.include?(node)
+					@parents.delete(node)
+					node.children.delete(self)
+				end
+			end
+		end
+
+		STEP = 4
+		def to_s
+			return @name
+		end
+		def to_graph(indent_level: 0)
+			sout = ""
+			margin = ''
+			0.upto(indent_level/STEP-1) { |p| margin += (p==0 ? ' ' : '|') + ' '*(STEP - 1) }
+			margin += '|' + '-'*(STEP - 2)
+			sout += margin + "#{@name}\n"
+			@children.each do |child|
+				sout += child.to_graph(indent_level: indent_level+STEP)
+			end
+			return sout
+		end
+		def to_dot
+			sout=["\""+name+"\""]
+			@children.each do |child|
+				sout.push  "\"#{@name}\" -> \"#{child.name}\""
+				sout += child.to_dot
+			end
+			return sout
+		end
+	end
+
+	class Graph
+		attr_accessor :nodes
+		include Enumerable
+		def initialize(g=nil)
+			@nodes=[]
+			if g #convert a hash to a graph
+				g.each do |name,children|
+					n=build(name)
+					n.add_child(*children)
+				end
+			end
+		end
+		def build(node, children: [], parents: [], **keywords)
+			graph_node=
+			case node
+			when Node
+				match = @nodes.find {|n| n == node} and return match
+				Node.new(node.name, graph: self, **keywords.merge({attributes: node.attributes||keywords[:attributes]}))
+				node.children.each do |c|
+					build(c,**keywords)
+				end
+			else
+				match = @nodes.find {|n| n.name == node}
+				match || Node.new(node, graph: self, **keywords)
+			end
+			graph_node.add_child(*children.map { |child| build(child) })
+			graph_node.add_parent(*parents.map { |child| build(child) })
+			return graph_node
+		end
+		def each
+			@nodes.each
+		end
+		def to_a
+			return @nodes
+		end
+		def all
+			@nodes.sort
+		end
+		def roots
+			@nodes.select{ |n| n.parents.length == 0}.sort
+		end
+		def dump(mode: :graph, nodes_list: :roots, **unused)
+			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 end
+			when :list; n.each do |i| sout+="- #{i}\n" end
+			when :dot;
+				sout+="digraph gems {\n"
+				sout+=n.map {|node| node.to_dot}.inject(:+).uniq!.join("\n")
+				sout+="}\n"
+			end
+			return sout
+		end
+
+		#return the connected set containing nodes (following the direction
+		#given)
+		def connected(*nodes, down:true, up:true)
+			r=Set.new()
+			nodes.each do |node|
+				unless r.include?(node)
+					new_nodes=Set.new()
+					new_nodes.merge(node.children) if down
+					new_nodes.merge(node.parents) if up
+					r.merge(connected(*new_nodes, down:down,up:up))
+				end
+			end
+			return r
+		end
+		#return all parents
+		def ancestors(*nodes)
+			connected(*nodes, up:true, down:false)
+		end
+		#return all childern
+		def descendants(*nodes)
+			connected(*nodes, up:false, down:true)
+		end
+
+		#from a list of nodes, return all nodes that are not descendants of
+		#other nodes in the graph
+		def unneeded(*nodes)
+			tokeep.merge(@nodes-nodes)
+			nodes.each do |node|
+				unneeded << node unless ancestors(node).any? {|c| tokeep.include?(c)}
+			end
+		end
+		#return all dependencies that are not needed by any more nodes.
+		#If some dependencies should be kept (think manual install), add them
+		#to the unneeded parameter
+		def unneeded_descendants(*nodes, needed:[])
+			needed-=nodes #nodes to delete are in priority
+			deps=descendants(*nodes)
+			deps-=needed #but for children nodes, needed nodes are in priority
+			unneeded(*deps)
+		end
+		#So to implement the equivalent of pacman -Rc packages
+		#it suffices to add the ancestors of packages
+		#For pacman -Rs, this is exactly unneeded_descendants
+		#and pacman -Rcs would be ancestors(unneeded_descendants)
+		#finally to clean all unneeded packages (provided we have a list of
+		#packages 'tokeep' to keep), either use unneeded(@nodes-tokeep)
+		#or unneeded_descendants(roots, needed:tokeep)
+
+		#return the subgraph containing all the nodes passed as parameters,
+		#and the complementary graph. The union of both may not be the full
+		#graph [edges] in case the components are not connected
+		def subgraph(*nodes)
+			subgraph=Graph.new()
+			compgraph=Graph.new()
+			@nodes.each do |node|
+				if nodes.include?(node)
+					n=subgraph.build(node.name)
+					node.children.each do |c|
+						n.add_child(c) if nodes.include?(c)
+					end
+				else
+					n=compgraph.build(node.name)
+					node.children.each do |c|
+						n.add_child(c) unless nodes.include?(c)
+					end
+				end
+			end
+			return subgraph, compgraph
+		end
+
+	end
+end