mfe 1.1

data/bin/mfe

@@ -0,0 +1,37 @@
+#! /usr/bin/ruby
+# MFE the meta-frontend
+# Reducing clutter in ~/bin since 2005.
+# 
+# By Pete Elmore (1337p337@gmail.com)
+# http://debu.gs/mfe
+#
+# For licensing and copyright information, see the file LICENSE in doc/ .
+
+require 'rubygems'
+require 'mfe'
+
+# int main(int argc, char *argv[])
+include MFE
+cmdname = ARGV.shift
+case cmdname
+when nil
+	usage
+when '-h', /^-?-?help$/      # Help
+	usage $stdout
+when '-V', /^-?-?version$/   # Version info
+	puts version_string
+when CommandSig              # MFE mode
+	methname = MLook[ARGV.first]
+	unless methname
+		usage
+		exit 1
+	end
+	ARGV.shift
+	send methname, *ARGV
+else                         # Execution mode
+	exec_cmd(cmdname, *ARGV)
+	# exec_cmd() doesn't return unless there was an error.
+	exit 1
+end
+
+exit 0

data/doc/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2005-2006, 2008-2010, 2012 Peter Elmore (pete at debu dot gs)
+
+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/doc/README

@@ -0,0 +1,136 @@
+= MFE
+
+== Installation
+
+You can install via rubygems,
+
+  gem install mfe
+
+or plain old setup.rb:
+
+  ruby setup.rb install
+
+== How to use MFE
+
+MFE has two main modes:  command mode, and execution mode.
+
+=== Quick Version
+
+Here's the quick version of this README, because seriously, you're not going
+to read this until you get confused:
+
+  mfe - add say-hi echo hi
+  mfe say-hi
+  => hi
+  mfe - add say-whatever echo ARGS
+  mfe say-whatever it can be whatever
+  => it can be whatever
+  mfe - add argplay echo 'ARGEVAL[ arg.sub(/d/, "date"); ]' 'EVAL[(argv.map { |arg| arg.sub "date", `date`.chomp }).join " -- "]'
+  mfe argplay a s d f
+  => "a -- s -- Tue Sep 19 01:28:48 PDT 2006 -- f"
+
+Also, several variations of 'mfe -h', 'mfe --help', 'mfe help', etc., do what
+you expect.
+
+=== Command Mode
+
+In command mode, you can add, edit, remove, or otherwise manipulate the
+user-defined commands.  
+
+==== To add a new command
+
+  mfe - add cmdname command-and-args
+
+This is the format for adding a command to MFE.  The first argument to mfe is
+'-', the command character.  This signals to MFE that we will be running an
+MFE command, as opposed to executing a command we have defined.  After that
+comes 'add', the keyword that tells MFE which command to perform.  'cmdname'
+is the name given to the command.  It can be whatever you want, but must be
+legal as a filename.  The 'command-and-args' part is the command you actually
+want to run when you type 'mfe cmdname'.  As a more concrete example, have a
+look at this:
+
+  mfe - add hgr grep ARGS /usr/log/httpd.log
+
+Which creates a command named 'hgr' that greps /usr/log/httpd.log for whatever
+arguments you pass it:
+
+  mfe hgr -i googlebot
+
+Executing the previous command is equivalent to running
+
+  grep -i googlebot /usr/log/httpd.log
+
+As you might have guessed, ARGS is replaced by whatever arguments you pass
+when you execute the command.  There are two other special strings:  EVAL[]
+and ARGEVAL[].  EVAL[] is replaced with the value of the Ruby code inside the
+brackets.  The Ruby inside ARGVEVAL[] is evaluated once for each argument
+(bound to 'arg') and its value replaces the argument.  The variable 'argv' is
+exposed to both constructs.  A couple of examples should make it clearer:
+
+ mfe - add reverse-args echo 'ARGEVAL[ arg.reverse ]' ARGS
+ mfe reverse-args Hello, World.
+ => ,olleH .dlroW
+ mfe - add reverse-argv echo 'EVAL[ argv.reverse.join(" ") ]'
+ mfe reverse-argv Hello, World.
+ => World. Hello,
+ mfe - add reverse-both echo 'ARGEVAL[ arg.reverse ]' 'EVAL[ argv.reverse.join(" ") ]'
+ mfe reverse-both Hello, World.
+ => .dlroW ,olleH
+ mfe reverse-both $(mfe reverse-args $(mfe reverse-argv Hello, World.)) 
+ => Hello, World.
+
+==== To edit a command
+
+  mfe - edit cmdname
+
+This brings up the JSON representing the command in your editor.
+
+==== To remove a command
+
+Simply do
+
+  mfe - rm cmdname1 cmdname2
+
+==== To generate a shell script from a command
+
+  mfe - add echo-args echo ARGS
+  mfe - to-shell echo-args A S D F > echoargs.sh
+
+Or, a little more creatively,
+
+  mfe - to-shell useful-command | ssh user@host-without-ruby 'cat > bin/cmd'
+
+=== Execution Mode
+
+  mfe cmdname args
+
+Execution mode refers to the loading and evaluation of a command.  Execution
+mode is invoked by running mfe followed by the name of a command and
+(optionally) any arguments you wish to pass to it.  For example:
+
+Add a command,
+
+  mfe - add testcommand for i in ARGS; do indent \$i; done
+
+then execute it:
+
+  mfe testcommand *.c
+
+== Environment Variables
+
+There are two relevant environment variables:  MFE_HOME and MFE_COMMAND_SIG .
+MFE_HOME can be used to change the location of your MFE command directory
+(the default is ~/.mfe).  MFE_COMMAND_SIG changes the string used for
+signaling command mode (default '-').  For example,
+
+  MFE_HOME=/tmp/foo MFE_COMMAND_SIG=c_mode mfe c_mode add hi echo hi
+
+creates a command named 'hi' which executes 'echo hi', and places it in
+/tmp/foo/hi .  Note that the mfe home is created automatically, with
+permissions set to 0700.
+
+== Credits
+
+Pete Elmore -- (pete at debu dot gs)
+

data/lib/mfe-config.rb

@@ -0,0 +1,8 @@
+# This module houses a pile of constants for MFE.
+module MFEConfig
+	Authors = 'Pete Elmore'
+	Email = 'pete@debu.gs'
+	PkgName = 'mfe'
+	Version = '1.1'
+	URL = 'http://debu.gs/mfe'
+end

data/lib/mfe.rb

@@ -0,0 +1,260 @@
+# MFE the meta-frontend!
+#
+# Reducing clutter in ~/bin since 2005.  And, although it seems to have survived
+# several major revisions of Ruby without blinking, it finally needed
+# maintenance when the damned YAML parser changed.  It's JSON now; MFE was
+# written before JSON was cool.  In fact, it is so old there is no Rakefile, but
+# there is a _darcs.  Hopefully JSON will change less frequently and I won't
+# have to open this file again for another few years.
+#
+# By Pete Elmore (http://debu.gs/)
+#
+# For licensing and copyright information, see the file LICENSE in doc/ .
+
+%w(mfe-config fileutils json tempfile etc metaid escape
+).each(&method(:require))
+
+class String
+	def shell_escape
+		Escape.shell_single_word self
+	end
+end
+
+# This module houses the main logic for MFE.
+module MFE
+	# Method lookup table for commands
+	MLook = {
+		'add' => :add_cmd,
+		'edit' => :edit_json,
+		'show' => :show_cmd,
+		'to-shell' => :cmd_to_shell,
+		'rm' => :rm_cmd,
+		'remove' => :rm_cmd,
+	}
+	
+	# This is the character (or string) that indicates that we will be
+	# running an MFE command rather than loading and executing a
+	# user-defined command.
+	CommandSig = ENV['MFE_COMMAND_SIG'] || '-'
+
+	def dirnames
+		# Possible directories for housing mfe commands.
+		@dirnames ||= [ENV['MFE_HOME'],
+			(File.join(ENV['HOME'], '/.mfe') rescue nil),
+			File.join(Etc.getpwuid(Process.euid).dir, '/.mfe'),
+		].compact
+	end
+
+	# Loads a command with the given name
+	def load_cmd(name)
+		Cmd.load full_path(name)
+	end
+
+	# Loads and executes a command named by +name+ with args +argv+.
+	def exec_cmd(name, *argv)
+		begin
+			exec load_cmd(name).expand(argv)
+		rescue Errno::E2BIG
+			fp = full_path name
+			$stderr.puts "Couldn't execute #{name}!", "Argument list too long."
+		rescue Exception => e
+			fp = full_path name
+			$stderr.puts "Couldn't execute #{name}! (#{e.message})"
+
+			if !File.exist? fp
+				$stderr.puts 'File does not exist.'
+			elsif !File.readable? fp
+				$stderr.puts 'File is not readable.'
+			elsif File.directory? fp
+				$stderr.puts 'It\'s a directory.'
+			else
+				$stderr.puts e.inspect
+			end
+		end
+	end
+
+	# Given a list of command names, show_cmd will print what each one does.
+	# In the absense of a list of names, it will print all commands in the
+	# .mfe directory.
+	def show_cmd(*names)
+		if names.empty?
+			names = Dir["#{dirname}/*"] - %w(. ..)
+			names.map! &File.method(:basename)
+		end
+
+		names.sort.each { |name|
+			puts "#{name}:  #{load_cmd(name).to_s}"
+		}
+	end
+
+	# Given a name and a list of args, this method prints a shell script
+	# that would have the effect of running the command.
+	def cmd_to_shell(name, *argv)
+		cmd = load_cmd(name)
+		shell = [
+			`which ENV['SHELL'] 2>/dev/null`,
+			Etc.getpwuid(Process.uid).shell,
+			'/bin/sh',
+		].find { |shell| !shell.chomp.empty? }
+
+		puts("#!#{shell}", 
+			cmd.expand(argv))
+		true
+	end
+
+	# Removes commands!  :O
+	def rm_cmd(names)
+		names.each { |name|
+			File.unlink full_path(name)
+		}
+	end
+	
+	# Adds a new command.
+	def add_cmd(name, *cmd)
+		if cmd.empty?
+			cmd = edit_json(name)
+			return false if cmd.to_s.empty?
+		else
+			cmd = Cmd.new(name, cmd)
+		end
+		cmd.save(dirname!)
+	end
+
+	# Allows the user to directly edit the JSON representation of a command.
+	def edit_json(name, *argv)
+		system editor, full_path!(name)
+		$?.exited?
+	end
+
+	# Returns the first viable directory for the MFE directory.  If none is
+	# found, returns nil.  Otherwise, it's guaranteed to always return the 
+	# same value.
+	def dirname
+		dir = dirnames.find { |d| File.directory?(d) }
+		if dir
+			# It's important for this to be consistent (and faster anyway).
+			meta_def(:dirname) { dir }
+			return dir
+		end
+		nil
+	end
+
+	# Returns the dirname, but if it's nil, makes the directory with
+	# permissions 0700.
+	def dirname!
+		return dirname if dirname
+		Dir.mkdir(dirnames.first, 0700)
+		dirname
+	end
+
+	# Returns the user's (suspected) preferred editor.
+	def editor
+		ENV['VISUAL'] || 
+		ENV['EDITOR'] || 
+		'vi'  # Reasonable default.
+	end
+
+	# Returns the full path for a given command with name +name+.
+	def full_path(name)
+		File.join(dirname, name)
+	end
+
+	# Returns the full path for a given command with name +name+, and
+	# creates the path if it does not exist.
+	def full_path!(name)
+		fn = File.join(dirname!, name)
+		File.open(fn, 'a').close
+		fn
+	end
+
+	def usage(out = $stderr)
+		out.puts [ "",
+			"MFE, the meta front-end (#{MFEConfig::URL})",
+			"Usage:",
+			"#{$0} #{CommandSig} command [args ...]",
+			"    Where command is one of",
+			"        add name script [args ...]:",
+			"            Adds a command named 'name' that executes " +
+				"'script [args ...]'.",
+			"        show [name(s)]", 
+			"            Shows the command(s) named, or all commands if none " +
+				"are named.",
+			"        edit name",
+			"            Runs your favorite editor on the named command.",
+			"        to-shell name [args ...]",
+			"            Turns the user-defined command into a shell script.",
+			"#{$0} your_command [args ...]",
+			"    Runs the user-defined command named 'your_command' with the " +
+				"specified\n    arguments.",
+			"#{$0} ['-h'|'-help'|'--help']",
+			"    This help screen.",
+			"See the README for more info about usage and influential " +
+				"environment\nvariables.",
+		]
+	end
+
+	def version_string
+		"MFE, version #{MFEConfig::Version}."
+	end
+end
+
+# Represents an individual command
+class Cmd
+	attr_accessor :name
+
+	# Turns a filename into a command!  Amazing!  Pass the full path.
+	def self.load(filename)
+		obj = JSON.parse(File.read(filename))
+
+		new(File.basename(filename), obj['cmd'])
+	end
+
+	# +save+, saves the command to a file.
+	def save(dirname)
+		File.open(File.join(dirname, @name), 'w') { |f|
+			f.puts JSON.pretty_unparse(to_hash)
+		}
+	end
+
+	# Creates a new command.  
+	def initialize(name, cmd)
+		@name = name
+		@cmd = cmd
+	end
+
+	# +to_s+ simply returns the command string.
+	def to_s
+		@cmd.join(' ')
+	end
+
+	def to_hash
+		{name: @name, cmd: @cmd}
+	end
+
+	# Turns the command into a line of shell, fit to be exec()'d or ``'d.
+	def expand(argv)
+		argv = argv.map(&:shell_escape)
+		@cmd.map { |this_arg|
+			a = this_arg.dup
+			a.gsub!(/\bARGS\b/, argv.join(' '))
+			a.gsub!(/\bARGEVAL\[(.*)\]/) { |m|
+				argeval = $1
+				argv.map! { |frozen_arg|
+					arg = frozen_arg.dup
+					eval(argeval, binding).to_s
+				}
+				''
+			}
+			a.gsub!(/\bEVAL\[(.*)\]/) { |m|
+				eval($1, binding).to_s
+			}
+			a
+		}.join(' ')
+	end
+
+	# +run+ runs the command, returning the output.
+	def run(argv)
+		`#{expand argv}`
+	end
+end
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: mfe
+version: !ruby/object:Gem::Version
+  version: '1.1'
+  prerelease: 
+platform: ruby
+authors:
+- Pete Elmore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: metaid
+  requirement: &6886860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *6886860
+- !ruby/object:Gem::Dependency
+  name: escape
+  requirement: &8227460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *8227460
+description: 
+email: pete@debu.gs
+executables:
+- mfe
+extensions: []
+extra_rdoc_files:
+- doc/README
+- doc/LICENSE
+files:
+- bin/mfe
+- doc/LICENSE
+- doc/README
+- lib/mfe.rb
+- lib/mfe-config.rb
+homepage: http://debu.gs/mfe
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A program which remembers and executes brief scripts.
+test_files: []