linen 0.5.0 → 0.6.0

data/lib/linen.rb

@@ -18,8 +18,8 @@ require 'string_extensions'
 
 
 module Linen
-	VERSION = "0.5.0"
-	SVNRev  = %q$Rev: 119 $
+	VERSION = "0.6.0"
+	SVNRev  = %q$Rev: 137 $
 
 
 	def self::plugins
@@ -38,7 +38,8 @@ end
 require 'linen/plugin_registry'
 require 'linen/plugin'
 require 'linen/argument'
-require 'linen/command'
+require 'linen/simple_command'
+require 'linen/two_phase_command'
 
 
 ### handlers

data/lib/linen/argument.rb

@@ -19,7 +19,19 @@ class Linen::Plugin::Argument
 	end
 
 
-	def process( value )
+	def process( value, opts_hash = IndifferentHash.new )
+		opts_hash[ :mode ] ||= :simple
+		
+		# if we're in edit mode, we need to take care of a couple of
+		# special cases before falling into the regular handling loop
+		if opts_hash[ :mode ] == :edit or opts_hash[ :mode ] == 'edit'
+			if value.empty? # means the user just hit enter.  Return nil to indicate the value should be left alone
+				return nil
+			elsif value =~ /^\s+$/ # user entered only spaces.  Empty string means "clear out previous value"
+				return ""
+			end
+		end
+		
 		raise Linen::Plugin::ArgumentError unless value =~ @regex
 		return value unless @process
 

data/lib/linen/exceptions.rb

@@ -38,4 +38,5 @@ class Linen::CLI::AmbiguousCommandError < Linen::CLI::AbstractAmbiguityError
 	end
 end
 
-class Linen::WorkspaceError < RuntimeError ; end
+class Linen::WorkspaceError < RuntimeError ; end
+class Linen::HandlerError   < RuntimeError ; end

data/lib/linen/handlers/cli.rb

@@ -58,6 +58,9 @@ class Linen::CLI < Linen::Handler
 		else
 			plugin, command, *args = canonicalize( input ).split
 
+			plugin  = Linen.plugins[ plugin ]
+			command = plugin.commands[ command ]
+
 			execute_command plugin, command, args
 		end
 	end
@@ -82,9 +85,9 @@ class Linen::CLI < Linen::Handler
 	private
 	#######
 	
-	# def self::say( input )
-	# 	puts input
-	# end
+	def self::say( input = "" )
+		puts input
+	end
 
 
 	def self::canonicalize( input )
@@ -108,10 +111,19 @@ class Linen::CLI < Linen::Handler
 
 
 	def self::execute_command( plugin, command, args )
-		plugin    = Linen.plugins[ plugin ]
-		command   = plugin.commands[ command ]
+		if command.is_a? Linen::Plugin::SimpleCommand
+			execute_simple_command plugin, command, args
+		elsif command.is_a? Linen::Plugin::TwoPhaseCommand
+			execute_two_phase_command plugin, command, args 
+		else
+			raise Linen::HandlerError, "Don't know how to execute a #{command.class}"
+		end
+	end
+	
+
+	def self::execute_simple_command( plugin, command, args )
 		workspace = Linen::Workspace.new
-		results   = command.validate_arguments( args )
+		workspace.add_values command.validate_arguments( args )
 
 		input = ''
 		if command.requires_confirmation?
@@ -133,10 +145,64 @@ class Linen::CLI < Linen::Handler
 			
 			return unless input =~ /^y/i
 		end
-		
-		workspace.add_values( results )
+
 		command.execute( workspace )
 	end
+	
+	
+	def self::execute_two_phase_command( plugin, command, args )
+		workspace = Linen::Workspace.new
+		
+		# the first argument will always be the lookup argument,
+		# so shift it off since we don't want it below
+		object = command.lookup_object( args.shift )
+		workspace.add_values object
+		
+		puts <<-END
+
+You will now be prompted to edit one or more fields.  To accept the
+current value, just hit enter.  To clear it, hit <space> and then
+enter. Otherwise, enter a new value.
+
+Current values
+--------------
+END
+		command.inspect( workspace )
+		puts # blank line for clarity
+
+		current_values = command.editable_attrs.inject( Hash.new ) {|hash, value|
+			hash[ value ] = object[ command.lookup_attr ].send( value )
+			hash 
+		}
+		
+		workspace.add_values current_values
+		workspace.add_values command.validate_arguments( args )
+		
+		input = ''
+		if command.requires_confirmation?
+			puts "\nRunning '#{plugin.short_name} #{command.name}' with arguments:"
+
+			puts results.map { |arg, value|
+				next unless value
+				
+				output = value
+				output = value.join( ', ' ) if value.is_a? Array
+				
+				"#{arg}: #{output}"
+			}.join( "\n" )
+
+			while input !~ /^(y|n)/i
+				input = Readline.readline( "\nContinue [y/N]? ")
+				input = "n" if input == ''
+			end
+			
+			return unless input =~ /^y/i
+		end
+		
+		puts
+		
+		command.execute( workspace )		
+	end
 
 
 	def self::reprompt( prompt = "Re-enter: " )

data/lib/linen/plugin.rb

@@ -69,10 +69,16 @@ class Linen::Plugin
 	end
 
 
-	def self::command( name, &block )
+	def self::command( name, hash = {}, &block )
 		@commands ||= IndifferentHash.new
 
-		@commands[ name ] = Command.new( self, name, &block )
+		if hash[ :lookup_first ]
+			command = TwoPhaseCommand.new( self, name, &block )
+		else
+			command = SimpleCommand.new( self, name, &block )
+		end
+
+		@commands[ name ] = command
 	end
 
 

data/lib/linen/{command.rb → simple_command.rb}

@@ -7,7 +7,7 @@
 #  * Ben Bleything <bbleything@laika.com>                    #
 ##############################################################
 
-class Linen::Plugin::Command
+class Linen::Plugin::SimpleCommand
 	attr_reader :name
 
 	def initialize( plugin, name, &block )

data/lib/linen/two_phase_command.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class Linen::Plugin::TwoPhaseCommand
+	attr_reader :name, :editable_attrs, :lookup_attr
+
+	def initialize( plugin, name, &block )
+		@plugin    = plugin
+		@name      = name
+		@arguments = []
+		@help_text = "No help for #{plugin.short_name} #{name}"
+
+		self.instance_eval &block
+	end
+
+
+	def execute( workspace = Linen::Workspace.new )
+		return workspace.instance_eval( &@action_proc )
+	end
+
+
+	def help
+		output = []
+
+		output << @help_text.wrap
+		output << nil # blank line
+
+		# this map turns our list of args into a list like this:
+		# <arg1> <arg2> <arg3> <arg4>...
+		arg_list = @arguments.map {|a| "<#{a.to_s}>"}.join( ' ' )
+
+		output << "Usage: #{@plugin.short_name} #{name} #{arg_list}"
+
+		return output.join( "\n" )
+	end
+
+
+	#############################
+	# PLUGIN DEFINITION METHODS #
+	#############################
+
+
+	# def one_of( *args )
+	# 	raise Linen::Plugin::ArgumentError,
+	# 		"You may not specify both required and one_of arguments" if @argument_type == :required
+	# 
+	# 	@argument_type = :one_of
+	# 
+	# 	args.each do |arg|
+	# 		raise Linen::Plugin::ArgumentError,
+	# 			"Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
+	# 
+	# 		@arguments << arg
+	# 	end
+	# end
+	# 
+	# 
+	# def required_arguments( *args )
+	# 	raise Linen::Plugin::ArgumentError,
+	# 		"You may not specify both required and one_of arguments" if @argument_type == :one_of
+	# 
+	# 	@argument_type = :required
+	# 
+	# 	args.each do |arg|
+	# 		raise Linen::Plugin::ArgumentError,
+	# 			"Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
+	# 
+	# 		@arguments << arg
+	# 	end
+	# end
+	# alias required_argument required_arguments
+
+	def lookup_by( attr_name, &block )
+		@lookup_attr  = attr_name
+		@lookup_block = block
+	end
+	
+	
+	def editable_attributes( *attr_list )
+		@editable_attrs = attr_list
+	end
+
+
+	def help_message( message )
+		@help_text = message
+	end
+
+
+	def action( &block )
+		@action_proc = block
+	end
+
+
+	def require_confirmation
+		@require_confirmation = true
+	end
+	
+	
+	def inspect( workspace = Linen::Workspace.new, &block )
+		if block_given?
+			@inspect_proc = block
+		else
+			return workspace.instance_eval( &@inspect_proc )
+		end
+	end
+
+
+	##################
+	# HELPER METHODS #
+	##################
+	
+	def lookup_object( input )
+		results = IndifferentHash.new
+		
+		argument  = @plugin.arguments[ @lookup_attr ]
+		arg_value = input
+		
+		begin
+			arg_value = Linen::CLI.reprompt( argument.prompt ) if arg_value.nil?
+
+			processed_argument = argument.process( arg_value )
+
+			results[ @lookup_attr ] = @lookup_block.call( processed_argument )
+		rescue Linen::Plugin::ArgumentError => e
+			# reset arg_value to nil so we get prompted on retry
+			arg_value = nil
+			
+			retry
+		end
+
+		return results
+	end
+	
+	### FIXME:bbleything
+	###
+	### The reprompting stuff below is going to come back to bite us when we try to
+	### add batch mode later... that said, in the interest of getting things out the
+	### door, we're going to leave it be for now.
+	def validate_arguments( args )
+		results = IndifferentHash.new
+		
+		@editable_attrs.each do |arg_name|
+			argument  = @plugin.arguments[ arg_name ]
+			arg_value = args.shift
+			
+			begin
+				arg_value = Linen::CLI.reprompt( argument.prompt ) if arg_value.nil?
+
+				result = argument.process( arg_value, :mode => :edit )
+				
+				if result.nil?
+					# user just hit enter; leave value as-is.  noop.
+				elsif result == ""
+					results[ arg_name ] = ''
+				else
+					results[ arg_name ] = result
+				end
+			rescue Linen::Plugin::ArgumentError => e
+				# reset arg_value to nil so we get prompted on retry
+				arg_value = nil ; retry
+			end
+			
+			return results
+		end
+	end
+
+
+	def requires_confirmation?
+		@require_confirmation
+	end
+end

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: linen
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.0
 date: 2007-09-10 00:00:00 -07:00
 summary: Linen - A pluggable command-line interface library
 require_paths: 
@@ -35,13 +35,14 @@ files:
 - lib/indifferent_hash.rb
 - lib/linen
 - lib/linen/argument.rb
-- lib/linen/command.rb
 - lib/linen/exceptions.rb
 - lib/linen/handler.rb
 - lib/linen/handlers
 - lib/linen/handlers/cli.rb
 - lib/linen/plugin.rb
 - lib/linen/plugin_registry.rb
+- lib/linen/simple_command.rb
+- lib/linen/two_phase_command.rb
 - lib/linen/workspace.rb
 - lib/linen.rb
 - lib/string_extensions.rb