uttk 0.3.1.2

data/lib/uttk/dumpers/Basic.rb

@@ -0,0 +1,23 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id$
+
+
+module Uttk
+
+  module Dumpers
+
+    class Basic < Dumper
+      include Concrete
+
+      def update ( *a, &b )
+        super
+        puts "NOTIFICATION: #{a.inspect} block_given: #{not b.nil?}"
+      end
+
+    end # class Basic
+
+  end # module Dumpers
+
+end # module Uttk

data/lib/uttk/dumpers/BasicColor.rb

@@ -0,0 +1,35 @@
+# 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/dumpers/BasicColor.rb 21970 2006-02-19T22:15:36.271512Z pouillar  $
+
+
+module Uttk
+
+  module Dumpers
+
+    class BasicColor < Dumper
+      include Concrete
+
+      def initialize ( *a, &b )
+        super
+        raise "HighLine not available" unless defined? HighLine
+        @h = HighLine.new(nil, self)
+      end
+
+      def update ( *a, &b )
+        super
+        msg, path, node, options = a
+        path = Logger::Path.new(path) unless path.nil?
+        @h.say "#{@h.color msg.inspect.ljust(10), :red} " +
+               "#{@h.color path.inspect, :green} " +
+               "#{@h.color node.inspect, :magenta} " +
+               "#{@h.color options.inspect, :yellow} " +
+               "<%=color 'block_given: #{not b.nil?}', :cyan %>"
+      end
+
+    end # class BasicColor
+
+  end # module Dumpers
+
+end # module Uttk

data/lib/uttk/dumpers/Dumper.rb

@@ -0,0 +1,77 @@
+# 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/dumpers/Dumper.rb 22102 2006-02-21T23:03:39.538964Z pouillar  $
+
+
+module Uttk
+
+  # Dumpers are backends of Uttk.
+  # You can easily write your own dumper. See Uttk::Dumpers::Dumper
+  module Dumpers
+
+    # The dumper is a specific Logger::Backend.
+    #
+    # It react to method calls by writting in the output.
+    # The output must be acceded like that:
+    #
+    #   * Using the print method
+    #   * Using the puts method
+    #   * Using the << method
+    #
+    # If you really need to access to the real outputs use each_output.
+    #
+    # You can safely call flush in your methods because this method take care
+    # of closed and unflushable outputs.
+    class Dumper < Logger::Backend
+      include Abstract
+      attr_accessor :options
+
+      def initialize ( output=STDOUT, *args )
+        @outputs = [output]
+        while args.first.is_a? IO do
+          @outputs << args.shift
+        end
+        @options = args
+        super()
+      end
+
+
+      def flush
+        each_output do |o|
+          o.flush if o.respond_to? :flush and (not o.closed?)
+        end
+      end
+
+
+      def each_output ( &block )
+        @outputs.each(&block)
+      end
+
+
+      def puts ( *args )
+        each_output do |o|
+          o.puts(*args)
+        end
+      end
+
+
+      def print ( *args )
+        each_output do |o|
+          o.print(*args)
+        end
+      end
+
+
+      def << ( arg )
+        each_output do |o|
+          o << arg
+        end
+        self
+      end
+
+    end # class Dumper
+
+  end # module Dumpers
+
+end # module Uttk

data/lib/uttk/dumpers/Html.rb

@@ -0,0 +1,271 @@
+# 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/dumpers/Html.rb 21970 2006-02-19T22:15:36.271512Z pouillar  $
+
+require 'stringio'
+HtmlEncode.import!
+
+module Uttk
+
+  module Dumpers
+
+    #
+    # Use me at least with the Compact filter:
+    #  Compact: [NodeCut: [!skip ^contents$, [Html: [log.html]]]]
+    #
+    class Html < Dumper
+      include Concrete
+      cattr_reader :base_url
+      @@base_url = 'http://api.uttk.org/'
+
+      # Use this one when you have made changes in lib/www
+      # @@base_url = "file://#{Uttk.dir.parent.expand_path}/www/"
+
+      class XmlMarkup < Builder::XmlMarkup #:nodoc:
+        def initialize ( *a, &b )
+          @self = nil
+          super
+        end
+        def itext! ( str )
+          _indent
+          text! str.to_s.chomp
+          _newline
+        end
+        alias_method :html!, :<<
+        def ihtml! ( str )
+          _indent
+          self << str.to_s.chomp
+          _newline
+        end
+        def expand_and_collapse ( type, name )
+          td do
+            a :onClick => "uttk_expand_all(#{type});" do
+              itext! "Expand all #{name}"
+            end
+          end
+          td do
+            a :onClick => "uttk_collapse_all(#{type});" do
+              itext! "Collapse all #{name}"
+            end
+          end
+        end
+      end
+
+      class BaseNode # :nodoc:
+        attr_reader :father, :name, :status, :id, :contents, :state
+
+        @@template_images = Html.base_url + 'images/%%%IMAGE_SPLIT%%%triangle.gif'
+
+        def initialize ( h )
+          @father, @status, @id = h[:father], h[:status], h[:id]
+          @name, @contents, @state = h[:name], h[:contents], h[:state]
+        end
+
+        def unquote ( s )
+          s.gsub('"', '')
+        end
+
+        def html
+          @status ||= ''
+          x = XmlMarkup.new
+          x.div :class => self.class.name.demodulize.underscore do
+            x.table :class => 'title', :id => unquote(status).sub(/\(.+\)/, '') do
+              x.tr do
+                if state == 2
+                  x.td { x.text!(name.to_s + ': ') }
+                  x.td { x.pre clean_yaml_str(contents),
+                               :class => 'attribute_alone' }
+                else
+                  x.td :width => '11px',
+                       :onClick => "uttk_toggle_state(#{id.gsub('"', "'")})" do
+                    x.img :src => @@template_images
+                  end
+                  x.td { x.text!(name.to_s) }
+                  x.td(:width => '20px') { x.text!(unquote(status).gsub('NONE', '')) }
+                end
+              end
+            end
+          end
+          result = x.target!
+          raise unless result =~ /<\/div>\Z/
+          result.sub!(/<\/div>\Z/, '')
+          result.split('%%%IMAGE_SPLIT%%%').map do |x|
+            x.dump
+          end.join(', ')
+        end
+
+        def clean_yaml_str ( anObject )
+          str = ''
+          io = StringIO.new str
+          log = Logger.new(Dumpers::Yaml.new(io))
+          log << anObject
+          log.close
+          io.close
+          str.sub!(/^---\s*/, '')
+          str.chomp!
+          str
+        end
+        private :clean_yaml_str
+      end
+
+      class Node < BaseNode # :nodoc:
+        def to_html_uttk_js ( status_h )
+          @status = status_h[@status]
+          "uttk_add_node(#@id, #@father, #@state, #{html});"
+        end
+      end
+
+      class Leaf < BaseNode # :nodoc:
+        def to_html_uttk_js ( status_h )
+          "uttk_add_leaf(#@id, #@father, #@state, #{html}, #{html_contents});"
+        end
+        def html_contents
+          return '""' if state == 2
+          x = XmlMarkup.new
+          x.table :class => 'attribute' do
+            contents.each do |k, v|
+              x.tr do
+                x.td "#{k}:", :class => 'key'
+                x.td :class => 'value' do
+                  x.pre clean_yaml_str(v), :class => 'attribute'
+                end
+              end
+            end
+          end
+          x.target!.dump
+        end
+      end
+
+
+
+      def initialize ( *a, &b )
+        @uttk_js = base_url + 'javascripts/uttk.js'
+        @uttk_css = base_url + 'stylesheets/uttk.css'
+        super
+        reset
+      end
+
+
+      def reset
+        @current_ids = Hash.new(0)
+        @ids = {}
+        @ids[:node] = { '/' => 'null' }
+        @elts = []
+        @status = Hash.new('"NONE"')
+        @x = Builder::XmlMarkup.new(:target => self, :indent => 2)
+      end
+      protected :reset
+
+
+      def new_node ( path, node )
+        super
+        father = id_of :node, path
+        path << node
+        id = id_of :node, path
+        path << :status
+        status = id_of :status, path
+        @elts << Node.new(:father => father,
+                          :name   => node.segment,
+                          :id     => id,
+                          :status => status,
+                          :state  => 1)
+      end
+      protected :new_node
+
+
+      def new_leaf ( path, leaf )
+        super
+        if path.last.segment == :status
+          @status[id_of(:status, path)] = leaf
+          @elts.pop
+        else
+          father = id_of :node, path
+          path << leaf
+          id = id_of :leaf, path
+          contents = leaf
+          n = @elts.pop
+          father, leaf, id, status = n.father, n.name, n.id, n.status
+          state, status = 0, ''
+          if contents.is_a? Hash
+            status = contents[:status]
+            [:status].each do |k|
+              contents.delete k if contents.has_key? k
+            end
+          else
+            state = 2
+          end
+          @elts << Leaf.new(:father   => father,
+                            :id       => id,
+                            :name     => leaf,
+                            :status   => status,
+                            :state    => state,
+                            :contents => contents)
+        end
+      end
+      protected :new_leaf
+
+
+      def close
+        super
+        x = XmlMarkup.new(:indent => 2, :target => self)
+        x.html do
+          x.head do
+            x.script '', :language => 'javascript', :src => @uttk_js
+            x.style :type => 'text/css' do
+              x.itext! "@import url('#@uttk_css');"
+            end
+            x.script :language => 'javascript' do
+              @elts.each do |elt|
+                x << elt.to_html_uttk_js(@status) << "\n"
+              end
+            end
+          end
+          x.body :onLoad => 'uttk_main()' do
+            x.table :class => 'uttk_infos' do
+              x.tr :class => 'uttk_infos_box' do
+                x.expand_and_collapse 'null', ''
+                x.expand_and_collapse "'node'", 'nodes'
+                x.expand_and_collapse "'leaf'", 'leaves'
+              end
+            end
+            x.div '', :id => 'uttk_contents'
+          end
+        end
+        reset
+      end
+      protected :close
+
+
+      def id_of ( prefix, path )
+        path = path.inspect
+        @ids[prefix] ||= {}
+        result = @ids[prefix][path]
+        if result.nil?
+          result = @ids[prefix][path] = new_id(prefix)
+        end
+        result
+      end
+      protected :id_of
+
+
+      def new_id ( prefix )
+        id = "#{prefix}#{@current_ids[prefix]}"
+        @current_ids[prefix] += 1
+        id.dump
+      end
+      protected :new_id
+
+
+      def self.clean_js_str ( str )
+        res = str.to_s.html_encode.dump
+        res.gsub!(/([^\\])\\n/, '\1<BR>\n')
+        res
+      end
+
+    end # class Html
+
+  end # module Dumpers
+
+end # module Uttk
+

data/lib/uttk/dumpers/Path.rb

@@ -0,0 +1,24 @@
+# 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/dumpers/Path.rb 21970 2006-02-19T22:15:36.271512Z pouillar  $
+
+module Uttk
+
+  module Dumpers
+
+    class Path < Dumper
+      include Concrete
+
+      def new_leaf ( *args )
+        super
+        puts args.to_yaml
+        flush
+      end
+      protected :new_leaf
+
+    end # class Path
+
+  end # module Dumpers
+
+end # module Uttk

data/lib/uttk/dumpers/Xml.rb

@@ -0,0 +1,88 @@
+# Author::    Jerome Pouiller  <pouill_j@epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 Uttk team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/lib/uttk/dumpers/Xml.rb 21970 2006-02-19T22:15:36.271512Z pouillar  $
+
+
+require 'rexml/document'
+
+module Uttk
+
+  module Dumpers
+
+    class Xml < Dumper
+      include Concrete
+
+
+      def initialize ( *a, &b )
+        super
+        puts '<?xml version="1.0" encoding="iso-8859-1"?>'
+        reset
+      end
+
+
+      def reset
+        @doc = @root = REXML::Document.new
+        @doc_stack = []
+      end
+
+
+      def add_elt ( elt, hsh={} )
+        return @doc if @doc.eql? @root and @root.has_elements?
+        @doc = @doc.add_element(REXML::Element.new(clean_for_xml(elt)))
+        hsh.each do |k, v|
+          @doc.add_attribute(clean_for_xml(k), v)
+        end
+        @doc
+      end
+      private :add_elt
+
+
+      def new_node ( path, node )
+        super
+        doc_ = @doc
+        opts = { :name => node.segment }
+        if type = node.options[:type]
+          opts[:type] = type
+        end
+        add_elt(:node, opts)
+        @doc_stack << doc_
+      end
+      protected :new_node
+
+
+      def new_leaf ( path, leaf )
+        super
+        @doc.add_text(leaf.to_s)
+      end
+      protected :new_leaf
+
+
+      def up ( path )
+        super
+        @doc = @doc_stack.pop unless @doc_stack.empty?
+      end
+      protected :up
+
+
+      def close
+        @root.write(self, 0, false)
+        puts
+        reset
+        super
+      end
+      protected :close
+
+
+      def clean_for_xml ( anObject )
+        str = anObject.to_s
+        str.gsub!(/[^a-zA-Z:-_]/, '_')
+        str
+      end
+      protected :clean_for_xml
+
+    end # class Xml
+
+  end # module Dumpers
+
+end # module Uttk