drain 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4801bbbd9081149ae66059ccabf69e10a6002c16
-  data.tar.gz: bd24d077d42a458160c61e985a8f3e2e1d14f323
+SHA256:
+  metadata.gz: 2a6165b74687b54296ee9b273eac4465746de73b9774eb5466fd550031897cba
+  data.tar.gz: 915728a74d0050b45fec8167e51e2b08c3657defb5fc3187b25b4aca2ff18fb4
 SHA512:
-  metadata.gz: f6c18209c458007657d6bc26e79d34f64a50de127c4db0b4d1dd525f3de950eb3d2cf8543a816aaddb4f322fc146e7bde45645f0af0bc95dd01360afe4fd3015
-  data.tar.gz: 0f64e58698354e4b75385aaa8127eedad9d55d6413fe141f3dea621eeacffb94cc531d3f80ea892ab16465134e28d9879c10884a835f43376de8bc609a615947
+  metadata.gz: f1c013bdb8158298fec2a204063d142a328840e9f3bea214036932ddc59f696aca94549190df72b95b3110dbea295f7a2e240bd69dbb3ed7264911a201517297
+  data.tar.gz: 4cdffbe87293046d6752bd64a0e7e17224b16786d39cb5ff4f4537a5ed3da6722060acf44475774c4bc788f4b09abbb66cf85833e8027cc990fb79fc862f001c

data/.gitignore

@@ -1,2 +1,6 @@
-doc/
-pkg/
+/.bundle
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.travis.yml

@@ -0,0 +1,10 @@
+---
+language: ruby
+rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - 2.1.10
+  - ruby-head
+  - ruby-head-clang
+script: rake test

data/.yardopts

@@ -1 +1,6 @@
---markup markdown -M kramdown --title "drain Documentation" --protected
+--markup markdown
+--title "drain Documentation"
+--protected
+-
+ChangeLog.md
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'kramdown'
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Damien Robert
+Copyright © 2015–2017 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

@@ -1,25 +1,31 @@
 # 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)
+* [Documentation](http://rubydoc.info/gems/drain)
 * [Email](mailto:Damien.Olivier.Robert+gems at gmail.com)
 
+[![Gem Version](https://img.shields.io/gem/v/drain.svg)](https://rubygems.org/gems/drain)
+[![Build Status](https://travis-ci.org/DamienRobert/drain.svg?branch=master)](https://travis-ci.org/DamienRobert/drain)
+
 ## 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!
 
+## Warning
+
+  For now the API is experimental and some parts are not ready to use!
+
 ## Install
 
     $ gem install drain
 
 ## Copyright
 
-Copyright (c) 2015 Damien Robert
+Copyright © 2015–2017 Damien Robert
 
-MIT License. See {file:LICENSE.txt} for details.
+MIT License. See [LICENSE.txt](./LICENSE.txt) for details.
 
 Some of the code is inspired by other project, in general I give proper
-Acknowledgement in the corresponding file.
+acknowledgement in the corresponding file.

data/Rakefile

@@ -1,20 +1,16 @@
-# encoding: utf-8
-
-require 'rubygems'
 require 'rake'
 
 begin
-  gem 'rubygems-tasks', '~> 0.2'
   require 'rubygems/tasks'
-
-  Gem::Tasks.new
+  Gem::Tasks.new(sign: {checksum: true, pgp: true}, 
+    scm: {status: true}) do |tasks|
+  tasks.console.command = 'pry'
+end
 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'
@@ -22,13 +18,12 @@ Rake::TestTask.new do |test|
 end
 
 begin
-  gem 'yard', '~> 0.8'
   require 'yard'
-
-  YARD::Rake::YardocTask.new  
+  YARD::Rake::YardocTask.new
 rescue LoadError => e
   task :yard do
-    abort "Please run `gem install yard` to install YARD."
+    warn e.message
   end
 end
 task :doc => :yard
+

data/drain.gemspec

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'yaml'
 
 Gem::Specification.new do |gem|
@@ -10,8 +8,8 @@ Gem::Specification.new do |gem|
                   lib_dir = File.join(File.dirname(__FILE__),'lib')
                   $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
 
-                  require 'drain/version'
-                  Drain::VERSION
+                  require 'dr/version'
+                  DR::VERSION
                 end
 
   gem.summary     = gemspec['summary']
@@ -24,6 +22,16 @@ Gem::Specification.new do |gem|
   glob = lambda { |patterns| gem.files & Dir[*patterns] }
 
   gem.files = `git ls-files`.split($/)
+
+  `git submodule --quiet foreach --recursive pwd`.split($/).each do |submodule|
+    submodule.sub!("#{Dir.pwd}/",'')
+
+    Dir.chdir(submodule) do
+      `git ls-files`.split($/).map do |subpath|
+        gem.files << File.join(submodule,subpath)
+      end
+    end
+  end
   gem.files = glob[gemspec['files']] if gemspec['files']
 
   gem.executables = gemspec.fetch('executables') do
@@ -38,7 +46,7 @@ Gem::Specification.new do |gem|
     %w[ext lib].select { |dir| File.directory?(dir) }
   })
 
-  gem.requirements              = gemspec['requirements']
+  gem.requirements              = Array(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']
@@ -56,4 +64,6 @@ Gem::Specification.new do |gem|
       gem.add_development_dependency(name,split[versions])
     end
   end
+
+  gem.metadata['yard.run']='yri'
 end

data/gemspec.yml

@@ -8,6 +8,7 @@ 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
+  minitest: "~> 5.0"
+  rake: "~> 10"
+  rubygems-tasks: "~> 0.2"
+  yard: "~> 0.8"

data/lib/dr.rb

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

data/lib/dr/base/converter.rb

@@ -0,0 +1,33 @@
+module DR
+	module Converter
+		extend self
+		#convert an obj to hash, using 'methods' for the methods attributes
+		def to_hash(obj=nil, methods:[], recursive: false, check: false, compact: false)
+			return {} if obj.nil?
+			obj||=self
+			stack=[*obj]
+			processed=[]
+			klass=stack.first.class
+			h={}
+			while !stack.empty?
+				obj=stack.shift
+				next if processed.include?(obj)
+				processed << obj
+				attributes={}
+				methods.each do |m|
+					next if check and !obj.respond_to? m
+					v=obj.public_send(m)
+					attributes[m]=v
+					if recursive
+						vals=v.kind_of?(Enumerable) ? v.to_a.flatten : [v]
+						vals.select! {|v| v.kind_of?(klass)}
+						stack.concat(vals)
+					end
+				end
+				attributes=attributes.values.first if compact and attributes.keys.length == 1
+				h[obj]=attributes
+			end
+			h
+		end
+	end
+end

data/lib/dr/base/eruby.rb

@@ -0,0 +1,284 @@
+module DR
+	class Eruby
+		module BindingHelper
+			extend self
+			#complement TOPLEVEL_BINDING
+			def empty_binding
+				#wraps into anonymous module so that 'def foo' do not pollute namespace
+				Module.new do
+					#regenerate a new binding
+					return binding
+				end
+			end
+			#empty binding (at first) that stays the same and can be shared
+			EMPTY_BINDING = empty_binding
+			BLANK_OBJECT=Object.new
+
+			# add variables values to a binding; variables is a Hash
+			def add_variables(variables, _binding=empty_binding)
+				eval variables.collect{|k,v| "#{k} = variables[#{k.inspect}]; "}.join, _binding
+				_binding
+			end
+
+			#From Tilt/template.rb
+			#return a string extracting local_keys from a hash named _context
+			def local_extraction(local_keys, context_name: '_context')
+				local_keys.map do |k|
+					if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
+						"#{k} = #{context_name}[#{k.inspect}]"
+					else
+						raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+					end
+				end.join("\n")+"\n"
+			end
+
+		end
+
+		module EngineHelper
+			### Stolen from erubis
+			## eval(@src) with binding object
+			def result(_binding_or_hash=BindingHelper.empty_binding)
+				_arg = _binding_or_hash
+				if _arg.is_a?(Hash)
+					_b=BindingHelper.add_variables(_arg, BindingHelper.empty_binding)
+				elsif _arg.is_a?(Binding)
+					_b = _arg
+				elsif _arg.nil?
+					_b = binding
+				else
+					raise ArgumentError.new("#{self.class.name}#result(): argument should be Binding or Hash but passed #{_arg.class.name} object.")
+				end
+				return eval(@src, _b, (@filename || '(eruby'))
+				#erb.rb:
+				#  if @safe_level
+				#  proc {
+				#		 $SAFE = @safe_level
+				#		 eval(@src, b, (@filename || '(erb)'), @lineno)
+				#  }.call
+			end
+
+			#Note that when the result is not used afterwards via "instance_eval"
+			#then the Klass of binding is important when src has 'def foo...'
+			#If set, locals should be an array of variable names
+			def compile(wrap: :proc, bind: BindingHelper.empty_binding, locals: nil, pre: nil, post: nil, context_name: '_context')
+				src=@src
+				src=BindingHelper.local_extraction(locals, context_name: context_name)+src if locals
+				src=pre+"\n"+src if pre
+				src<< post+"\n" if post
+				to_eval=case wrap
+					when :eval; @src
+					when :lambda; "lambda { |#{context_name}| #{src} }"
+					when :proc; "Proc.new { |#{context_name}| #{src} }"
+					when :module; "Module.new { |#{context_name}| #{src} }"
+					when :unbound
+						#wrapping in a method allows us to pass a block to a code
+						#calling yield
+						require 'dr/ruby_ext/meta_ext'
+						return Meta.get_unbound_evalmethod('eruby', src, args: context_name)
+					when :unbound_instance
+						#here we wrap in a method that the calls instance_eval
+						require 'dr/ruby_ext/meta_ext'
+						return Meta.get_unbound_evalmethod('eruby', <<-RUBY, args: context_name)
+							self.instance_eval do
+								#{src}
+							end
+						RUBY
+					when :string
+						src.to_s
+					else 
+						warn "wrap meth #{warn} not understood, defaulting to String"
+						src
+					end
+				return eval(to_eval, bind, "(wrap #{@filename})")
+			end
+
+			## by default invoke context.instance_eval(@src)
+			def evaluate(_context=Context.new, compile: {}, **opts, &b)
+				#I prefer to pass context as a keyword, but we allow to pass it as
+				#an argument to respect erubis's api
+				_context=opts[:context] if opts.key?(:context)
+				_context = Context.new(_context) if _context.is_a?(Hash)
+				vars=opts[:vars]
+				compile[:locals]||=vars.keys if vars
+				#to pass a block we need to wrap in a method
+				compile[:wrap]||=:unbound_instance if b
+				_proc=compile(**compile)
+				Eruby.evaluate(_proc, context: _context, **opts, &b)
+			end
+
+			## if object is an Class or Module then define instance method to it,
+			## else define singleton method to it.
+			def def_method(object, method_name, filename=nil)
+				m = object.is_a?(Module) ? :module_eval : :instance_eval
+				object.__send__(m, "def #{method_name}; #{@src}; end", filename || @filename || '(eruby)')
+				#erb.rb: src = self.src.sub(/^(?!#|$)/) {"def #{methodname}\n"} << "\nend\n" #This pattern insert the 'def' after lines with leading comments
+			end
+		end
+
+		class Template
+			include EngineHelper
+
+			def initialize(src, filename: nil)
+				if src.respond_to?(:read)
+					filename=src unless filename
+					src=src.read
+				end
+				@filename=filename || self.class.inspect
+				@src=src
+			end
+
+		end
+
+		module ClassHelpers
+			def process_eruby(eruby_src, **opts, &b)
+				src=Eruby::Engine.new(eruby_src).src
+				process_ruby(src, **opts, &b)
+			end
+
+			def process_ruby(src, src_info: nil, **opts, &b)
+				Template.new(src, filename: src_info).evaluate(**opts, &b)
+			end
+
+			def evaluate(_proc, context: Context.new, vars: nil, &b)
+				#we can only pass the block b when we get an UnboundMethod
+				if _proc.is_a?(UnboundMethod)
+					vars={} if _proc.arity > 0 and vars.nil?
+					if !vars.nil?
+						_proc.bind(context).call(vars,&b)
+					else
+						_proc.bind(context).call(&b)
+					end
+				elsif _proc.is_a?(String)
+					#in this case we cannot pass vars
+					warn "Cannot pass variables when _proc is a String" unless vars.nil?
+					context.instance_eval(_proc)
+				else
+					if context.nil?
+						if !vars.nil?
+							_proc.to_proc.call(vars,&b)
+						else
+							_proc.to_proc(&b)
+						end
+					else
+						warn "Cannot pass block in context.instance_eval" unless b.nil?
+						if !vars.nil?
+							context.instance_exec(vars,&_proc)
+						else
+							context.instance_eval(&_proc)
+						end
+					end
+				end
+			end
+
+			def include(template, **opts)
+				file=File.expand_path(template)
+				Dir.chdir(File.dirname(file)) do |cwd|
+					erb = Engine.new(File.read(file))
+					#if context is not empty, then we probably want to evaluate
+					if opts[:evaluate] or opts[:context]
+						r=erb.evaluate(opts[:context])
+					else
+						bind=opts[:bind]||binding
+						r=erb.result(bind)
+					end
+					#if using erubis, it is better to invoke the template in <%= =%> than
+					#to use chomp=true
+					r=r.chomp if opts[:chomp]
+					return r
+				end
+			end
+		end
+
+		extend ClassHelpers
+
+		begin
+			require 'erubi'
+			Engine=::Erubi::Engine
+		rescue LoadError
+			require 'erubis'
+			Engine=::Erubis::Eruby
+		rescue LoadError
+			require 'erb'
+			Engine=::ERB
+		end
+		#prepend so that we have the same implementation
+		Engine.__send__(:prepend, EngineHelper)
+
+		## Copy/Pasted from erubis context.rb
+		## # context object for Engine#evaluate
+		##
+		## ex.
+		##	 template = <<'END'
+		##	 Hello <%= @user %>!
+		##	 <% for item in @list %>
+		##		- <%= item %>
+		##	 <% end %>
+		##	 END
+		##
+		##	 context = Erubis::Context.new(:user=>'World', :list=>['a','b','c'])
+		##	 # or
+		##	 # context = Erubis::Context.new
+		##	 # context[:user] = 'World'
+		##	 # context[:list] = ['a', 'b', 'c']
+		##
+		##	 eruby = Erubis::Eruby.new(template)
+		##	 print eruby.evaluate(context)
+		##
+		class Context
+			include Enumerable
+
+			def initialize(hash=nil)
+				hash.each do |name, value|
+					self[name] = value
+				end if hash
+			end
+
+			def [](key)
+				return instance_variable_get("@#{key}")
+			end
+
+			def []=(key, value)
+				return instance_variable_set("@#{key}", value)
+			end
+
+			def keys
+				return instance_variables.collect { |name| name[1..-1] }
+			end
+
+			def each
+				instance_variables.each do |name|
+					key = name[1..-1]
+					value = instance_variable_get(name)
+					yield(key, value)
+				end
+			end
+
+			# Was to_hash, but changed to 'to_h' in commit 25d0e1e4b1a4ada40fd64945eb79823ea074d030
+			# Indeed otherwise passing it to 'evaluate' it get interpreted as the options rather than as a context
+			# cf https://bugs.ruby-lang.org/issues/12884
+			# corrected in ruby 2.4.1?
+			def to_h
+				hash = {}
+				self.keys.each { |key| hash[key] = self[key] }
+				return hash
+			end
+
+			def update(context_or_hash)
+				arg = context_or_hash
+				if arg.is_a?(Hash)
+					arg.each do |key, val|
+						self[key] = val
+					end
+				else
+					arg.instance_variables.each do |varname|
+						key = varname[1..-1]
+						val = arg.instance_variable_get(varname)
+						self[key] = val
+					end
+				end
+			end
+
+		end
+	end
+
+end