filigree 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 508a55d16a4f1321ba4c9042758b1a497bf85827
-  data.tar.gz: d5ce1b0d135d319bb5a20425bf74ce6d8ade72c9
+  metadata.gz: 178a6b1f4c1c7e4fa5572856e84f8e42e61ef423
+  data.tar.gz: 0b4d734851d85411da754286fbe7562dd894e8a7
 SHA512:
-  metadata.gz: b0683038d43739552cd653c997fd28b8c1f435db879166bc2c50475817528fb8061ef2b5fd11c3c948b8c005e237ab6d81d24963e77d8ca0b60534cb6af8eead
-  data.tar.gz: 1bc7acb9d54d99a95ff8229c384d57b3929e6ab24b3478fbe6ebeb19888d4339c6f058ca39bbc078db452f568f69c011cb46874d90b27819abbbeb4f0c3c8411
+  metadata.gz: 37ed52f1a1780895bfdb255625f9edd5a649c96595395851a1d99ae79ba695e7f45f4e5d443452342ce3aa77db665b24abf9a71c67579233bf806ce3177e41c0
+  data.tar.gz: 67ded0ee569137d4dd0b00d99e753af2db406beff41f8a6994b76bfff52521b4b7f08316c4d3ff3128f0180b7b1cea91aa2c1cbd1e7900278a2c46d5e7ae242b

data/README.md

@@ -164,7 +164,11 @@ Filigree's implementation of the visitor pattern is built on the pattern matchin
 ```Ruby
 class Binary < Struct.new(:x, :y)
   extend  Filigree::Destructurable
-  include Filigree::Visitor
+  include Filigree::Visitable
+
+  def children
+  	[x, y]
+  end
 
   def destructure(_)
     [x, y]

data/lib/filigree/abstract_class.rb

@@ -1,7 +1,7 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2013/4/19
-# Description:	An implementation of an AbstractClass module.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Filigree
+# Date:        2013/4/19
+# Description: An implementation of an AbstractClass module.
 
 ############
 # Requires #

data/lib/filigree/match.rb

@@ -1,7 +1,7 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2013/05/04
-# Description:	Pattern matching for Ruby.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Filigree
+# Date:        2013/05/04
+# Description: Pattern matching for Ruby.
 
 ############
 # Requires #
@@ -22,146 +22,6 @@ require 'filigree/class'
 # An error that indicates that no pattern matched a given object.
 class MatchError < RuntimeError; end
 
-###########
-# Methods #
-###########
-
-# This is an implementation of pattern matching.  The objects passed to match
-# are tested against the patterns defined inside the match block.  The return
-# value of `match` will be the result of evaluating the block given to `with`.
-
-# The most basic pattern is the literal.  Here, the object or objects being
-# matched will be tested for equality with value passed to `with`.  In the
-# example below, the call to `match` will return `:one`.  Similar to the
-# literal pattern is the wildcard pattern `_`.  This will match any object.
-
-# You may also match against variables.  This can sometimes conflict with the
-# next kind of pattern, which is a binding pattern.  Here, the pattern will
-# match any object, and then make the object it matched available to the with
-# block via an attribute reader.  This is accomplished using the method_missing
-# callback, so if there is a variable or function with that name you might
-# 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.
-
-# 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.
-# If the object being matched is a string then the regular expressions `match?`
-# method is used.  The result of the regular expression match is available
-# inside the with block via the match_data accessor.
-
-# When a class is used in a pattern it will match any object that is an
-# 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
-# include the {Filigree::Destructurable} module.  You can then destructure an
-# object as shown bellow.
-
-# 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.
-
-# Any with clause can be given a guard clause by passing a lambda as the last
-# argument to `with`.  These are evaluated after the pattern is matched, and
-# any bindings made in the pattern are available to the guard clause.
-
-# If you wish to evaluate the same body on matching any of several patterns you
-# may list them in order and then specify the body for the last pattern in the
-# group.
-
-# Patterns are evaluated in the order in which they are defined and the first
-# pattern to match is the one chosen.  You may define helper methods inside the
-# match block.  They will be re-defined every time the match statement is
-# evaluated, so you should move any definitions outside any match calls that
-# are being evaluated often.
-
-# @example The literal pattern
-#   def foo(n)
-#     match 1 do
-#       with(1) { :one   }
-#       with(2) { :two   }
-#       with(_) { :other }
-#     end
-#   end
-#
-#   foo(1)
-
-# @example Matching against variables
-#   var = 42
-#   match 42 do
-#     with(var) { :hoopy }
-#     with(0)   { :zero  }
-#   end
-
-# @example Binding patterns
-#   # Returns 42
-#   match 42 do
-#     with(x) { x }
-#   end
-
-#   x = 3
-#   # Returns 42
-#   match 42 do
-#     with(Bind(:x)) { x      }
-#     with(42)       { :hoopy }
-#   end
-
-# @example Regular expression and class instance pattern
-#    def matcher(object)
-#      match object do
-#        with(/hoopy/) { 42      }
-#        with(Integer) { 'hoopy' }
-#      end
-#    end
-
-#    # Returns 42
-#    matcher('hoopy')
-#    # Returns 'hoopy'
-#    matcher(42)
-
-# @example Destructuring an object
-#    class Foo
-#      include Filigree::Destructurable
-#      def initialize(a, b)
-#        @a = a
-#        @b = b
-#      end
-#
-#      def destructure(_)
-#         [@a, @b]
-#      end
-#    end
-
-#    # Returns true
-#    match Foo.new(4, 2) do
-#      with(Foo.(4, 2)) { true  }
-#      with(_)          { false }
-#    end
-
-# @example Using guard clauses
-#    match o do
-#      with(n, -> { n < 0 }) { :NEG  }
-#      with(0)               { :ZERO }
-#      with(n, -> { n > 0 }) { :POS  }
-#    end
-#
-# @param [Object]  objects  Objects to be matched
-# @param [Proc]    block    Block containing with clauses.
-#
-# @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
-
 #######################
 # Classes and Modules #
 #######################
@@ -172,6 +32,142 @@ module Filigree
 	# Methods #
 	###########
 
+	# This is an implementation of pattern matching.  The objects passed to match
+	# are tested against the patterns defined inside the match block.  The return
+	# value of `match` will be the result of evaluating the block given to `with`.
+
+	# The most basic pattern is the literal.  Here, the object or objects being
+	# matched will be tested for equality with value passed to `with`.  In the
+	# example below, the call to `match` will return `:one`.  Similar to the
+	# literal pattern is the wildcard pattern `_`.  This will match any object.
+
+	# You may also match against variables.  This can sometimes conflict with the
+	# next kind of pattern, which is a binding pattern.  Here, the pattern will
+	# match any object, and then make the object it matched available to the with
+	# block via an attribute reader.  This is accomplished using the method_missing
+	# callback, so if there is a variable or function with that name you might
+	# 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.
+
+	# 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.
+	# If the object being matched is a string then the regular expressions `match?`
+	# method is used.  The result of the regular expression match is available
+	# inside the with block via the match_data accessor.
+
+	# When a class is used in a pattern it will match any object that is an
+	# 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
+	# include the {Filigree::Destructurable} module.  You can then destructure an
+	# object as shown bellow.
+
+	# 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.
+
+	# Any with clause can be given a guard clause by passing a lambda as the last
+	# argument to `with`.  These are evaluated after the pattern is matched, and
+	# any bindings made in the pattern are available to the guard clause.
+
+	# If you wish to evaluate the same body on matching any of several patterns you
+	# may list them in order and then specify the body for the last pattern in the
+	# group.
+
+	# Patterns are evaluated in the order in which they are defined and the first
+	# pattern to match is the one chosen.  You may define helper methods inside the
+	# match block.  They will be re-defined every time the match statement is
+	# evaluated, so you should move any definitions outside any match calls that
+	# are being evaluated often.
+
+	# @example The literal pattern
+	#   def foo(n)
+	#     match 1 do
+	#       with(1) { :one   }
+	#       with(2) { :two   }
+	#       with(_) { :other }
+	#     end
+	#   end
+	#
+	#   foo(1)
+
+	# @example Matching against variables
+	#   var = 42
+	#   match 42 do
+	#     with(var) { :hoopy }
+	#     with(0)   { :zero  }
+	#   end
+
+	# @example Binding patterns
+	#   # Returns 42
+	#   match 42 do
+	#     with(x) { x }
+	#   end
+
+	#   x = 3
+	#   # Returns 42
+	#   match 42 do
+	#     with(Bind(:x)) { x      }
+	#     with(42)       { :hoopy }
+	#   end
+
+	# @example Regular expression and class instance pattern
+	#    def matcher(object)
+	#      match object do
+	#        with(/hoopy/) { 42      }
+	#        with(Integer) { 'hoopy' }
+	#      end
+	#    end
+
+	#    # Returns 42
+	#    matcher('hoopy')
+	#    # Returns 'hoopy'
+	#    matcher(42)
+
+	# @example Destructuring an object
+	#    class Foo
+	#      include Filigree::Destructurable
+	#      def initialize(a, b)
+	#        @a = a
+	#        @b = b
+	#      end
+	#
+	#      def destructure(_)
+	#         [@a, @b]
+	#      end
+	#    end
+
+	#    # Returns true
+	#    match Foo.new(4, 2) do
+	#      with(Foo.(4, 2)) { true  }
+	#      with(_)          { false }
+	#    end
+
+	# @example Using guard clauses
+	#    match o do
+	#      with(n, -> { n < 0 }) { :NEG  }
+	#      with(0)               { :ZERO }
+	#      with(n, -> { n > 0 }) { :POS  }
+	#    end
+	#
+	# @param [Object]  objects  Objects to be matched
+	# @param [Proc]    block    Block containing with clauses.
+	#
+	# @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
+
 	# Wrap non-pattern objects in pattern objects so they can all be treated
 	# in the same way during pattern sorting and matching.
 	#

data/lib/filigree/version.rb

@@ -1,8 +1,8 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2013/4/19
-# Description:	This file specifies the version number of Filigree.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Filigree
+# Date:        2013/4/19
+# Description: This file specifies the version number of Filigree.
 
 module Filigree
-	VERSION = '0.3.2'
+	VERSION = '0.3.3'
 end

data/lib/filigree/visitor.rb

@@ -32,7 +32,7 @@ module Filigree
 		#
 		# @param [Object]  objects  Objects to pattern match.
 		#
-		# @return [Object]  Result of calling the matched pattern's block
+		# @return [Object, MatchError]  Result of calling the matched pattern's block or MatchError if nothing was found
 		#
 		# @raise [MatchError]  Raised when no matching pattern is found and
 		#                      strict matching is enabled.
@@ -58,7 +58,7 @@ module Filigree
 				# If we didn't find anything we raise a MatchError.
 				raise MatchError
 			else
-				nil
+				MatchError
 			end
 		end
 
@@ -230,27 +230,37 @@ module Filigree
 		# Visit this object with the provided visitor in pre-, post-, or
 		# in-order traversal.
 		#
-		# @param [Visitor]                          visitor  Visitor to call
-		# @param [:preorder, :inorder, :postorder]  method   How to visit
+		# @param [Visitor]                                   visitor  Visitor to call
+		# @param [:preorder, :inorder, :postorder, :downup]  method   How to visit
 		#
-		# @return [void]
+		# @return [Boolean] If a pattern matched or not
 		def visit(visitor, method = :preorder)
 			case method
 			when :preorder
-				visitor.visit(self)
-				children.flatten.compact.each { |child| child.visit(visitor, :preorder) }
+				res = (visitor.visit(self) != MatchError)
+				children.flatten.compact.inject(false) { |mod, child| child.visit(visitor, :preorder) || mod } || res
 
 			when :inorder
+				mod   = false
 				nodes = [self]
 
+				# Not all Ruby implementations support modifying arrays while
+				# you are iterating over them.
 				while node = nodes.shift
 					nodes += node.children.flatten.compact
-					visitor.visit(node)
+					mod = visitor.visit(node) || mod
 				end
 
+				mod
+
 			when :postorder
-				children.flatten.compact.each { |child| child.visit(visitor, :postorder) }
-				visitor.visit(self)
+				res = children.flatten.compact.inject(false) { |mod, child| child.visit(visitor, :postorder) || mod }
+				(visitor.visit(self) != MatchError) || res
+
+			when :downup
+				res = (visitor.visit(self) != MatchError)
+				res = children.flatten.compact.inject(false) { |mod, child| child.visit(visitor, :downup) || mod } || res
+				(visitor.visit(self) != MatchError) || res
 			end
 		end
 	end

data/test/tc_match.rb

@@ -1,7 +1,7 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Filigree
-# Date:		2013/05/04
-# Description:	Test cases for the match method.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Filigree
+# Date:        2013/05/04
+# Description: Test cases for the match method.
 
 ############
 # Requires #
@@ -19,6 +19,8 @@ require 'filigree/match'
 
 class MatchTester < Minitest::Test
 
+	include Filigree
+
 	####################
 	# Internal Classes #
 	####################

data/test/tc_visitor.rb

@@ -230,7 +230,7 @@ class VisitorTester < Minitest::Test
 	def test_nonstrict_matching
 		nsmv = NonStrictMatchVisitor.new
 
-		assert_nil(nsmv.visit 0)
+		assert_equal(MatchError, nsmv.visit(0))
 	end
 
 	def test_simple_visitor
@@ -305,5 +305,15 @@ class VisitorTester < Minitest::Test
 		tree.visit(nv, :postorder)
 
 		assert_equal expected, nv.vals
+
+		# Test down-up
+		nv = NodeVisitor.new
+		expected = ['F', 'B', 'A', 'A', 'D', 'C', 'C', 'E', 'E', 'D', 'B', 'G', 'I', 'H', 'H', 'I', 'G', 'F']
+		tree.visit(nv, :downup)
+
+		assert_equal expected, nv.vals
+
+		# Test behaviour whith no match.
+		assert(!tree.visit(HelperMethodVisitor.new), 'Visitable object falsely reported a matching.')
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filigree
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Chris Wailes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler