filigree 0.3.0 → 0.3.1

data/lib/filigree/configuration.rb

@@ -20,7 +20,7 @@ require 'filigree/string'
 module Filigree
 	module Configuration
 		include ClassMethodsModule
-	
+
 		#############
 		# Constants #
 		#############
@@ -28,10 +28,10 @@ module Filigree
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# @return [Array<String>]  Remaining strings that weren't used in configuration
 		attr_accessor :rest
-		
+
 		# Dump the state of the Configuration object.  This will dump the
 		# state, encoded in YAML, to different destinations depending on the
 		# io parameter.
@@ -54,25 +54,25 @@ module Filigree
 		# @return [void]
 		def dump(io = nil, *fields)
 			require 'yaml'
-		
+
 			vals =
 			if fields.empty? then self.class.options_long.keys else fields end.inject(Hash.new) do |hash, field|
 				hash.tap { hash[field.to_s] = self.send(field) }
 			end
-		
+
 			case io
 			when nil
 				YAML.dump vals
-			
+
 			when String
 				File.open(io, 'w') { |file| YAML.dump vals, file }
-			
+
 			when IO
 				YAML.dump vals, io
 			end
 		end
 		alias :serialize :dump
-		
+
 		# Configures the object based on the overloaded parameter.
 		#
 		# @overload initialize(args)
@@ -89,28 +89,28 @@ module Filigree
 		# @return [void]
 		def initialize(overloaded = ARGV.clone)
 			set_opts = Array.new
-		
+
 			case overloaded
 			when Array
 				handle_array_options(overloaded, set_opts)
-			
+
 			when String, IO
 				handle_serialized_options(overloaded, set_opts)
 			end
-		
+
 			(self.class.options_long.keys - set_opts).each do |opt_name|
 				default = self.class.options_long[opt_name].default
 				default = self.instance_exec(&default) if default.is_a? Proc
-			
+
 				self.send("#{opt_name}=", default)
 			end
-		
+
 			# Check to make sure all the required options are set.
 			self.class.required_options.each do |option|
 				raise ArgumentError, "Option #{option} not set." if self.send(option).nil?
 			end
 		end
-		
+
 		# Find the appropriate option object given a string.
 		#
 		# @param [String]  str  Search string
@@ -119,49 +119,49 @@ module Filigree
 		def find_option(str)
 			if str[0,2] == '--'
 				self.class.options_long[str[2..-1]]
-			
+
 			elsif str[0,1] == '-'
 				self.class.options_short[str[1..-1]]
 			end
 		end
-		
+
 		# Configure the object from an array of strings.
 		#
 		# @param [Array<String>]  argv      String options
 		# @param [Array<String>]  set_opts  List of names of options already added
 		#
-		# @return [void] 
+		# @return [void]
 		def handle_array_options(argv, set_opts)
 			while str = argv.shift
-		
+
 				break if str == '--'
-			
+
 				if option = find_option(str)
 					args = argv.shift(option.arity == -1 ? argv.index { |str| str[0,1] == '-' } : option.arity)
-			
+
 					case option.handler
 					when Array
 						tmp = args.zip(option.handler).map { |arg, sym| arg.send sym }
 						self.send("#{option.long}=", (option.arity == 1 and tmp.length == 1) ? tmp.first : tmp)
-				
+
 					when Proc
 						self.send("#{option.long}=", self.instance_exec(*args, &option.handler))
 					end
-			
+
 					set_opts << option.long
 				end
 			end
-		
+
 			# Save the rest of the command line for later.
 			self.rest = argv
 		end
-		
+
 		# Configure the object from a serialization source.
 		#
 		# @param [String, IO]     overloaded  Serialization source
 		# @param [Array<String>]  set_opts    List of names of options already added
 		#
-		# @return [void] 
+		# @return [void]
 		def handle_serialized_options(overloaded, set_opts)
 			options =
 			if overloaded.is_a? String
@@ -173,33 +173,35 @@ module Filigree
 			else
 				YAML.load overloaded
 			end
-		
+
 			options.each do |option, val|
 				set_opts << option
 				self.send "#{option}=", val
 			end
 		end
-	
+
 		#################
 		# Class Methods #
 		#################
-	
+
 		module ClassMethods
 			# @return [Hash<String, Option>]  Hash of options with long names used as keys
 			attr_reader :options_long
 			# @return [Hash<String, Option>]  hash of options with short name used as keys
 			attr_reader :options_short
-			
+
 			# Add an option to the necessary data structures.
 			#
 			# @param [Option]  opt  Option to add
 			#
 			# @return [void]
 			def add_option(opt)
+				attr_accessor opt.long
+
 				@options_long[opt.long]   = opt
 				@options_short[opt.short] = opt unless opt.short.nil?
 			end
-			
+
 			# Define an automatic configuration variable.
 			#
 			# @param [Symbol]  name   Name of the configuration variable
@@ -209,7 +211,7 @@ module Filigree
 			def auto(name, &block)
 				define_method(name, &block)
 			end
-			
+
 			# Define a boolean option.  The variable will be set to true if
 			# the flag is seen and be false otherwise.
 			#
@@ -221,7 +223,7 @@ module Filigree
 				@next_default = false
 				option(long, short) { true }
 			end
-			
+
 			# Sets the default value for the next command.  If a block is
 			# provided it will be used.  If not, the val parameter will be.
 			#
@@ -232,7 +234,7 @@ module Filigree
 			def default(val = nil, &block)
 				@next_default = block ? block : val
 			end
-			
+
 			# Sets the help string for the next command.
 			#
 			# @param [String]  str  Command help string
@@ -241,20 +243,20 @@ module Filigree
 			def help(str)
 				@help_string = str
 			end
-			
+
 			# Install the instance class variables in the including class.
 			#
 			# @return [void]
 			def install_icvars
-				@help_string	= ''
-				@next_default	= nil
-				@next_required	= false
-				@options_long	= Hash.new
-				@options_short	= Hash.new
-				@required		= Array.new
-				@usage		= ''
+				@help_string   = ''
+				@next_default  = nil
+				@next_required = false
+				@options_long  = Hash.new
+				@options_short = Hash.new
+				@required      = Array.new
+				@usage         = ''
 			end
-			
+
 			# Define a new option.
 			#
 			# @param [String]         long         Long option name
@@ -264,23 +266,23 @@ module Filigree
 			#
 			# @return [void]
 			def option(long, short = nil, conversions: nil, &block)
-			
+
 				attr_accessor long.to_sym
-			
+
 				long  = long.to_s
 				short = short.to_s if short
-			
+
 				add_option Option.new(long, short, @help_string, @next_default,
-					                 conversions.nil? ? block : conversions)
-			
+					                  conversions.nil? ? block : conversions)
+
 				@required << long.to_sym if @next_required
-			
+
 				# Reset state between option declarations.
-				@help_string	= ''
-				@next_default	= nil
+				@help_string   = ''
+				@next_default  = nil
 				@next_required = false
 			end
-			
+
 			# Mark some options as required.  If no names are provided then
 			# the next option to be defined is required; if names are
 			# provided they are all marked as required.
@@ -295,12 +297,12 @@ module Filigree
 					@required += names
 				end
 			end
-			
+
 			# @return [Array<Symbol>]  Options that need to be marked as required
 			def required_options
 				@required
 			end
-			
+
 			# Define an option that takes a single string argument.
 			#
 			# @param [String]  long   Long option name
@@ -310,7 +312,7 @@ module Filigree
 			def string_option(long, short = nil)
 				option(long, short) { |str| str }
 			end
-			
+
 			# Add's a usage string to the entire configuration object.  If
 			# no string is provided the current usage string is returned.
 			#
@@ -318,22 +320,22 @@ module Filigree
 			#
 			# @return [String]  Current or new usage string
 			def usage(str = nil)
-				if str then @usage = str else @usage end 
+				if str then @usage = str else @usage end
 			end
-		
+
 			#############
 			# Callbacks #
 			#############
-		
+
 			def self.extended(klass)
 				klass.install_icvars
 			end
 		end
-	
+
 		#################
 		# Inner Classes #
 		#################
-		
+
 		# This class represents an option that can appear in the
 		# configuration.
 		class Option < Struct.new(:long, :short, :help, :default, :handler)
@@ -342,11 +344,11 @@ module Filigree
 			# @return [Fixnum]  Number of arguments the option takes
 			def arity
 				case self.handler
-				when Array	then self.handler.length
-				when Proc		then self.handler.arity 
+				when Array then self.handler.length
+				when Proc  then self.handler.arity
 				end
 			end
-			
+
 			# Print the option information out as a string.
 			#
 			# Layout:
@@ -362,14 +364,14 @@ module Filigree
 			def to_s(max_long, max_short, indent = 0)
 				segment_indent	= indent + max_long + max_short + 8
 				segmented_help = self.help.segment(segment_indent)
-			
+
 				if self.short
 					sprintf "#{' ' * indent}%-#{max_long + 3}s %-#{max_short + 1}s - %s", "--#{self.long},", '-' + self.short, segmented_help
 				else
 					sprintf "#{' ' * indent}%-#{max_long + max_short + 5}s - %s", '--' + self.long, segmented_help
 				end
 			end
-			
+
 			# Helper method used to print out information on a set of options.
 			#
 			# @param [Array<Option>]  options  Options to be printed
@@ -378,29 +380,29 @@ module Filigree
 			# @return [String]
 			def self.to_s(options, indent = 0)
 				lines = []
-				
+
 				max_long  = options.lazy.map { |opt| opt.long.length }.max
 				max_short = options.lazy.map(&:short).reject { |opt| opt.nil? }.map(&:length).max
-		
+
 				options.each do |opt|
 					lines << opt.to_s(max_long, max_short, indent)
 				end
-			
+
 				lines.join("\n")
 			end
 		end
-	
+
 		#######################
 		# Pre-defined Options #
 		#######################
-		
+
 		# The default help option.  This can be added to your class via
 		# add_option.
 		HELP_OPTION = Option.new('help', 'h', 'Prints this help message.', nil, Proc.new do
 			puts "Usage: #{self.class.usage}"
 			puts
 			puts 'Options:'
-		
+
 			options = self.class.options_long.values.sort { |a, b| a.long <=> b.long }
 			puts Option.to_s(options, 2)
 

data/lib/filigree/match.rb

@@ -43,7 +43,7 @@ class MatchError < RuntimeError; end
 # accidentally compare against a variable.  To bind to a name that is already
 # in scope you can use the {Filigree::MatchEnvironment#Bind} method.  In
 # addition, class and destructuring pattern results (see bellow) can be bound
-# to a variable by using the {Filigree::BasicPattern#as} method. 
+# to a variable by using the {Filigree::BasicPattern#as} method.
 
 # If you wish to match string patterns you may use regular expressions.  Any
 # object that isn't a string will fail to match against a regular expression.
@@ -55,7 +55,7 @@ class MatchError < RuntimeError; end
 # instance of that class.  If you wish to compare one regular expression to
 # another, or one class to another, you can force the comparison using the
 # {Filigree::MatchEnvironment#Literal} method.
-# 
+#
 # Destructuring patterns allow you to match against an instance of a class,
 # while simultaneously binding values stored inside the object to variables
 # in the context of the with block.  A class that is destructurable must
@@ -131,7 +131,7 @@ class MatchError < RuntimeError; end
 #        @a = a
 #        @b = b
 #      end
-#      
+#
 #      def destructure(_)
 #         [@a, @b]
 #      end
@@ -156,9 +156,9 @@ class MatchError < RuntimeError; end
 # @return [Object]  Result of evaluating the matched pattern's block
 def match(*objects, &block)
 	me = Filigree::MatchEnvironment.new
-	
+
 	me.instance_exec &block
-	
+
 	me.find_match(objects)
 end
 
@@ -167,11 +167,11 @@ end
 #######################
 
 module Filigree
-	
+
 	###########
 	# Methods #
 	###########
-	
+
 	# Wrap non-pattern objects in pattern objects so they can all be treated
 	# in the same way during pattern sorting and matching.
 	#
@@ -188,11 +188,11 @@ module Filigree
 			end
 		end
 	end
-	
+
 	#######################
 	# Modules and Classes #
 	#######################
-	
+
 	# A module indicating that an object may be destructured.  The including
 	# class must define the `destructure` instance method, which takes one
 	# argument specifying the number of pattern elements it is being matched
@@ -207,7 +207,7 @@ module Filigree
 			DestructuringPattern.new(self, Filigree::wrap_pattern_elements(pattern))
 		end
 	end
-	
+
 	# Match blocks are evaluated inside an instance of MatchEnvironment.
 	class MatchEnvironment
 		# Force binding to the given name
@@ -218,21 +218,21 @@ module Filigree
 		def Bind(name)
 			BindingPattern.new(name)
 		end
-		
+
 		# Force a literal comparison
 		#
 		# @param [Object]  obj  Object to test equality with
 		#
-		# @return [LiteralPattern] 
+		# @return [LiteralPattern]
 		def Literal(obj)
 			LiteralPattern.new(obj)
 		end
-		
+
 		def initialize
 			@patterns = Array.new
 			@deferred = Array.new
 		end
-		
+
 		# Find a match for the given objects among the defined patterns.
 		#
 		# @param [Array<Object>]  objects  Objects to be matched
@@ -242,15 +242,15 @@ module Filigree
 		# @raise [MatchError]  Raised if no pattern matches the objects
 		def find_match(objects)
 			@patterns.each do |pattern|
-				env = OpenStruct.new 
-			
+				env = OpenStruct.new
+
 				return pattern.(env, objects) if pattern.match?(objects, env)
 			end
-		
+
 			# If we didn't find anything we raise a MatchError.
 			raise MatchError
 		end
-		
+
 		# Define a pattern in this match call.
 		#
 		# @see match  Documentation on pattern matching
@@ -260,26 +260,26 @@ module Filigree
 		#
 		# @return [void]
 		def with(*pattern, &block)
-			guard = if pattern.last.is_a?(Proc) then pattern.pop end 
-			
+			guard = if pattern.last.is_a?(Proc) then pattern.pop end
+
 			pattern = Filigree::wrap_pattern_elements(pattern)
-			
+
 			@patterns << (mp = OuterPattern.new(pattern, guard, block))
-		
+
 			if block
 				@deferred.each { |pattern| pattern.block = block }
 				@deferred.clear
-			
+
 			else
 				@deferred << mp
 			end
 		end
 		alias :w :with
-	
+
 		#############
 		# Callbacks #
 		#############
-		
+
 		# Callback used to generate wildcard and binding patterns
 		def method_missing(name, *args)
 			if args.empty?
@@ -289,12 +289,12 @@ module Filigree
 			end
 		end
 	end
-	
+
 	# This class provides the basis for all match patterns.
 	class BasicPattern
 		extend  AbstractClass
 		include Comparable
-		
+
 		# Base implementation of bi-directional comparison for patterns.
 		#
 		# @param [BasicPattern]  other  Right-hand side of the comparison
@@ -302,9 +302,11 @@ module Filigree
 		# @return [Integer]  Value corresponding to less than, equal to, or
 		#   greater than the right-hand side pattern.
 		def <=>(other)
-			self.weight - other.weight
+			# This is performed in the non-intuitive order due to
+			# higher-priority patterns having lower weights.
+			other.weight - self.weight
 		end
-		
+
 		# Wraps this pattern in a {BindingPattern}, causing the object that
 		# this pattern matches to be bound to this name in the with block.
 		#
@@ -313,30 +315,30 @@ module Filigree
 			binding_pattern.tap { |bp| bp.pattern_elem = self }
 		end
 	end
-	
+
 	# A pattern that matches any object
 	class WildcardPattern < BasicPattern
 		include Singleton
-		
+
 		# Return true for any object and don't create any bindings.
 		#
 		# @return [true]
 		def match?(_, _)
 			true
 		end
-		
+
 		def weight
 			4
 		end
 	end
-	
+
 	# An abstract class that matches only a single object to a single pattern.
 	class SingleObjectPattern < BasicPattern
 		extend AbstractClass
-		
+
 		# @return [BasicPattern]
 		attr_reader :pattern_elem
-		
+
 		# Create a new pattern with a single element.
 		#
 		# @param [Object]  pattern_elem  Object representing the pattern
@@ -344,7 +346,7 @@ module Filigree
 			@pattern_elem = pattern_elem
 		end
 	end
-	
+
 	# A pattern for checking to see if an object is an instance of a given
 	# class.
 	class InstancePattern < SingleObjectPattern
@@ -361,10 +363,10 @@ module Filigree
 				else                                                         -1
 				end
 			else
-				super
+				super(other)
 			end
 		end
-		
+
 		# Test the object to see if the object is an instance of the given
 		# class.
 		#
@@ -374,12 +376,12 @@ module Filigree
 		def match?(object, _)
 			object.is_a?(@pattern_elem)
 		end
-		
+
 		def weight
 			3
 		end
 	end
-	
+
 	# A pattern that forces an equality comparison
 	class LiteralPattern < SingleObjectPattern
 		# Test the object for equality to the pattern element.
@@ -390,12 +392,12 @@ module Filigree
 		def match?(object, _)
 			object == @pattern_elem
 		end
-		
+
 		def weight
 			0
 		end
 	end
-	
+
 	# A pattern that tests a string against a regular expression.
 	class RegexpPattern < SingleObjectPattern
 		# Test the object to see if it matches the wrapped regular
@@ -410,18 +412,18 @@ module Filigree
 				env.send("match_data=", md) if match
 			end
 		end
-		
+
 		def weight
 			2
 		end
 	end
-	
+
 	# A pattern that binds a sub-pattern's matching object to a name in the
 	# binding environment.
 	class BindingPattern < SingleObjectPattern
-		
+
 		attr_writer :pattern_elem
-		
+
 		# Create a new binding pattern.
 		#
 		# @param  [Symbol]  name          Name to bind to
@@ -430,12 +432,12 @@ module Filigree
 			@name = name
 			super(pattern_elem)
 		end
-		
+
 		# Overridden method to prevent binding BindingPattern objects.
 		def as(_, _)
 			raise 'Binding a BindingPattern is not allowed.'
 		end
-		
+
 		# Test the object for equality to the pattern element.  Binds the
 		# object to the binding pattern's name if it does match.
 		#
@@ -446,26 +448,26 @@ module Filigree
 		def match?(object, env)
 			@pattern_elem.match?(object, env).tap { |match| env.send("#{@name}=", object) if match }
 		end
-		
+
 		def weight
 			@pattern_elem.weight
 		end
 	end
-	
+
 	# An abstract class that matches multiple objects to multiple patterns.
 	class MultipleObjectPattern < BasicPattern
 		extend AbstractClass
-		
+
 		# @return [Array<BasicPattern>]
 		attr_reader :pattern
-		
+
 		# Create a new pattern with multiple elements.
 		#
 		# @param [Array<Object>]  pattern  Array of pattern elements
 		def initialize(pattern)
 			@pattern = pattern
 		end
-		
+
 		# A wrapper method to sort MultipleObjectPattern objects by their
 		# arity.
 		#
@@ -480,7 +482,7 @@ module Filigree
 				self.pattern.length - other.pattern.length
 			end
 		end
-		
+
 		# Test multiple objects against multiple pattern elements.
 		#
 		# @param [Object]  objects  Object to test pattern against
@@ -491,20 +493,20 @@ module Filigree
 				@pattern.zip(objects).each do |pattern_elem, object|
 					return false unless pattern_elem.match?(object, env)
 				end
-			
+
 				true
-			
+
 			else
 				(@pattern.length == 1 and @pattern.first == WildcardPattern.instance)
 			end
 		end
 	end
-	
+
 	# The class that contains all of the pattern elements passed to a with clause.
 	class OuterPattern < MultipleObjectPattern
 		attr_writer :block
 		attr_reader :guard
-		
+
 		# Specialized version of the bi-directional comparison operator.
 		#
 		# @param [BasicPattern]  other  Right-hand side of the comparison
@@ -517,7 +519,7 @@ module Filigree
 				self.pattern.zip(other.pattern).inject(0) do |total, pair|
 					total + (pair.first <=> pair.last)
 				end <=> 0
-				
+
 				if comp_res == 0
 					self.guard ? (other.guard ? 0 : 1) : (other.guard ? -1 : comp_res)
 				else
@@ -525,7 +527,7 @@ module Filigree
 				end
 			end
 		end
-		
+
 		# Create a new outer pattern with the given pattern elements, guard,
 		# and block.
 		#
@@ -537,7 +539,7 @@ module Filigree
 			@guard = guard
 			@block = block
 		end
-		
+
 		# Call the pattern's block, passing the given objects to the block.
 		#
 		# @param [Object]         env      Environment in which to evaluate the block
@@ -545,7 +547,7 @@ module Filigree
 		def call(env, objects = [])
 			if @block then env.instance_exec(*objects, &@block) else nil end
 		end
-		
+
 		# Test the objects for equality to the pattern elements.
 		#
 		# @param [Object]  objects  Objects to test pattern elements against
@@ -556,14 +558,14 @@ module Filigree
 			super && (@guard.nil? or env.instance_exec(&@guard))
 		end
 	end
-	
+
 	# A pattern that matches an instance of a class and destructures it so
 	# that the values contained by the object may be matched upon.
 	class DestructuringPattern < MultipleObjectPattern
-		
+
 		# @return [Class]
 		attr_reader :klass
-		
+
 		# Specialized version of the bi-directional comparison operator.
 		#
 		# @param [BasicPattern]  other  Right-hand side of the comparison
@@ -578,16 +580,16 @@ module Filigree
 							total + (pair.first <=> pair.last)
 						end / self.pattern.length
 					end
-					
+
 				elsif self.klass.subclass_of?(other.klass) then  1
 				else                                            -1
 				end
-				
+
 			else
 				super
 			end
 		end
-		
+
 		# Create a new destructuring pattern.
 		#
 		# @param [Class]   klass    Class to match instances of.  It must be destructurable.
@@ -596,7 +598,7 @@ module Filigree
 			@klass = klass
 			super(pattern)
 		end
-		
+
 		# Test to see if the object is an instance of the appropriate class,
 		# and if so destructure it and test it's values against the
 		# sub-pattern elements.
@@ -608,7 +610,7 @@ module Filigree
 		def match?(object, env)
 			object.is_a?(@klass) and super(object.destructure(@pattern.length), env)
 		end
-		
+
 		def weight
 			1
 		end
@@ -621,7 +623,7 @@ end
 
 class Array
 	extend Filigree::Destructurable
-	
+
 	# Destructuring for the array class.  If the array is being matched
 	# against two patterns the destructuring of the array will be the first
 	# element and then an array containing the rest of the values.  If there
@@ -655,3 +657,12 @@ class Regexp
 		binding_pattern.tap { |bp| bp.pattern_elem = Filigree::RegexpPattern.new(self) }
 	end
 end
+
+class Symbol
+	# Turns a symbol into a binding pattern.
+	#
+	# @return [Filigree::BindingPattern]
+	def !
+		Filigree::BindingPattern.new(self)
+	end
+end