patheditor 1.1.0-x86-mswin32-60

data/README.txt

@@ -0,0 +1,74 @@
+= PathEditor
+
+Anyone who's had to change their Windows PATH environment variable more than once in a week knows it's a frustrating and error prone process.
+
+This command line utility intends to fix that. It allows you to view, add, or remove paths from the PATH variable. It will also clean the variable of directorries that no longer exist. It's even smart enough to expand system variables such as %SystemRoot% when cleaning the path.
+
+When the path is modified, all system processes are notified immediately. Not all programs will respond to the notification, but the current shell and future shells opened from the Start | Run box will. 
+
+= Usage
+
+For help, just type
+
+  path_editor --help
+  
+To list the current path settings, just run the program without any arguments:
+
+  path_editor
+
+== Adding a Path
+
+To add a directory to the path:
+
+  path_editor --add "full path" --no-test
+
+Note, because of the way the Windows shell works, if you wish to add a path with a trailing slash, you must use a double slash at the end:
+
+  path_editor --add "c:\program files\\" --no-test
+  
+If the path already given already exists, it will not be added again.
+
+== Removing a path
+
+To remove a directory from the path:
+
+  path_editor --remove "full path"
+  
+Limited regular expressions can be used - essentially "*" or "?", like filename wild cards. If more than one path matches the expression given, you will be asked for confirmation before the path variable is updated.
+
+== Cleaning the Path
+
+To clean your path:
+
+  path_editor --clean
+  
+This process will remove directories which no longer exist, and will remove any duplicate directories from the path. 
+
+= Acknowledgements
+
+Of course, my thanks to Matz for creating Ruby. What a joy it is to program in. I'm also indebted to the fine coders of the "commandline" and "highline" libraries. Finally, my thanks to the King of Kings, Jesus Christ, for the gift of this life. Amen.
+
+= LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Justin Bailey
+
+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/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+	s.name = "patheditor"
+	s.summary = "A simple program to manage the Windows PATH environment variable."
+	s.version = "1.1.0"
+	s.author = "Justin Bailey"
+	s.email = "jgbailey@nospam@gmail.com"
+	s.homepage = "http://rubyforge.org/projects/patheditor/"
+	s.rubyforge_project = "http://rubyforge.org/projects/patheditor/"
+	
+	s.description = <<EOS
+This gem provides an application, path_editor, which makes it easy to add, remove, display or clean up the
+Windows System and User PATH variables. Note this does NOT any transient variables active in the current process -
+it only affects those which are stored in the registry and set before each process begins. It's a nice
+alternative to using "Computer / Properties / Advanced" for updating environment variables.
+EOS
+
+	s.platform = Gem::Platform::CURRENT
+	s.files = FileList["lib/**/*", "test/**/*", "*.txt", "Rakefile"].to_a
+
+	s.bindir = "bin"
+	s.executables = ["path_editor"]
+	s.require_path = "lib"
+
+	s.has_rdoc = true
+	s.extra_rdoc_files = ["README.txt"]
+	s.rdoc_options << '--title' << 'PathEditor -- A PATH environment variable editor' <<
+                       '--main' << 'README.txt' <<
+                       '--line-numbers'
+
+	s.add_dependency("highline", ">= 1.2.3")
+	s.add_dependency("commandline", ">= 0.7.10")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+end

data/bin/path_editor

@@ -0,0 +1,133 @@
+# A simple application for editing the environment's path information.
+require 'rubygems'
+require 'highline'
+require 'commandline'
+require 'pathname'
+
+$: << (Pathname.new(__FILE__).dirname + '..\lib') unless $:.include?(Pathname.new(__FILE__).dirname + '..\lib')
+require 'windows_path'
+
+class App < CommandLine::Application
+  def initialize
+    synopsis "[[-c, --clean] [-a, --add PATH] [r, --remove EXPR]] [--case-sensitive] [-n, --no-confirmation] [-h, --help]"
+    short_description <<-EOS
+With no arguments, displays the current path, broken into separate entries. Arguments allow directories to be added to or removed from the path. The path can also be cleaned of directories which no longer exist."
+    EOS
+    
+    long_description <<-EOS
+A script for manipulating the environment's PATH variable. Editing this variable is a huge pain in Windows - this script aims to make it easier.    
+    EOS
+    
+    option :names => %w(-c --clean), :arity => 0, 
+      :opt_found => proc { |opt, user_option, opt_args|
+        @clean = true
+      },
+      :opt_description => <<-EOS
+Cleans directories which no longer exist from the path, and removes any duplicate directories.
+      EOS
+
+    option :names => %w(-a --add), :arity => 1, :arg_description => "path", 
+      :opt_found => proc { |opt, user_option, opt_args|
+        @add = Pathname.new opt_args.first
+      },
+      :opt_description => <<-EOS
+Adds the given path to the PATH environment variable. If the path already exists (in the exact form given), it will not be added.
+      EOS
+
+    option :names => %w(-r --remove), :arity => 1, :arg_description => "expression",
+      :opt_found => proc { |opt, user_option, opt_args|
+        @remove = opt_args.first
+      },
+      :opt_description => <<-EOS
+Removes the given path from the environment variable. Special characters such as "?" and "*" will be treated
+as wildcards, just like at the command line. Be sure to enclose the expression in quotes, or the command prompt will
+attempt to expand them for you. Note also that the command prompt seems to switch "\" characters to "/", so matches
+with those characters will appear odd.
+      EOS
+
+    option :names => %w(--case-sensitive), :arity => 0,
+      :opt_found => proc { |opt, user_option, opt_args|
+        @case_sensitive = true
+      },
+      :opt_description => <<-EOS
+Makes path comparisons case-sensitive if present. Path comparisons are case-insensitive otherwise.
+      EOS
+      
+    option :names => %w(-n --no-confirmation), :arity => 0,
+      :opt_found => proc { @confirm_disabled = true},
+      :opt_description => <<-EOS
+Forces changes to occur with confirmation. True by default unless paths are being removed with a regular expression and more than one path is matched - then it is false. This is intended to prevent the accidental remove of all paths or a similar disaster.
+      EOS
+      
+      option :debug, :help
+  end
+
+  def main
+    @hl = HighLine.new
+    @currPath = WindowsPath.new
+    
+    if @clean || @add || @remove
+      if @clean
+				@currPath.clean do |path, reason|
+					case reason
+						when :dup
+							@hl.say "Removing #{path} (duplicate)" 						
+						when :notfound
+							@hl.say "Removing #{path} (doesn't exist)"						
+					end
+					
+					path_removed
+				end
+      end
+      
+      if @add
+        unless @currPath.paths.include?(@add)
+          @currPath.paths.add(@add)
+          @path_updated = true
+          @hl.say "Added #{@add} to path." 
+        else
+          @hl.say "#{@add} not added because it already exists in the path."
+        end
+      end
+      
+      if @remove
+        @currPath.remove(@remove) do |p| 
+					@hl.say "Removing path #{p}"
+					path_removed
+        end
+      end
+
+      if @path_updated
+        if confirmation_needed? 
+					@currPath.update if @hl.agree("Would you like to commit the changes made? [Yn] ", true)
+        else
+          @currPath.update
+        end
+      end
+    else
+      # Print path
+      @hl.say "Current path entries:" 
+      @currPath.paths.each { |p| @hl.say "\t#{p}" } 
+    end
+  rescue 
+    puts "Exception: #{$!.message}"
+    puts $!.backtrace.join("\n")
+  end
+  
+  def confirmation_needed?
+		# No need to confirm if either the user specified no confirmation explicitly, or
+		# the automatic confirmation never got set.
+		(@automatic_confirm && ! @confirm_disabled) || false
+  end
+  
+  # Records that a path was removed
+  def path_removed
+		@path_updated = true
+		# first time through, @paths_removed is false. Automatic confimration
+		# should happen with more than one directory, therefore this will succeed.
+    @automatic_confirm = true if @paths_removed  
+    @paths_removed = true
+  end
+end
+
+App.run unless $0 == __FILE__

data/lib/windows_path.rb

@@ -0,0 +1,167 @@
+require 'win32ole'
+require 'pathname'
+
+# Specialized array that knows how to compare paths.
+class WindowsPathArray < Array
+	
+	def include?(path)
+    # Compare paths case-insensitive, and also checking
+    # trailing separators (so c:\program files == c:\program files\)
+    self.any? { |p| compare_paths(path, p) }
+	end
+
+	def compare_paths(left, right)
+    left = Pathname.new(WindowsPath.expand_vars(left.to_s).downcase).cleanpath
+    right = Pathname.new(WindowsPath.expand_vars(right.to_s).downcase).cleanpath
+    
+    return left.eql?(right)
+  end
+
+  def <<(p)
+    super(p.to_s)
+  end
+	
+  alias_method :add, :<<
+
+	def delete(path)
+		self.delete_if { |p| compare_paths(path, p) }
+	end
+	
+	def each
+		for i in 0..size - 1
+			yield WindowsPath.expand_vars(raw_item(i))
+		end
+	end
+	
+	# Preserve access to base class definition of []
+	alias_method :raw_item, :[]
+	
+	def [](idx)
+		WindowsPath.expand_vars(super)
+	end
+end
+
+# Manages access to and updating of windows path setting. 
+class WindowsPath
+  include Enumerable
+  FILE_SEPARATOR = File::ALT_SEPARATOR
+	
+	# paths is a WindowsPathArray holding all paths in the system.
+	attr_accessor :paths
+
+	# Holds a reference to the Win32 Shell COM object.
+	def self.shell
+    @shell ||= WIN32OLE.new("WScript.Shell")
+	end
+
+	# Given a path, expands any environment variables found in it.
+	# Returns the expanded path.
+	def self.expand_vars(path)
+    while m = path.match(/%.*?%/)
+      path = path.gsub(m[0], shell.ExpandEnvironmentStrings(m[0]))
+    end
+		
+    path
+  end
+	
+  def initialize
+		@source = Hash.new
+    @paths = WindowsPathArray.new
+		@system = WindowsPath.shell.Environment("System")
+		@user = WindowsPath.shell.Environment("User")
+		
+		[@system, @user].each do |which|
+			which.Item("Path").split(";").each do |p|
+				@paths.add(p.strip)
+				source[p] = which
+			end
+		end
+  end
+  
+  # Update any changes 
+  def update
+		# Map paths back to origina environment object
+		env = Hash.new
+		
+		@paths.each do |p|
+			o = (source[p] || @user)
+			env[o] ||= []
+			env[o] << p
+		end
+
+		# Update each source object
+		env.each { |o, p| o["Item", "Path"] = p.join(";") }
+  end
+	
+	# Cleans the current path of any non-existent or duplicate directories.
+	# If a block is given, yields each directory removed along with a
+	# the symbol :dup or :notfound. 
+	def clean # :yields: path, reason
+		nonexistent = []
+		found = WindowsPathArray.new
+		duplicates = []
+		idx = 0 
+    @paths.each do |p| 
+      pathname = Pathname.new(p).cleanpath
+			if ! pathname.exist? 
+				nonexistent << p  
+			elsif found.include?(pathname)
+				duplicates << idx
+			else
+				found << pathname
+			end
+			idx += 1
+    end
+
+		unless duplicates.empty?
+			remove_paths(duplicates) { |p| yield p, :dup if block_given? } 
+		end
+
+		unless nonexistent.empty?					
+			remove_paths(nonexistent) { |p|  yield p, :notfound if block_given? } 
+		end
+	end
+	
+	# Removes paths matching the path given. If path is regular
+	# expression, it is matched directly. Any other
+	# pattern is treated as a potential shell "glob" 
+	# match, which means "*" and "?" are treated 
+	# specially. 
+	#
+	# In all cases, the path(s) removed are yielded.
+	def remove(pattern) # :yields: path
+		paths_to_remove = []
+		@paths.each do |p|
+			if pattern.is_a?(Regexp)
+				paths_to_remove << p if pattern.match(p)
+			else
+				paths_to_remove << p if File.fnmatch(pattern, p, File::FNM_CASEFOLD | File::FNM_NOESCAPE)
+			end
+		end
+		
+		paths_to_remove.each do |p|
+			yield p if block_given?
+			@paths.delete(p)
+		end
+	end
+
+private
+
+	attr_accessor :source
+	
+  def remove_paths(paths_to_remove)
+		adjust = 0
+    paths_to_remove.each do |p| 
+			if p.is_a?(Fixnum)
+				idx = p - adjust # adjust index based on paths removed so far.
+				yield @paths[idx] if block_given?
+				@paths.delete_at(idx)
+			else
+				yield p if block_given?
+				@paths.delete p
+      end
+      
+      adjust += 1
+    end
+  end
+end

data/test/test_windows_path.rb

@@ -0,0 +1,128 @@
+require 'test/unit'
+$:.unshift File.dirname(__FILE__) + "/../lib" unless $:.include?(File.dirname(__FILE__) + "../lib")
+require 'windows_path'
+
+class WindowsPathTests < Test::Unit::TestCase
+	
+	def setup
+		@path = WindowsPath.new
+	end
+	
+	def test_clean
+		# add some non-existent directories
+		fake = add_fake
+		
+		assert_dir_found fake, "Fake directory not added to current path."
+		@path.clean
+		assert_dir_not_found fake, "Fake directory found in current path after cleaning!"
+	end
+	
+	def test_clean_dups
+		fake = add_fake_dup
+
+		assert_dir_found fake, "Duplicate directory not found in path."
+		assert_dup_found fake, "Did not find the right number of duplicates directories in the path."
+		
+		@path.clean
+		assert_dir_not_found fake, "Duplicate directory found in current path after cleaning!"
+	end
+	
+	def test_clean_and_notfound
+		fake_dup = add_fake_dup
+		fake_not_found = add_fake
+
+		assert_dup_found fake_dup, "Did not find the right number of duplicates directories in the path."
+		assert_dir_found fake_not_found, "Nonexistent directory not found in path."
+
+		@path.clean
+		assert_dir_not_found fake_dup, "Duplicate directory found in current path after cleaning!"
+		assert_dir_not_found fake_not_found, "Nonexistent directory found in current path after cleaning!"
+	end
+	
+	def test_remove_dir
+		fake_dir = add_fake
+		assert_dir_found fake_dir, "Fake directory not found in path."
+		@path.remove fake_dir
+		assert_dir_not_found fake_dir, "Fake directory found in path after removal."
+	end
+	
+	def test_remove_glob
+		fake_dir = add_fake
+		assert_dir_found fake_dir, "Fake directory not found in path."
+		fake_glob = fake_dir.chop << "*"
+		@path.remove fake_glob
+		assert_dir_not_found fake_dir, "Fake directory not removed by glob: #{fake_glob}"
+	end
+	
+	def test_remove_regexp
+		fake_dir = add_fake
+		assert_dir_found fake_dir, "Fake directory not found in path."
+		fake_regex = Regexp.new("^" << fake_dir.gsub('\\', '\\\\\\\\') << "$")
+		@path.remove fake_regex
+		assert_dir_not_found fake_dir, "Fake directory not removed by regex: #{fake_regex}"
+	end
+	
+	def test_remove_case_sensitive_glob
+		# Ensure matches with different case works.
+		fake_dir = add_fake "C:\\program files"
+		fake_glob = "C:\\PROGRAM*"
+		@path.remove fake_glob
+		assert_dir_not_found fake_dir, "Fake directory not removed by glob: #{fake_glob}"
+	end
+
+	def test_remove_glob_two_stars
+		# Test that a glob with wildcards on both ends works
+		fake_dir = add_fake "C:\\program files"
+		fake_glob = "*PROGRAM*"
+		@path.remove fake_glob
+		assert_dir_not_found fake_dir, "Fake directory not removed by glob: #{fake_glob}"
+	end
+
+	def test_remove_glob_single_char
+		# Test that a glob with question mark works
+		fake_dir = add_fake 
+		fake_glob = fake_dir.chop << "?"
+		@path.remove fake_glob
+		assert_dir_not_found fake_dir, "Fake directory not removed by glob: #{fake_glob}"
+	end
+
+	# Makes a directory guarnteed not to exist
+	def make_fake_dir(dir)
+		cnt = 1
+		fake_dir = dir
+		while @path.paths.include? fake_dir
+			fake_dir = dir << cnt
+			cnt += 1
+		end
+		
+		fake_dir
+	end
+
+	# Add a fake path	
+	def add_fake(base = "C:\\foobar")
+		@path.paths << fake = make_fake_dir(base)
+		fake
+	end
+	
+	# Add a duplicated fake path 
+	def add_fake_dup
+		fake = add_fake
+		@path.paths << fake
+		
+		fake
+	end
+	
+	def assert_dir_found(dir, msg)
+		assert @path.paths.include?(dir), msg
+	end
+		
+	def assert_dir_not_found(dir, msg)
+		assert ! @path.paths.include?(dir), msg
+	end
+	
+	def assert_dup_found(dir, msg)
+		cnt = 0
+		@path.paths.each { |p| cnt += 1 if p == dir }
+		assert cnt == 2, msg
+	end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: patheditor
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: x86-mswin32-60
+authors: 
+- Justin Bailey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: commandline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.10
+    version: 
+description: This gem provides an application, path_editor, which makes it easy to add, remove, display or clean up the Windows System and User PATH variables. Note this does NOT any transient variables active in the current process - it only affects those which are stored in the registry and set before each process begins. It's a nice alternative to using "Computer / Properties / Advanced" for updating environment variables.
+email: jgbailey@nospam@gmail.com
+executables: 
+- path_editor
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- lib/windows_path.rb
+- test/test_windows_path.rb
+- README.txt
+- Rakefile
+has_rdoc: true
+homepage: http://rubyforge.org/projects/patheditor/
+post_install_message: 
+rdoc_options: 
+- --title
+- PathEditor -- A PATH environment variable editor
+- --main
+- README.txt
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: http://rubyforge.org/projects/patheditor/
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple program to manage the Windows PATH environment variable.
+test_files: []
+