filigree 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1d6915cb3d2543b432be0c5edbf4a3217ab373e
-  data.tar.gz: 4855e4e67ea643c57890627905bb4be09d0d784d
+  metadata.gz: 7264462695b42d279eabfc6cf85ff3569dc256ce
+  data.tar.gz: 29f78a7573518bcffe8b4ac1a7e4c17ada4e1679
 SHA512:
-  metadata.gz: 79fcfefdb28a5ce107c5568a6110a1e4d9bfcde37e95663fe4292b9ebc9cda0d5057d0efbdfbcaada9158856a39075d01875b56f0e88a7e023192f64ba10750e
-  data.tar.gz: 76d3b55b506b2b37e1a801d8e6795cc044a05ad47f008d22a9cbf83000ab8b148117e1577040484f2a22abd3de24757ca20e7a985a4f0b6e60ec1c98ea412e7c
+  metadata.gz: 9e38b5a5cc832448271b531dafe9c31fa9cc897274bd9e75dad2bb8bc11bbc1c10dc00a2a441aaeeb7e137d98d88aa3bdf4534d94abcb23a021b289aaf19c906
+  data.tar.gz: 4b56356808f786d479cc5cadcbfb769188f4c1bbdbd3bcb3255aa9f77a0ce8f2e5dc5e447c6dc1e2ec3046df1611c1e4c1977517a43182e25ad0f7073ab21798

data/README.md

@@ -1,17 +1,23 @@
 Filigree: For more beautiful Ruby
 =================================
 
-Filigree is a collection of classes, modules, and functions that I found myself re-writing in each of my projects.  In addition, I have thrown in a couple of other features that I've always wanted.  Here are some of those features:
+<div style="float: left; padding-right: 25px">
+<img src="https://raw.github.com/chriswailes/filigree/master/resources/filigree_logo_large.jpg" alt="Filigree: For more beautiful Ruby" height=256 width=256>
+</div>
 
-* Abstract classes and methods
-* An implementation of pattern matching
-* An implementation of the visitor pattern
-* Module for defining class methods in a mixin
-* Modules for configuration and command handling
-* Easy dynamic type checking
-* Small extensions to standard library classes
+Filigree is a collection of classes, modules, and functions that I found myself re-writing in each of my projects.  In addition, I have thrown in a couple of other features that I've always wanted.  Most of these features can be used independently.  Bellow is a list of many of the files and the features that each file provides:
 
-I'm going to go over some of the more important features below, but I won't be able to cover everything.  Explore the rest of the documentation to discover additional features.
+* **filigree/abstract_class.rb** - Abstract class and method implementations
+* **filigree/application.rb** - A basic application framework
+* **filigree/class_methods_module.rb** - Easy way to include class methods in a mixin
+* **filigree/commands.rb** - Framework for defining and processing command lines
+* **filigree/configuration.rb** - Framework for parsing configuration strings
+* **filigree/match.rb** - An implementation of pattern matching for Ruby
+* **filigree/request_file.rb** - Conditionally do something if a file can be included; great for Rakefiles
+* **filigree/types.rb** - Helper functions/classes for type checking ruby code; great for FFI integration
+* **filigree/visitor.rb** - Implementation of the Visitor pattern based on pattern matching library
+
+The above is not a complete list of files provided by this gem, and the documentation bellow only covers the most important features of the library.  Explore the rest of the documentation to discover additional features.
 
 Abstract Classes and Methods
 ----------------------------
@@ -130,7 +136,7 @@ match Foo.new(4, 2) do
 end
 ```
 
-Of particular note is the destructuring of arrays.  When an array is destructured like so, `Array.(xs)`, the array is bound to `xs`.  If an additional pattern is added, `Array.(x, xs)`, then `x` will hold the first element of the array and `xs` will hold the remailing characters.  As more patterns are added more elements will be pulled off of the front of the array.  You can match an array with a specific number of elements by using an empty array litteral: `Array.(x, [])`
+Of particular note is the destructuring of arrays.  When an array is destructured like so, `Array.(xs)`, the array is bound to `xs`.  If an additional pattern is added, `Array.(x, xs)`, then `x` will hold the first element of the array and `xs` will hold the remaining characters.  As more patterns are added more elements will be pulled off of the front of the array.  You can match an array with a specific number of elements by using an empty array literal: `Array.(x, [])`
 
 Both `match` and `with` can take multiple arguments.  When this happens, each object is paired up with the corresponding pattern.  If they all match, then the `with` clause matches.  In this way you can match against tuples.
 
@@ -184,6 +190,16 @@ mv.visit(Add.new(6, 8)) # => 14
 mv.visit(Mul.new(7, 6)) # => 42
 ```
 
+The only complicated aspect of the Visitor mixin is the method used to select the order in which the patterns are tested.  If patterns were tested in order of definition then a subclass of a visitor would be unable to define a more specific pattern than one defined int he parent visitor.  To address this issue the most _specific_ patterns are tested first.  This gets a bit complicated when it gets to destructuring patterns, but most cases are fairly simple.  Pattern specificity is as follows:
+
+1. Literals
+2. Destructurings
+3. Regular expressions
+4. Instances
+5. Wildcard
+
+There are special rules for destructuring and instance patterns.  In both cases, a pattern for a subclass is preferred to a pattern for a superclass.  Destructuring patterns have the additional rule that longer, more specific destructurings are preferred to shorter, less specific destructurings.  Lastly, any pattern that has a guard expression is more specific than an otherwise equivalent expression that doesn't have a guard expression.
+
 Class Methods
 -------------
 
@@ -317,15 +333,6 @@ var = Foo.new(42, '42')
 var.bar = '42' # Raises a TypeError
 ```
 
-Array#map
----------
-
-The Array class has been monkey patched so that it takes an optional symbol argument.  If it is provided, the symbol is sent to each of the objects in the array and the result is used for the new array.
-
-```Ruby
-[1, 2, 3, 4].map :to_sym # => [:1, :2, :3, :4]
-```
-
 Contributing
 ------------
 

data/lib/filigree.rb

@@ -12,7 +12,6 @@
 # Filigree
 require 'filigree/abstract_class'
 require 'filigree/application'
-require 'filigree/array'
 require 'filigree/boolean'
 require 'filigree/class'
 require 'filigree/class_methods_module'

data/lib/filigree/commands.rb

@@ -10,7 +10,6 @@
 # Standard Library
 
 # Filigree
-require 'filigree/array'
 require 'filigree/class_methods_module'
 require 'filigree/configuration'
 
@@ -85,7 +84,7 @@ module Filigree
 			# @return [void]
 			def add_command(command_obj)
 				@command_list << command_obj
-				namespace = reify_namespace(command_obj.name.split.map(:to_sym))
+				namespace = reify_namespace(command_obj.name.split.map(&:to_sym))
 				namespace[:nil] = command_obj
 			end
 			
@@ -225,7 +224,7 @@ module Filigree
 			comm_list = self.class.command_list
 		
 			sorted_comm_list = comm_list.sort { |a, b| a.name <=> b.name }
-			max_length       = comm_list.map(:name).inject(0) { |max, str| max <= str.length ? str.length : max }
+			max_length       = comm_list.lazy.map { |opt| opt.name.length }.max
 		
 		
 			sorted_comm_list.each do |comm|

data/lib/filigree/configuration.rb

@@ -378,9 +378,9 @@ module Filigree
 			# @return [String]
 			def self.to_s(options, indent = 0)
 				lines = []
-			
-				max_long  = options.inject(0) { |max, opt| max <= opt.long.length  ? opt.long.length  : max }
-				max_short = options.inject(0) { |max, opt| !opt.short.nil? && max <= opt.short.length ? opt.short.length : max }
+				
+				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)

data/lib/filigree/match.rb

@@ -13,6 +13,7 @@ require 'singleton'
 
 # Filigree
 require 'filigree/abstract_class'
+require 'filigree/class'
 
 ##########
 # Errors #
@@ -166,7 +167,32 @@ 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.
+	#
+	# @param [Array<Object>]  pattern  Naked pattern object
+	#
+	# @return [Array<BasicPattern>]  Wrapped pattern object
+	def Filigree::wrap_pattern_elements(pattern)
+		pattern.map do |el|
+			case el
+			when BasicPattern then el
+			when Class        then InstancePattern.new(el)
+			when Regexp       then RegexpPattern.new(el)
+			else                   LiteralPattern.new(el)
+			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
@@ -178,7 +204,7 @@ module Filigree
 		#
 		# @return [DestructuringPattern]
 		def call(*pattern)
-			DestructuringPattern.new(self, *pattern)
+			DestructuringPattern.new(self, Filigree::wrap_pattern_elements(pattern))
 		end
 	end
 	
@@ -235,7 +261,9 @@ module Filigree
 		# @return [void]
 		def with(*pattern, &block)
 			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
@@ -264,7 +292,18 @@ module Filigree
 	
 	# This class provides the basis for all match patterns.
 	class BasicPattern
-		extend AbstractClass
+		extend  AbstractClass
+		include Comparable
+		
+		# Base implementation of bi-directional comparison for patterns.
+		#
+		# @param [BasicPattern]  other  Right-hand side of the comparison
+		#
+		# @return [Integer]  Value corresponding to less than, equal to, or
+		#   greater than the right-hand side pattern.
+		def <=>(other)
+			self.weight - other.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.
@@ -273,32 +312,6 @@ module Filigree
 		def as(binding_pattern)
 			binding_pattern.tap { |bp| bp.pattern_elem = self }
 		end
-		
-		# Test to see if a single object matches a single pattern, using the
-		# given environment to store bindings.
-		#
-		# @param [Object]  pattern_elem  Object representing the pattern
-		# @param [Object]  object        Object to be matched
-		# @param [Object]  env           Environment in which to store bindings
-		#
-		# @return [Boolean]  If the pattern element matched
-		def match_pattern_element(pattern_elem, object, env)
-			case pattern_elem
-			when Class
-				object.is_a?(pattern_elem)
-			
-			when Regexp
-				(object.is_a?(String) and (md = pattern_elem.match(object))).tap do |match|
-					env.send("match_data=", md) if match
-				end
-			
-			when BasicPattern
-				pattern_elem.match?(object, env)
-				 
-			else
-				object == pattern_elem
-			end
-		end
 	end
 	
 	# A pattern that matches any object
@@ -311,28 +324,59 @@ module Filigree
 		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
 		def initialize(pattern_elem)
 			@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
+		# Specialized version of the bi-directional comparison operator.
+		#
+		# @param [BasicPattern]  other  Right-hand side of the comparison
+		#
+		# @return [-1, 0, 1]  Value corresponding to less than, equal to, or
+		#   greater than the right-hand side pattern.
+		def <=>(other)
+			if other.is_a?(InstancePattern)
+				if    self.pattern_elem == other.pattern_elem            then 0
+				elsif self.pattern_elem.subclass_of?(other.pattern_elem) then 1
+				else                                                         -1
+				end
+			else
+				super
+			end
+		end
 		
-		# Testing the pattern only involves testing the single pattern
-		# element.
+		# Test the object to see if the object is an instance of the given
+		# class.
 		#
 		# @param [Object]  object  Object to test pattern against
-		# @param [Object]  env     Binding environment
 		#
 		# @return [Boolean]
-		def match?(object, env)
-			match_pattern_element(@pattern_elem, object, env)
+		def match?(object, _)
+			object.is_a?(@pattern_elem)
+		end
+		
+		def weight
+			3
 		end
 	end
 	
@@ -346,22 +390,52 @@ 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
+		# expression.
+		#
+		# @param [Object]  object  Object to test pattern against
+		# @param [Object]  env     Binding environment
+		#
+		# @return [Boolean]
+		def match?(object, env)
+			(object.is_a?(String) and (md = @pattern_elem.match(object))).tap do |match|
+				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_accessor :pattern_elem
+		
+		attr_writer :pattern_elem
 		
 		# Create a new binding pattern.
 		#
 		# @param  [Symbol]  name          Name to bind to
 		# @param  [Object]  pattern_elem  Sub-pattern
-		def initialize(name, pattern_elem = nil)
+		def initialize(name, pattern_elem = WildcardPattern.instance)
 			@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.
 		#
@@ -370,9 +444,11 @@ module Filigree
 		#
 		# @return [Boolean]
 		def match?(object, env)
-			(@pattern_elem.nil? or super).tap do |match|
-				env.send("#{@name}=", object) if match
-			end
+			@pattern_elem.match?(object, env).tap { |match| env.send("#{@name}=", object) if match }
+		end
+		
+		def weight
+			@pattern_elem.weight
 		end
 	end
 	
@@ -380,6 +456,9 @@ module Filigree
 	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
@@ -387,6 +466,21 @@ module Filigree
 			@pattern = pattern
 		end
 		
+		# A wrapper method to sort MultipleObjectPattern objects by their
+		# arity.
+		#
+		# @param [BasicPattern]  other  Right-hand side of the comparison
+		#
+		# @return [Integer]  Value corresponding to less than, equal to, or
+		#   greater than the right-hand side pattern.
+		def base_compare(other)
+			if self.pattern.length == other.pattern.length
+				yield
+			else
+				self.pattern.length - other.pattern.length
+			end
+		end
+		
 		# Test multiple objects against multiple pattern elements.
 		#
 		# @param [Object]  objects  Object to test pattern against
@@ -395,7 +489,7 @@ module Filigree
 		def match?(objects, env)
 			if objects.length == @pattern.length
 				@pattern.zip(objects).each do |pattern_elem, object|
-					return false unless match_pattern_element(pattern_elem, object, env)
+					return false unless pattern_elem.match?(object, env)
 				end
 			
 				true
@@ -406,9 +500,31 @@ module Filigree
 		end
 	end
 	
-	# The that contains all of the pattern elements passed to a with clause.
+	# 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
+		#
+		# @return [-1, 0, 1]  Value corresponding to less than, equal to, or
+		#   greater than the right-hand side pattern.
+		def <=>(other)
+			base_compare(other) do
+				comp_res =
+				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
+					comp_res
+				end
+			end
+		end
 		
 		# Create a new outer pattern with the given pattern elements, guard,
 		# and block.
@@ -444,11 +560,39 @@ module Filigree
 	# 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
+		#
+		# @return [Integer]  Value corresponding to less than, equal to, or
+		#   greater than the right-hand side pattern.
+		def <=>(other)
+			if other.is_a?(DestructuringPattern)
+				if self.klass == other.klass
+					base_compare(other) do
+						self.pattern.zip(other.pattern).inject(0) do |total, pair|
+							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.
 		# @param [Object]  pattern  Pattern elements to use in matching the object's values
-		def initialize(klass, *pattern)
+		def initialize(klass, pattern)
 			@klass = klass
 			super(pattern)
 		end
@@ -464,6 +608,10 @@ module Filigree
 		def match?(object, env)
 			object.is_a?(@klass) and super(object.destructure(@pattern.length), env)
 		end
+		
+		def weight
+			1
+		end
 	end
 end
 
@@ -494,6 +642,16 @@ class Class
 	#
 	# @param [BindingPattern]  binding_pattern  Name to bind the instance to
 	def as(binding_pattern)
-		binding_pattern.tap { |bp| bp.pattern_elem = self }
+		binding_pattern.tap { |bp| bp.pattern_elem = Filigree::InstancePattern.new(self) }
+	end
+end
+
+class Regexp
+	# Causes a string matching the regular expression to be bound the the
+	# given name.
+	#
+	# @param [BindingPattern]  binding_pattern  Name to bind the instance to
+	def as(binding_pattern)
+		binding_pattern.tap { |bp| bp.pattern_elem = Filigree::RegexpPattern.new(self) }
 	end
 end

data/lib/filigree/version.rb

@@ -4,5 +4,5 @@
 # Description:	This file specifies the version number of Filigree.
 
 module Filigree
-	VERSION = '0.1.2'
+	VERSION = '0.2.0'
 end

data/lib/filigree/visitor.rb

@@ -88,11 +88,38 @@ module Filigree
 				LiteralPattern.new(obj)
 			end
 			
+			# Inserts a new pattern in the appropriate place in the patterns
+			# list.
+			#
+			# @param [OuterPattern]  new_pat  New pattern to add
+			#
+			# @return [void]
+			def add_pattern(new_pat)
+				@patterns.each_with_index do |old_pat, index|
+					if new_pat > old_pat
+						@patterns.insert(index, new_pat)
+						return
+					end
+				end
+				
+				@patterns << new_pat
+			end
+			
+			# A callback used to pass patterns declared in a parent class to
+			# a subclass.
+			#
+			# @param [Class]  klass  Subclass
+			#
+			# @return [void]
+			def inherited(klass)
+				klass.install_icvars(@patterns.clone)
+			end
+			
 			# Install the instance class variables in the including class.
 			#
 			# @return [void]
-			def install_icvars
-				@patterns = Array.new
+			def install_icvars(inherited_patterns = Array.new)
+				@patterns = inherited_patterns
 				@deferred = Array.new
 			end
 			
@@ -106,8 +133,9 @@ module Filigree
 			# @return [void]
 			def on(*pattern, &block)
 				guard = if pattern.last.is_a?(Proc) then pattern.pop end 
-		
-				@patterns << (mp = OuterPattern.new(pattern, guard, block))
+				
+				pattern = Filigree::wrap_pattern_elements(pattern)
+				add_pattern (mp = OuterPattern.new(pattern, guard, block))
 		
 				if block
 					@deferred.each { |pattern| pattern.block = block }

data/test/tc_visitor.rb

@@ -157,9 +157,32 @@ class VisitorTester < Minitest::Test
 		end
 	end
 	
+	class NumericVisitor
+		include Filigree::Visitor
+		
+		on Numeric do |n|
+			"Numeric: #{n}"
+		end
+	end
+	
+	class SubclassVisitor < NumericVisitor
+		on Integer do |i|
+			"Integer: #{i}"
+		end
+	end
+	
 	def setup
 	end
 	
+	def test_inheritance
+		sv = SubclassVisitor.new
+		
+		assert_equal "Numeric: 3.1415296", sv.visit(3.1415296)
+		assert_equal "Integer: 42",        sv.visit(42)
+		
+		assert_raises(MatchError) { sv.visit(:hoopy) }
+	end
+	
 	def test_simple_visitor
 		sv = SimpleVisitor.new
 		

data/test/ts_filigree.rb

@@ -20,7 +20,6 @@ end
 # Test Cases
 require 'tc_abstract_class'
 require 'tc_application'
-require 'tc_array'
 require 'tc_boolean'
 require 'tc_class'
 require 'tc_class_methods_module'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filigree
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Wailes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-26 00:00:00.000000000 Z
+date: 2014-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -175,35 +175,33 @@ files:
 - AUTHORS
 - README.md
 - Rakefile
-- lib/filigree/request_file.rb
-- lib/filigree/class_methods_module.rb
-- lib/filigree/visitor.rb
 - lib/filigree/types.rb
-- lib/filigree/object.rb
-- lib/filigree/string.rb
-- lib/filigree/commands.rb
-- lib/filigree/abstract_class.rb
 - lib/filigree/boolean.rb
+- lib/filigree/match.rb
 - lib/filigree/application.rb
+- lib/filigree/abstract_class.rb
+- lib/filigree/class.rb
+- lib/filigree/string.rb
 - lib/filigree/version.rb
 - lib/filigree/configuration.rb
-- lib/filigree/array.rb
-- lib/filigree/match.rb
-- lib/filigree/class.rb
+- lib/filigree/visitor.rb
+- lib/filigree/object.rb
+- lib/filigree/commands.rb
+- lib/filigree/request_file.rb
+- lib/filigree/class_methods_module.rb
 - lib/filigree.rb
-- test/tc_commands.rb
-- test/tc_array.rb
+- test/tc_boolean.rb
+- test/tc_object.rb
 - test/tc_types.rb
-- test/tc_class.rb
+- test/tc_configuration.rb
+- test/tc_commands.rb
 - test/tc_string.rb
-- test/tc_application.rb
-- test/tc_match.rb
 - test/tc_abstract_class.rb
-- test/tc_object.rb
-- test/tc_class_methods_module.rb
-- test/tc_configuration.rb
-- test/tc_boolean.rb
 - test/tc_visitor.rb
+- test/tc_class_methods_module.rb
+- test/tc_match.rb
+- test/tc_class.rb
+- test/tc_application.rb
 - test/ts_filigree.rb
 homepage: https://github.com/chriswailes/filigree
 licenses:
@@ -230,18 +228,17 @@ signing_key:
 specification_version: 4
 summary: Extra functionality for Ruby.
 test_files:
-- test/tc_commands.rb
-- test/tc_array.rb
+- test/tc_boolean.rb
+- test/tc_object.rb
 - test/tc_types.rb
-- test/tc_class.rb
+- test/tc_configuration.rb
+- test/tc_commands.rb
 - test/tc_string.rb
-- test/tc_application.rb
-- test/tc_match.rb
 - test/tc_abstract_class.rb
-- test/tc_object.rb
-- test/tc_class_methods_module.rb
-- test/tc_configuration.rb
-- test/tc_boolean.rb
 - test/tc_visitor.rb
+- test/tc_class_methods_module.rb
+- test/tc_match.rb
+- test/tc_class.rb
+- test/tc_application.rb
 - test/ts_filigree.rb
 has_rdoc: 

data/lib/filigree/array.rb

@@ -1,35 +0,0 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2013/05/04
-# Description:	Additional features for Arrays.
-
-############
-# Requires #
-############
-
-# Standard Library
-
-# Filigree
-
-#######################
-# Classes and Modules #
-#######################
-
-class Array
-	alias :aliased_map :map
-	
-	# Map now takes an optional symbol argument.  If a symbol is provided the
-	# specified method is invoked on each of the objects in the array.
-	#
-	# @param [Symbol]  method  Method to be invoked on the array elements.
-	# @param [Proc]    block   Normal Array#each block.
-	#
-	# @return [Array<Object>]
-	def map(method = nil, &block)
-		if method
-			self.aliased_map { |obj| obj.send(method) }
-		else
-			self.aliased_map(&block)
-		end
-	end
-end

data/test/tc_array.rb

@@ -1,28 +0,0 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2014/02/05
-# Description:	Test cases for the Array extensions.
-
-############
-# Requires #
-############
-
-# Gems
-require 'minitest/autorun'
-
-# Filigree
-require 'filigree/array'
-
-#######################
-# Classes and Modules #
-#######################
-
-class ArrayTester < Minitest::Test
-	
-	def setup
-	end
-	
-	def test_map_with_method
-		assert_equal [:cat, :dog, :cow], ['cat', 'dog', 'cow'].map(:to_sym)
-	end
-end