shell_helpers 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e423354674b7162de244672ab417617837d4667f
-  data.tar.gz: 36527735c314d40be7389de683688e4446c24961
+SHA256:
+  metadata.gz: 6049045c2830e61e0ea865aeb4905e0f4464cdd4b837ee0e7923667e8aae7900
+  data.tar.gz: 2ca9a6fceac250538239f8ff3b075d4d2813b02892f7dad411dfad0a8dbfd1e7
 SHA512:
-  metadata.gz: 743a7bbaec3fa0511cbba321b847db43233a3c964bc4a03cbd07577c5ef2ae4e5357d98a9906532c5536842f92f10ecddf815904f2e776035533763a3a9b8fb4
-  data.tar.gz: 023a3e4ce0a45b3cde0c94906ae05ab1d15687531f9425eb93b60fd59d1fd17c3fd6939b629617d92f0520d6083f06b729a3e54e1ae2f3a317ce58c6b80bf03f
+  metadata.gz: 809023e14ecf8fc382ce25f107eeeba053573e190fac4030641a496e74306d3f480ef6b4555f5ffb71b9e412bf4f95778c78ab7bdf27efa7a517f92c1239c69c
+  data.tar.gz: 6db15aa50cb2ee5d60ee85404a109b00f8106aad9491b993c6aed289f2f23fd838d65124501a617672cf3e9fa06360aef525177199fedaa1b47362622b6a673c

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: bundle exec rake test

data/.yardopts

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'drain', :github => 'DamienRobert/drain'
+
+group :development do
+  gem 'kramdown'
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 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

@@ -1,11 +1,13 @@
 # shell_helpers
 
 * [Homepage](https://github.com/DamienRobert/shell_helpers#readme)
-* [Gems]("https://rubygems.org/gems/shell_helpers)
 * [Issues](https://github.com/DamienRobert/shell_helpers/issues)
-* [Documentation](http://rubydoc.info/gems/shell_helpers/frames)
+* [Documentation](http://rubydoc.info/gems/shell_helpers)
 * [Email](mailto:Damien.Olivier.Robert+gems at gmail.com)
 
+[![Gem Version](https://img.shields.io/gem/v/shell_helpers.svg)](https://rubygems.org/gems/shell_helpers)
+[![Build Status](https://travis-ci.org/DamienRobert/shell_helpers.svg?branch=master)](https://travis-ci.org/DamienRobert/shell_helpers)
+
 ## Description
 
   This gem contains a collection of libraries to ease working with the
@@ -23,13 +25,35 @@
   this functionality from other command parsers than methadone
   (like [gli](https://github.com/davetron5000/gli)).
 
+## Features
+
+  One of the main feature is an extension of the class `Pathname` with a
+  lots of methods to help in shell related task.
+
+## Examples
+
+    require 'shell_helpers'
+    SH::Pathname.new("foo").cp("bar") #calls FileUtils.cp("foo","bar")
+    SH::Pathname.new("foo/").on_cp("bar","baz") #copy 'bar' and 'baz' to 'foo/'
+    SH::Pathname.new("foo").on_rm(mode: :dangling_symlink) #remove 'foo' only if it is a dangling symlink
+    SH::Pathname.new("foo").squel("bar/baz", action: :on_ln_s) #create a symlink foo/bar/baz -> ../../bar/baz
+
+    #Symlink all files in a directory into another, while preserving the structure
+    SH::Pathname.new("foo").squel_dir("bar',action: :on_ln_s)
+    #Remove these symlinks
+    SH::Pathname.new("foo").squel_dir("bar") {|o,t| o.on_rm(mode: :symlink)} 
+
+## Warning
+
+  For now the API is experimental and some parts are not ready to use!
+
 ## Install
 
     $ gem install shell_helpers
 
 ## Copyright
 
-Copyright (c) 2015 Damien Robert
+Copyright © 2015–2018 Damien Robert
 
 MIT License. See {file:LICENSE.txt} for details.
 

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/TODO

@@ -0,0 +1,2 @@
+Integrate ptools?
+https://github.com/djberg96/ptools

data/bin/abs_to_rel.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'shell_helpers/pathname'
+require 'shell_helpers/options'
+
+opts = Slop.parse(ARGV) do |o|
+	o.bool "-v", "--verbose", "verbose"
+	o.bool "-t", "--test", "test"
+	o.symbol "-m", "--mode", "Conversion mode", default: :rel
+	o.string "-b", "--base", "Assume symlinks are relative to this base"
+	o.symbol "--base-mode", "Base conversion mode", default: :abs_realdir
+	o.on '--help' do
+		puts o
+		exit
+	end
+end
+
+pathname=ShellHelpers::Pathname
+if opts[:verbose] and opts[:test]
+	pathname=ShellHelpers::Pathname::DryRun
+elsif opts[:verbose] and !opts[:test]
+	pathname=ShellHelpers::Pathname::Verbose
+elsif opts[:test]
+	pathname=ShellHelpers::Pathname::NoWrite
+end
+
+opts.args.each do |l|
+	l=pathname.new(l)
+	if l.symlink?
+		base=(opts[:base]||l.dirname).convert_path(mode: opts[:'base-mode'])
+		oldpath=l.readlink
+		newpath=l.rel_path_to(oldpath, base: base, mode: opts[:mode])
+		if oldpath != newpath
+			puts "#{l}: #{oldpath} -> #{newpath}" if opts[:verbose]
+			l.on_ln_sf(newpath, dereference: :none) 
+		else
+			puts "#{l}: #{newpath}" if opts[:verbose]
+		end
+	else
+		puts "! #{l} is not a symlink" if opts[:verbose]
+	end
+end

data/bin/mv_and_ln.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'shell_helpers/pathname'
+require 'shell_helpers/options'
+
+opts = Slop.parse(ARGV) do |o|
+	o.bool "-v", "--verbose", "verbose"
+	o.int "--verbose-level", "verbose level"
+	o.bool "-t", "--test", "test"
+	o.symbol "-m", "--mode", "Conversion mode", default: :rel
+	o.symbol "--rm", "rm options", default: :noclobber
+	o.symbol "--dereference-mode", "dereference mode for dest"
+	o.bool "-L", "--dereference", "dereference dest"
+	o.bool "-f", "--force", "force remove"
+	o.on '--help' do
+		puts o
+		exit
+	end
+end
+
+if opts[:force]
+	opts[:rm] ||= :all
+else
+	opts[:rm] ||= :noclobber
+end
+#dereference-mode can also take the values 'simple' and 'none'
+opts[:"dereference-mode"] ||= opts[:dereference]
+
+pathname=ShellHelpers::Pathname
+if opts[:verbose] and opts[:test]
+	pathname=ShellHelpers::Pathname::DryRun
+elsif opts[:verbose] and !opts[:test]
+	pathname=ShellHelpers::Pathname::Verbose
+elsif opts[:test]
+	pathname=ShellHelpers::Pathname::NoWrite
+end
+
+*args,dest=opts.args
+dest=pathname.new(dest)
+if args.empty?
+	warn "You should specify at least two arguments"
+	exit 1
+end
+if args.length > 1 and !dest.directory?
+	warn "When specifying more than one target, dest should be a directory"
+	exit 1
+end
+args.each do |f|
+	f=pathname.new(f)
+	t=dest.directory? ? dest+f.basename : dest
+	t=f.rel_path_to(t, mode: opts[:mode])
+	puts "#{f} -> #{t}" if opts[:verbose]
+	dest.on_mv(f, mode: opts[:rm], verbose: opts[:verbose], dereference: opts[:"dereference-mode"]) and f.on_ln_s(t, verbose: opts[:verbose])
+end

data/gemspec.yml

@@ -8,8 +8,9 @@ email: Damien.Olivier.Robert+gems@gmail.com
 homepage: https://github.com/DamienRobert/shell_helpers#readme
 
 dependencies:
-  drain: ~> 0.1
+  drain: ~> 0.2
 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/shell_helpers.rb

@@ -1,20 +1,28 @@
 require 'shell_helpers/version'
 
-require 'shellwords'; require 'pathname'; require 'fileutils'
-require 'dr/ruby_ext/core_ext'; require 'dr/ruby_ext/pathname_ext'
+require 'fileutils'
+#require 'dr/ruby_ext/core_ext'
 #load everything in shell_helpers/*.rb
-dir=File.expand_path(File.basename(__FILE__).chomp('.rb'), File.dirname(__FILE__))
-Dir.glob(File.expand_path('*.rb',dir)) do |file|
-	require file
-end
+#dir=File.expand_path(File.basename(__FILE__).chomp('.rb'), File.dirname(__FILE__))
+#Dir.glob(File.expand_path('*.rb',dir)) do |file|
+#	require file
+#end
+require 'shell_helpers/logger'
+require 'shell_helpers/run'
+require 'shell_helpers/sh'
+require 'shell_helpers/utils'
+require 'shell_helpers/sysutils'
+require 'shell_helpers/export'
+require 'shell_helpers/pathname'
 
-module SH
+module ShellHelpers
 	include Run #run_command, run_output, run_status, run
 	include CLILogging #logger.{debug info warn error fatal}, log_and_do
 	include ExitNow #exit_now!
 	include Sh #sh, sh!
-	include ShellExport #export
-	include ShellUtils #find, run_pager
+	include Export #export
+	include Utils #find, run_pager, rsync...
+	include SysUtils #mount, find_devices...
 	extend self
 	#activates debug mode
 	def self.debug(level=Logger::DEBUG)
@@ -22,11 +30,30 @@ module SH
 		Pathname.send(:include, CLILogging)
 		logger.level=(level)
 	end
-	#including SH::FU to add FileUtils
+	#include SH::FU to add FileUtils
 	module FU
 		include ::FileUtils
-		include ::SH
+		include ::ShellHelpers
 		extend self
 	end
+
+	# #include LogHelper to set up CLILogging with some convenience facilities
+	# module LogHelper
+	# 	include CLILogging
+	# 	CLILogging.logger.progname||=$0
+	# 	# #Activates Sh.sh in klass
+	# 	# def self.included(klass)
+	# 	# 	klass.const_set(:Sh,ShellHelpers::Sh)
+	# 	# end
+	# end
 end
 
+#for the lazy
+SH=ShellHelpers
+
+## # SHLog.sh to get logging
+## module SHLog
+## 	include ShellHelpers
+## 	include ShellHelpers::ShLog
+## end
+

data/lib/shell_helpers/export.rb

@@ -0,0 +1,169 @@
+require 'dr/ruby_ext/core_ext' #for Hash#keyed_value
+require 'dr/parse/simple_parser'
+
+module ShellHelpers
+	module Export
+		extend self
+		ImportError=Class.new(StandardError)
+		ExportError=Class.new(StandardError)
+
+		#export a value for SHELL consumption
+		def export_value(v)
+			case v
+				when String
+					return v.shellescape
+				when Array
+					return "(#{v.map {|i| i.to_s.shellescape}.join(' ')})"
+				when Hash
+					return "(#{v.map {|k,v| k.to_s.shellescape+" "+v.to_s.shellescape}.join(' ')})"
+				when nil
+					return ""
+				when ->(x){x.respond_to?(:to_a)}
+					return export_value(v.to_a)
+				when ->(x){x.respond_to?(:to_h)}
+					return export_value(v.to_h)
+				else
+					return v.to_s.shellescape
+			end
+		end
+		def import_value(v, type: String, unquote: true)
+			#String === String => false
+			case type.to_s
+			when "String"
+				v.gsub!(/\A['"]+|['"]+\Z/, "") if unquote
+				v.to_s
+			when "Integer"
+				v.to_i
+			when "Symbol"
+				v.to_sym
+			when "Array"
+				#v is of the form (ploum plam)
+				#TODO: handle quotes in the array
+				eval "%w#{v}"
+			when "Hash"
+				import_value(v, type: Array).each_slice(2).to_h
+			end
+		end
+
+		def escape_name(name, prefix:"", upcase: true)
+			name=name.to_s
+			name=name.upcase if upcase
+			(prefix+name).gsub('/','_')
+		end
+
+		#export_variable("ploum","plam") yields ploum="plam"
+		def export_variable(name, value, local: false, export: false, prefix:"",upcase:true)
+			r=""
+			name=escape_name(name,prefix:prefix,upcase:upcase)
+			r+="local #{name}\n" if local
+			r+="typeset -A #{name}\n" if Hash === value
+			r+="#{name}=#{export_value(value)}\n"
+			r+="export #{name}\n" if export
+			return r
+		end
+
+		def import_variable(namevalue, downcase:true, type: :auto)
+			namevalue.match(/(local|export)?\s*(\S*)=(.*)$/) do |m|
+				_match,_type,name,value=m.to_a
+				name=name.downcase if downcase
+				if type == :auto
+					if value=~/^\(.*\)$/
+						value=import_value(value, type: Array)
+					else
+						value=import_value(value)
+					end
+				else
+					value=import_value(value, type: type)
+				end
+				return name, value
+			end
+		end
+
+		#from {ploum: plim} return something like
+		#PLOUM=plim
+		#that can be evaluated by the shell
+		def export_variables(hash, local: false, export: false, prefix:"",upcase:true)
+			names=hash.keys.map {|s| escape_name(s,prefix:prefix,upcase:upcase)}
+			r=""
+			r+="local #{names.join(" ")}\n" if local
+			hash.each do |k,v|
+				r+=export_variable(k,v,prefix:prefix,upcase:upcase)
+			end
+			r+="export #{names.join(" ")}\n" if export
+			return r
+		end
+
+		#export_parse(hash,"name:value")
+		#will output name=$(hash[value])
+		#special cases: when value = '/' we return the full hash
+		#		when value ends by /, we return the splitted hash (and name serves
+		#		as a prefix)
+		#Ex: Numenor ~ $ ./mine/00COMPUTERS.rb --export=//
+		#		 HOSTNAME=Numenor;
+		#		 HOSTTYPE=perso;
+		#		 HOMEPATH=/home/dams;...
+		#		 Numenor ~ $ ./mine/00COMPUTERS.rb --export=syst/
+		#		 LAPTOP=true;
+		#		 ARCH=i686;...
+		#Remark: in name:value, we don't put name in uppercase
+		#But in split hash mode, we put the keys in uppercase (to prevent collisions)
+		def export_parse(hash,s)
+			r=""
+			args=DR::SimpleParser.parse_string(s.to_s)
+			args[:values].each do |k,v|
+				if v
+					name=k.to_s
+				else
+					#no name given
+					v=k.to_s
+					if v !='/' && v[-1]=='/'
+						#in split mode we don't need the name
+						name="" 
+					else
+						#else since no name was given we reuse the variable
+						name=v
+						name="all" if v=="/"
+					end
+				end
+				if v != '/' && v[-1]=='/'
+					all=true
+					v=v[0...-1]
+				end
+				value=hash.keyed_value(v)
+				opts=args[:opts][k]
+				if all
+					r+=export_variables(value, prefix: name, **opts)
+				else
+					r+=export_variable(name,value, **opts)
+				end
+			end
+			return r
+		end
+
+		def import_parse(s, split_on: :auto, var_separator:'/', inline: false)
+			r={}
+			if split_on == :auto
+				split_on=","
+				split_on="\n" if s =~ /\n/
+			end
+			if s.is_a?(Enumerable)
+				instructions=s
+			else
+				instructions=s.split(split_on)
+			end
+			instructions.each do |namevalue|
+				if inline
+					name,value=DR::SimpleParser.parse_namevalue(optvalue,sep:'=')
+				else
+					name,value=import_variable(namevalue)
+				end
+				if name
+					r.set_keyed_value(name,value, sep: var_separator)
+				else
+					raise ImportError.new("Cannot parse #{s}")
+				end
+			end
+			r
+		end
+	end
+end