rscm-accurev 0.0

data/lib/rscm/scm/accurev/exception.rb

@@ -0,0 +1,38 @@
+# -*- ruby -*-
+#
+# = exception.rb
+#
+# Exception classes for RSCM::Accurev
+#
+# Includes:
+#
+# * AccurevException
+#
+# * StaleWorkspaceException
+#
+module RSCM
+  module Accurev
+    
+    #
+    # General exception class for errors processing commands.
+    #
+    # @attr error_msg Error message output by accurev.
+    #
+    class AccurevException < Exception
+      attr_reader :error_msg
+      def initialize( msg, error_msg=nil )
+        super( "#{msg}: #{error_msg}" )
+        @error_msg = error_msg
+      end     
+    end
+    
+    #
+    # Exception thrown when an update is performed
+    # on a workspace with unkept/unanchored modifications.
+    # Accurev requires that all modifications be handled before
+    # an update is performed.
+    #
+    class StaleWorkspaceException < AccurevException; end
+
+  end
+end

data/lib/rscm/scm/accurev/filterio.rb

@@ -0,0 +1,57 @@
+require 'stringio'
+
+module RSCM
+  module Accurev
+
+    #
+    # IO stream which cleans irregularities out of accurev xml output.
+    #
+    # In particular:
+    #
+    # * Unlike other commands, the +-fx+ output from _accurev update_
+    #   has a root element of +<acResponse>+, not +<AcResponse>+.
+    #
+    # * _accurev update_ emits broken XML when there are no files
+    #   to update.
+    #
+    class AcXMLScrubIO < StringIO
+
+      # @param: sourceio - io or string source to wrap
+      def initialize( sourceio )
+        if sourceio.respond_to?( :read )
+          super( clean( sourceio.read ) )
+        else
+          super( clean(sourceio) )
+        end
+      end
+
+      def clean( source )
+        File.open( "/tmp/scrubio.outA", "w" ).puts( source )
+        source.gsub!( /<acResponse/, "<AcResponse" )
+        source.gsub!( /<\/acResponse/, "<\/AcResponse" )
+        File.open( "/tmp/scrubio.outB", "w" ).puts( source )
+        source.gsub!( /command="update"[^>]*(>?)/, 'command="update"\1' )
+        File.open( "/tmp/scrubio.outC", "w" ).puts( source )
+        return source
+      end
+    end
+
+
+    #
+    # Simple filtering IO implementation.
+    # 
+    #   io = RSCM::Accurev::FilterIO.new( otherio ) do |string|
+    #          string.gsub( "2", "fifty-one" )
+    #        end
+    #
+    class FilterIO < StringIO
+      def initialize( sourceio, &filter )
+        str = filter.call( sourceio.read )
+        super( str )
+      end
+    end
+
+
+  end
+
+end

data/lib/rscm/scm/accurev/xml.rb

@@ -0,0 +1,224 @@
+module RSCM; module Accurev; end; end
+
+require 'rexml/element'
+
+module RSCM::Accurev
+
+  #
+  # XMLMapper creates an object tree from an XML element and its children.
+  #
+  # For each XML node, it locates a class associated with that node's name,
+  # and builds a new object of that type from the element.
+  #
+  # The nodename-class associations are determined by finding all 
+  # classes derived from ElementBackedClass and checking
+  # each of those classes +element_name+ methods.
+  #
+  # See ElementBackedClass for examples.
+  #
+  class XMLMapper
+
+    # Map of element (tag) names to (ruby) class.
+    attr_accessor :classmap
+
+    def initialize()
+      @classmap = {}
+      ObjectSpace.each_object( Class ) do |k|
+        if k.ancestors.delete( ElementBackedClass ) and k != ElementBackedClass
+          if k.respond_to?( :element_name )
+            @classmap[ k.element_name ] = k
+          end
+        end
+      end
+    end
+
+    #
+    # Build an object tree from the given REXML element and its children.
+    # The returned object will be a subclass of +ElementBackedClass+.
+    #
+    def map( e )
+      unless @classmap.has_key?( e.name )
+        return nil
+      end
+      o = @classmap[e.name].new( e )
+      e.children.each do |child|
+        if child.kind_of?( REXML::Element )
+          a = self.map( child )
+          unless a.nil?
+            if o.children[ a.class.element_name ].nil?
+              o.children[ a.class.element_name ] = []
+            end
+            o.children[ a.class.element_name ] << a
+          end
+        end
+      end
+      return o
+    end
+  end
+
+  #
+  # Abstract base class for defining typed mirror classes for XML elements.
+  #
+  # A subclass of ElementBackedClass has:
+  #
+  # * A class static +element_name+ method, identifying what
+  #   type of XML element it shadows
+  #
+  # * A set of attributes shadowing the XML attributes of its target element
+  #
+  # * A map (+children+) of child elements, keyed by element name
+  #
+  # * A (optional) +text_content+ attribute, populated when the
+  #   target element has text subnodes.
+  #
+  # ---
+  #
+  # === Example
+  #
+  # For the XML element:
+  #
+  #    <book title="The Monkey Wrench Gang" author="Edward Albee">
+  #      <note>Lots of beer and dynamite</note>
+  #    </book>
+  #
+  # You can define:
+  #
+  #    class Book < ElementBackedClass
+  #      element_name 'book'
+  #      attr_accessor :title, :author
+  #    end
+  #
+  # And then use XMLMapper to create instances:
+  #
+  #    e = ...; # <book> node: REXML::Element
+  #    book = XMLMapper.map(e)
+  #    puts "Title: #{book.title}"
+  #    puts "Author: #{book.author}"
+  #    puts "Notes:"
+  #    book['note'].each do |n|
+  #      puts n.text_content
+  #    end
+  #
+  class ElementBackedClass
+
+    attr_accessor :children
+
+    def self.element_name( name )
+      class << self
+        self
+      end.send( :define_method, "element_name" ) {name}
+    end
+
+    # currently advisory only
+    def self.children( *kidtypes )
+      # nothing XXX
+    end
+
+    def initialize( element=nil )
+      @children = {}
+      unless element.nil?
+        self.set_from_element(element)
+      end
+    end
+
+    # ebc['foo'] is a synonym for ebc.children['foo']   
+    def []( key )
+      return self.children[key]
+    end
+
+    def to_s
+      s = "<#{self.class.element_name} "
+      self.instance_variables.each do |a|
+        unless a == "@children"
+          attr = a.sub( /^@/, "" )
+          s += "#{attr}='#{self.send(attr)}' "
+        end
+      end
+      s += "/>"
+      return s
+    end
+
+  protected
+    # Does the work of calling object setters for each XML attribute.
+    def set_from_element( e )
+      e.attributes.each do |attr, value|
+        # downcase the attr name for method-happiness
+        # (also hacks around some inconsistent accurev attr names...)
+        mattr = attr.downcase
+        if self.respond_to?( "#{mattr}=" )
+          self.send( "#{mattr}=", value )
+        end
+      end
+      if self.respond_to?( :text_content= ) and ! e.text.nil?
+        self.text_content = e.text
+      end
+    end
+
+  end
+
+  #
+  # Data from the typical AcResponse root node.
+  # 
+  class AcResponseData < ElementBackedClass
+    element_name 'AcResponse'
+    attr_accessor :command, :directory
+
+    # Returns this response's error message, or nil if no error detected.
+    def error
+      if self.children['message']
+        zmsg = self.children['message'][0]
+        if zmsg.error and zmsg.error == 'true'
+          return zmsg.text_content
+        end
+      else
+        return nil
+      end
+    end
+  end
+  
+  #
+  # Data from "accurev file", "accure update", "accurev stat" commands.
+  # Identifies workspace objects (files, directories, etc).
+  #
+  class ElementData < ElementBackedClass
+    element_name 'element'
+    attr_accessor :location, :status, :dir, :id
+    attr_accessor :elemType, :namedVersion, :virtual, :real
+  end
+  
+  #
+  # Data from "accurev {file,update,stat}" commands.
+  # Streamed status/info messages, usually interleaved with ElementData
+  # nodes.
+  #
+  class MessageData < ElementBackedClass
+    element_name 'message'
+    attr_accessor :error, :text_content
+  end
+
+  #
+  # Version (element) records in a history transaction
+  #
+  class VersionData < ElementBackedClass
+    element_name 'version'
+    attr_accessor :path, :eid, :virtual, :real, :elem_type
+  end
+
+  # 
+  # Commit messages on transactions
+  #
+  class CommentData < ElementBackedClass
+    element_name 'comment'
+  end
+
+  #
+  # Data from "accurev hist" - transaction groups
+  # Contains one or more VersionData.
+  #
+  class TransactionData < ElementBackedClass
+    element_name 'transaction'
+    children VersionData, CommentData
+    attr_accessor :id, :type, :time, :user
+  end
+
+end

data/lib/test/unit/ui/xml/testrunner.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+
+require 'test/unit/ui/testrunnermediator'
+require 'test/unit/ui/testrunnerutilities'
+require 'test/unit/ui/console/testrunner'
+require 'test/unit/autorunner'
+require 'rexml/document'
+
+module Test
+  module Unit
+    module UI
+      module XML
+
+        #
+        # XML::TestRunner - generate xml output for test results
+        #
+        # Example use:
+        #
+        #   $ ruby -rtest/unit/ui/xml/testrunner test/test_1.rb --runner=xml
+        #
+        # By default, XML::TestRunner will output to stdout.
+        # You can set the environment variable $XMLTEST_OUTPUT to
+        # a filename to send the output to that file.
+        #
+        # The summary file created by this testrunner is XML, but 
+        # this module also includes a stylesheet
+        # (test/unit/ui/xml/xmltestrunner.xslt) which converts it to
+        # HTML.  Copy the XSLT file into the same directory as the 
+        # test results file, and open the results file with a browser.
+        #
+        # --- 
+        # 
+        # (todo: use with rake)
+        #
+        class TestRunner < Test::Unit::UI::Console::TestRunner
+
+          def initialize( suite, output_level )
+            super( suite )
+            if ENV['XMLTEST_OUTPUT']
+              fn = ENV['XMLTEST_OUTPUT']
+              puts "Writing to #{fn}"
+              @io = File.open( fn, "w" )
+              @using_stdout = false
+            else
+              puts "Writing to stdout (along with everyone else...)"
+              @io = STDOUT
+              @using_stdout = true
+            end
+            create_document()
+          end
+
+          def create_document()
+            @doc = REXML::Document.new()
+            @doc << REXML::XMLDecl.new()
+            
+            pi = REXML::Instruction.new(
+                   "xml-stylesheet",
+                   "type='text/xsl' href='xmltestrunner.xslt' "
+            )
+            @doc << pi
+
+            e = REXML::Element.new( "testsuite" )
+            e.attributes['rundate'] = Time.now
+            @doc << e
+          end
+
+          def to_s
+            @doc.to_s
+          end
+
+          def start
+            @current_test = nil
+            # setup_mediator
+            @mediator = TestRunnerMediator.new( @suite )
+            suite_name = @suite.to_s
+            if @suite.kind_of?(Module)
+              suite_name = @suite.name
+            end
+            @doc.root.attributes['name'] = suite_name
+            # attach_to_mediator - define callbacks
+            @mediator.add_listener( TestResult::FAULT, 
+                                    &method(:add_fault) )
+            @mediator.add_listener( TestRunnerMediator::STARTED,
+                                    &method(:started) )
+            @mediator.add_listener( TestRunnerMediator::FINISHED,
+                                    &method(:finished) )
+            @mediator.add_listener( TestCase::STARTED, 
+                                    &method(:test_started) )
+            @mediator.add_listener( TestCase::FINISHED, 
+                                    &method(:test_finished) )
+            # return start_mediator
+            return @mediator.run_suite
+          end
+
+          # callbacks
+
+          def add_fault( fault )
+            ##STDERR.puts "Fault:"
+            @faults << fault
+            e = REXML::Element.new( "fault" )
+            e << REXML::CData.new( fault.long_display ) 
+            @current_test << e
+          end
+
+          def started( result )
+            #STDERR.puts "Started"
+            @result = result
+          end
+
+          def finished( elapsed_time )
+            #STDERR.puts "Finished"
+            res = REXML::Element.new( "result" )
+            summ = REXML::Element.new( "summary" )
+            summ.text = @result
+            res << summ
+            # @result is a Test::Unit::TestResults
+            res.attributes['passed'] = @result.passed?
+            res.attributes['testcount'] = @result.run_count
+            res.attributes['assertcount'] = @result.assertion_count
+            res.attributes['failures'] = @result.failure_count
+            res.attributes['errors'] = @result.error_count
+            @doc.root << res
+
+            e = REXML::Element.new( "elapsed-time" )
+            e.text = elapsed_time
+            @doc.root << e
+            @io.puts( @doc.to_s )
+            
+            unless @using_stdout
+              puts @result
+            end
+          end
+          
+          def test_started( name )
+            #STDERR.puts "Test: #{name} started"
+            e = REXML::Element.new( "test" )
+            e.attributes['name'] = name
+            #e.attributes['status'] = "failed"
+            @doc.root << e
+            @current_test = e
+          end
+
+          def test_finished( name )
+            #STDERR.puts "Test: #{name} finished"
+            # find //test[@name='name']
+            @current_test = nil
+          end
+
+        end
+      end
+    end
+  end
+end
+
+# "plug in" xmltestrunner into autorunner's list of known runners
+# This enables the "--runner=xml" commandline option.
+Test::Unit::AutoRunner::RUNNERS[:xml] = proc do |r|
+  require 'test/unit/ui/xml/testrunner'
+  Test::Unit::UI::XML::TestRunner
+end
+
+if __FILE__ == $0
+  Test::Unit::UI::XML::TestRunner.start_command_line_test
+end
+