uttk 0.3.1.2

data/lib/uttk/filters/Default.rb

@@ -0,0 +1,27 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/Default.rb 22074 2006-02-21T13:47:00.947568Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class Default < Id
+
+      def self.template ( str )
+        [
+          'Yaml: [%s.yml]', "Xml: [%s.xml]",
+          'JustStatus: [RemoveTypes: [Yaml]]',
+          'Compact: [NodeCut: [!skip ^contents$, [Html: [%s.html]]]]',
+        ].join(', ') % [str, str, str]
+      end
+
+      composition template('log')
+
+    end # class Default
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/DefaultColor.rb

@@ -0,0 +1,27 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/DefaultColor.rb 22074 2006-02-21T13:47:00.947568Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class DefaultColor < Id
+
+      def self.template ( str )
+        [
+          'Yaml: [%s.yml]', "Xml: [%s.xml]",
+          'JustStatus: [RemoveTypes: [ColorStatus: [Yaml]]]',
+          'Compact: [NodeCut: [!skip ^contents$, [Html: [%s.html]]]]',
+        ].join(', ') % [str, str, str]
+      end
+
+      composition template('log')
+
+    end # class DefaultColor
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/Filter.rb

@@ -0,0 +1,53 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/filters/Filter.rb 22184 2006-02-23T16:12:25.225774Z pouillar  $
+
+
+module Uttk
+
+  # A tutorial introduces how to create new filters at
+  # http://uttk.org/shelf/documentation
+  module Filters
+
+
+    # FIXME: document me
+    class Filter < Logger::Backend
+      include Abstract
+      include Observable
+
+      class_inheritable_hash :default_options
+      self.default_options = {}
+
+      def initialize ( observers=[], options=nil )
+        @options = default_options.merge(options || {})
+        observers.each do |obs|
+          raise ObserverError, obs unless obs.respond_to? :update
+          add_observer(obs)
+        end
+        super()
+      end
+
+      def notif ( *args )
+        changed
+        notify_observers(*args)
+      end
+
+      def self.composition ( *desc )
+        class_eval do
+          @@desc = desc
+          def initialize ( *a, &b )
+            super()
+            Filters[*@@desc].each do |obs|
+              raise ObserverError, obs unless obs.respond_to? :update
+              add_observer(obs)
+            end
+          end
+        end
+      end
+
+    end # class Filter
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/Id.rb

@@ -0,0 +1,30 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/Id.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class Id < Filter
+      include Concrete
+
+
+      def new_leaf ( path, leaf )
+        notif :new_leaf, path, leaf
+      end
+      protected :new_leaf
+
+
+      def close
+        notif :close
+      end
+      protected :close
+
+    end # class Id
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/JustStatus.rb

@@ -0,0 +1,25 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/JustStatus.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class JustStatus < RPathFilter
+      include Concrete
+
+      match '^status$/.*\Z', :display
+
+      def display ( path )
+        leaf = path.pop.segment
+        notif :new_leaf, path, leaf
+      end
+
+    end # class JustStatus
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/KeepSkipBased.rb

@@ -0,0 +1,38 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /fey/uttk/trunk/lib/uttk/filters/KeepSkipBased.rb 8778 2005-09-26T04:34:48.103938Z ertai  $
+
+module Uttk
+
+  module Filters
+
+    class KeepSkipBased < Id
+      include Concrete # Abstract
+
+      attr_reader :keep, :skip
+
+      default_options.merge! :keep => %r{},           # Keep anything
+                             :skip => %r{\A\Z}        # Skip only empty strings
+
+      def initialize ( observers, options, &b )
+        super
+        @keep, @skip, @action = @options.values_at :keep, :skip, :action
+      end
+
+
+      def keep? ( node )
+        node_s = node.to_s
+        (node_s =~ @keep and node_s !~ @skip)
+      end
+
+
+      def skip? ( node )
+        ! keep? node
+      end
+
+    end # class KeepSkipBased
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/NodeCut.rb

@@ -0,0 +1,97 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/NodeCut.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    # FIXME Can be path based
+    # This filter cut nodes which match `keep' but not `skip'
+    #   options:
+    #       keep:  A regular expression (all keys which match this regexp are cut)
+    #       skip:  Antoher regexp that skip keys which match
+    #       prune: Completly cut all sub nodes of a cut one
+    class NodeCut < KeepSkipBased
+      include Concrete
+
+      default_options.merge! :prune => false      # Don't prune by default
+
+      def initialize ( *a, &b )
+        super
+        @pruning_path = Set.new
+        @pruning_path_node = nil
+      end
+
+
+      def new_node ( path, node )
+        if @pruning_path_node or keep? node.segment
+          super
+        elsif prune?
+          @pruning_path << path.to_s
+          @pruning_path_node = path.dup << node
+        else
+          @pruning_path << path.to_s
+        end
+      end
+      protected :new_node
+
+
+      def up ( path )
+        node = path.last
+        path_s= path.to_s
+        if @pruning_path.include? path_s
+          @pruning_path_node = nil
+          @pruning_path.delete path_s
+        else
+          super
+        end
+      end
+      protected :up
+
+
+      def notif ( msg, *args )
+        return super if args.first.nil?
+        path = args.shift
+        return if pruning_path? path
+        copy = path.dup
+        copy.delete_if do |x|
+          skip? x.segment
+        end
+        super(msg, copy, *args)
+      end
+      protected :notif
+
+
+      def prune?
+        @options[:prune]
+      end
+
+
+      def pruning_path? ( path )
+        return false unless @pruning_path_node
+        @pruning_path_node.each_with_index do |seg, i|
+          return false if seg != path[i]
+        end
+        return true
+      end
+
+
+      module Assertions
+        def assert_node_cut ( input, ref, options )
+          @mock_object.mock_clear
+          @filter = NodeCut.new([@mock_object], options)
+          input.each do |n|
+            @filter.update(*Logger.make_notif(n))
+          end
+          assert_mock Logger.make_notifs(ref)
+        end
+      end # module Assertions
+
+    end # class NodeCut
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/RPathFilter.rb

@@ -0,0 +1,134 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/lib/uttk/filters/RPathFilter.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    class RPathFilter < Id
+      # FIXME include Abstract
+
+      attr_reader :log
+
+      def initialize ( *a, &b )
+        @log = Logger.new # FIXME PERAPHS you can remove me
+        @matchers = matchers.dup
+        super
+      end
+
+
+      def add_observer ( obj )
+        @log.add_observer(obj)
+        super
+      end
+
+
+      def new_leaf ( lpath, leaf )
+        lpath << leaf
+        @matchers.each do |matcher|
+          next unless matcher.active?
+          if matcher.have_a_star?
+            buf = matcher.buffer
+            is_prefix = lpath.rpath_prefix(matcher.re)
+            unless buf.empty? or is_prefix
+              buf.buffer.rpath(matcher.re) do |*args|
+                matcher[self, *args]
+              end
+              buf.reset
+            end
+            if is_prefix
+              if buf.empty?
+                l = Logger.new(buf)
+                lpath.each do |seg|
+                  l.new_node seg.segment, seg.options
+                end
+              end
+              buf.update(:new_leaf, lpath, leaf)
+            end
+          else
+            lpath.rpath(matcher.re) do |*args|
+              matcher[self, *args]
+            end
+          end
+        end
+      end
+
+
+      class_inheritable_accessor :matchers
+      self.matchers = []
+
+      #  The _aRegexpPath_ is matched against the path of every notification
+      # the filter receive. If the notification path matches, then the method
+      # mentioned as second argument is called. If no method are mentioned, it
+      # looks for a block. You must supply either a method or a block, not
+      # both.
+      def self.match ( aRegexPath, aMethod=nil, &block )
+        if aMethod.nil? and block.nil?
+          raise ArgumentError, "no block or method given"
+        end
+        if aMethod and block
+          raise ArgumentError, "supply a block OR a method name not both"
+        end
+        self.matchers = matchers + [Matcher.new(aRegexPath, aMethod, &block)]
+      end
+
+      def self.disable_matcher
+        raise Matcher::Disable
+      end
+
+      class Matcher
+        attr_accessor :re, :block, :buffer
+
+        class Disable < Exception
+        end
+
+        def initialize ( aRegexPath, aMethod=nil, &block )
+          @re = aRegexPath
+          @re = RegexPath.new(@re) unless @re.is_a? RegexPath
+          @block = aMethod || block
+          @have_a_star = @re.segments.any? { |x| x.captured? }
+          @buffer = Filters::Buffer.new
+          @active = true
+        end
+
+        def have_a_star?
+          @have_a_star
+        end
+
+        def active?
+          @active
+        end
+
+        def [] ( obj, *args )
+          begin
+            if @block.is_a? Symbol
+              obj.send(@block, *args)
+            else
+              @block[obj, *args]
+            end
+          rescue Disable
+            @active = false
+          end
+        end
+
+      end # class Matcher
+
+      module Assertions
+        attr_accessor :logger, :output_tree
+        attr_reader :rpath_filter
+        def assert_rpath_filter ( ref, aClass )
+          @rpath_filter = aClass.new([mock_object])
+          @logger.add_observer @rpath_filter
+          @logger << @output_tree
+          assert_mock(*Logger.make_notifs(ref))
+        end
+      end # module Assertions
+
+    end # class RPathFilter
+
+  end # module Filters
+
+end # module Uttk

data/lib/uttk/filters/Saver.rb

@@ -0,0 +1,53 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/filters/Saver.rb 21844 2006-02-17T17:26:59.771162Z pouillar  $
+
+
+module Uttk
+
+  module Filters
+
+    # FIXME Path based
+    #
+    # This very basic filter, observe a logger, and
+    # save all received leaves, without any formatting.
+    #
+    # With this observer you save a sort of execution trace.
+    # After that you can apply to another logger the same
+    # message sequence.
+    #
+    # You can also simply check that two results are equal,
+    # for that, just compare the sequence message.
+    #
+    class Saver < Filter
+      include Concrete
+
+      def initialize(*a, &b)
+        super
+        @out = []
+      end
+
+      def new_leaf ( *args )
+        @out << args
+      end
+
+      def get
+        @out.dup
+      end
+
+      def to_uttk_log ( log )
+        each do |a|
+          log.update(:new_leaf, *a)
+        end
+      end
+
+      def each ( &block )
+        @out.each(&block)
+      end
+
+    end # class Saver
+
+  end # module Filters
+
+end # Uttk