docbook_files 0.4.0 → 0.5.0

data/lib/docbook_files/docbook.rb

@@ -108,7 +108,7 @@ private
       refs = doc.find('//db:*[@fileref!=""]',:db => DOCBOOK_NS)
       refs.map {|r|
         fname = r.attributes['fileref']
-        FileData.new(fname,parent_dir,parent_fd)
+        FileRef.new(fname,parent_dir,parent_fd)
       }
     end
 
@@ -116,7 +116,7 @@ private
     # Returns a FileData object with its include-tree
     #
     def analyze_file(fname, parent_dir, parent_fd=nil)
-      fl = FileData.new(fname, parent_dir, parent_fd)
+      fl = FileRef.new(fname, parent_dir, parent_fd)
       if fl.exists?
         begin
           doc = XML::Document.file(fl.full_name)      

data/lib/docbook_files/file_data.rb

@@ -4,61 +4,78 @@ module DocbookFiles
   require 'digest/sha1'
   require 'wand'
 
-  # Data about a member file of a DocBook project
+  # Represents the actual file that is included or referenced in a DocBook project.
+  # For every file there should only one FileData instance, so we use a factory method
+  # #FileData.for to create new instances.
+  #
   class FileData
 
-    # Type for the main/master file
-    TYPE_MAIN = :main
-    # Type for referenced files
-    TYPE_REFERENCE = :ref
-    # Type for included files
-    TYPE_INCLUDE = :inc
-
     # File exists and no error happened
     STATUS_OK = 0
     # File does not exist
     STATUS_NOT_FOUND = 1
     # Error while processing the file, see #error_string
     STATUS_ERR = 2
+
+    # A storage for all FileData instances. 
+    @@Files = {}
+
+    # The directory of the main file. All #path names are relative to that
+    @@MainDir = ""
     
-    attr_accessor :name, :path, :exists, :includes, :refs
-    attr_accessor :status, :error_string
+    # Return the FileData storage -- for testing only
+    def self.storage; @@Files; end
+
+    # Return all existing FileData instances
+    def self.files; @@Files.values; end
     
-    def FileData.init_vars()
-      x = {:full_name => "file name + path",
-        :ts => "last modified timestamp",
-        :size => "file size",
-        :checksum => "file checksum",
-        :mime => "the file's MIME type",
-        :namespace => "XML namespace, if applicable",
-        :docbook => "DocBook type flag",
-        :version => "DocBook version number, if applicable",
-        :tag => "XML start tag, if applicable",
-        :parent => "parent file, if included or referenced"}
-      x.each  { |s,ex|
-        attr_accessor s
-      }
-      x
+    # Reset the FileData storage -- must be done before every run!
+    def self.reset
+      @@Files={}
+      @@MainDir = ""
     end
-
-    @@vars = init_vars()
     
+    # Factory method for FileData instances. Checks if there is already
+    # an instance. 
+    def self.for(name,parent_dir=".")
+      full_name = get_full_name(name, parent_dir)
+      # Initialize the main dir name for path construction
+      @@MainDir = File.dirname(full_name) if @@Files.size == 0
+      key = full_name
+      if (@@Files[key].nil?)
+        @@Files[key] = FileData.new(name, full_name, key, parent_dir)
+      end
+      @@Files[key]
+    end
+
 
-    def initialize(name,parent_dir=".",parent_file=nil)
-      @path = name
-      @full_name = get_full_name(name, parent_dir)
-      @name = File.basename(name)   
+    attr_accessor :name, :path, :exists
+    attr_accessor :status, :error_string
+    attr_accessor :full_name
+    # Unique key (path+checksum)
+    attr_reader :key
+    # SHA1 checksum, file size in bytes, mime type, last modified timestamp
+    attr_reader :checksum, :size, :mime, :ts
+    # XML data: namespace, docbook flag, namespace version, start tag
+    attr_accessor :namespace, :docbook, :version, :tag
+
+        
+    def initialize(name, full_name, key, parent_dir=".")
+      @path = relative2main(full_name)
+      @full_name = full_name
+      @name = File.basename(name)
+      @key = key
       @namespace = ""
       @docbook = false
       @version = ""
       @tag = ""
       @error_string = nil
-      @parent = (parent_file.nil? ? nil : parent_file.name)
+      @rels = []
       if (File.exists?(@full_name))
         @status = STATUS_OK
         @ts  = File.mtime(full_name)
         @size = File.size(full_name)        
-        @checksum = calc_checksum()
+        @checksum = calc_checksum(full_name)
         @mime = get_mime_type()
       else
         @status = STATUS_NOT_FOUND
@@ -67,9 +84,7 @@ module DocbookFiles
         @checksum = ""
         @mime = ""
         @error_string = "file not found"
-      end
-      @includes = []
-      @refs = []
+      end      
     end
 
 
@@ -78,59 +93,86 @@ module DocbookFiles
       @status != STATUS_NOT_FOUND
     end
 
-    # Return the names and parent files of non-existing files
-    def find_non_existing_files
-      files = traverse([:name, :status, :parent])
-      files.flatten.reject{|f| f[:status] != STATUS_NOT_FOUND}.map{|f| f.delete(:status); f}
+    # Add a one-way relationship, type and target, to self
+    def add_rel(type, target)
+      @rels << {:type => type, :target => target}
     end
-
-    # Return a tree-like array with all names
-    def names
-      self.traverse([:name])
+    # Add a two-way relationship between self and a number of targets. 
+    def add_rels(type, invtype, targets)
+      targets.each {|t|
+        self.add_rel(type, t)
+        t.add_rel(invtype, self)
+      }
     end
-
-    # Return a hash with the values for the passed symbols.
-    # The type is added.
-    # 
-    # Example: to_hash([:name, :mime]) would return 
-    #  {:name => "name", :mime => "application/xml"}.
+    # Get all targets for a relation
+    def get_rel_targets(type)
+      @rels.find_all{|rel| rel[:type] == type}.map{|r| r[:target]}
+    end
+    
+    # Add included FileDatas. Establishes a two way relationship between self
+    # and the included files:
     #
-    def to_hash(props,type)
-      me_hash = {:type => type}
-      props.each {|p| me_hash[p] = self.send(p)}
-      me_hash
+    # self -> TYPE_INCLUDE -> target
+    # self <- TYPE_INCLUDED_BY <- target
+    #
+    # TODO: should be 'add_includes'
+    def add_includes(incs)
+      add_rels(FileRefTypes::TYPE_INCLUDE, FileRefTypes::TYPE_INCLUDED_BY, incs)
+    end
+    # Retrieves all included FileDatas
+    def includes
+      get_rel_targets(FileRefTypes::TYPE_INCLUDE)
+    end
+    # Retrieves all FileDatas that include self
+    def included_by
+      get_rel_targets(FileRefTypes::TYPE_INCLUDED_BY)
     end
 
-    # Return a tree-like array of maps with the 
-    # requested properties (symbols)
-    def traverse(props=[],type=TYPE_MAIN)
-      me = self.to_hash(props,type)
-      me2 = [me]
-      unless @refs.empty?()
-        me2 += @refs.map {|r| r.to_hash(props,TYPE_REFERENCE)}
-      end
-      if @includes.empty?()
-        me2
+    # Add referenced FileDatas. Establishes a two way relationship between self
+    # and the referenced files:
+    #
+    # self -> TYPE_REFERENCE -> target
+    # self <- TYPE_REFERENCED_BY <- target
+    #
+    def add_references(incs)
+      add_rels(FileRefTypes::TYPE_REFERENCE, FileRefTypes::TYPE_REFERENCED_BY, incs)
+    end
+    # Retrieves all referenced files
+    def references
+      get_rel_targets(FileRefTypes::TYPE_REFERENCE)
+    end
+    # Retrieves all FileDatas that reference self
+    def referenced_by
+      get_rel_targets(FileRefTypes::TYPE_REFERENCED_BY)
+    end
+    
+    # Try to find the path of _file_name_ that is relative to directory
+    # of the _main file_.
+    # If there is no common part return the _file_name_.
+    def relative2main(file_name)
+      md = file_name.match("^#{@@MainDir}/")
+      if md.nil?
+        file_name
       else
-        me2 + @includes.map {|i| i.traverse(props,TYPE_INCLUDE)}
+        md.post_match
       end
     end
 
-    # Return a table-like array of maps with the 
-    # requested properties (symbols). Each entry gets a level 
-    # indicator (:level) to show the tree-level.
+    # Return a hash with the values for the passed symbols.
+    # 
+    # Example: to_hash([:name, :mime]) would return 
+    #  {:name => "name", :mime => "application/xml"}.
     #
-    def traverse_as_table(props,level=0,type=TYPE_MAIN)
-      me = self.to_hash(props,type)
-      me[:level] = level
-      me2 = [me]
-      unless @refs.empty?()
-        me2 += @refs.map {|r| x = r.to_hash(props,TYPE_REFERENCE); x[:level] = level+1; x}
-      end
-      unless @includes.empty?()
-        me2 += @includes.map {|i| i.traverse_as_table(props,level+1,TYPE_INCLUDE)}
-      end
-      me2.flatten
+    def to_hash(props)
+      me_hash = {}      
+      props.each {|p|
+        if ([:includes, :included_by, :references, :referenced_by].member?(p))
+          me_hash[p] = self.send(p).map{|p2| p2.path}
+        else
+          me_hash[p] = self.send(p)
+        end
+      }
+      me_hash
     end
 
 private
@@ -140,17 +182,17 @@ private
     #--
     # Includes hack for Ruby 1.8
     #++
-    def calc_checksum
+    def calc_checksum(full_name)
       if RUBY_VERSION=~ /^1.8/
-        contents = open(@full_name, "rb") {|io| io.read }
+        contents = open(full_name, "rb") {|io| io.read }
       else
-        contents = IO.binread(@full_name)
+        contents = IO.binread(full_name)
       end
       Digest::SHA1.hexdigest(contents)
     end
 
     # Produce the full path for a filename
-    def get_full_name(fname, parent_dir)
+    def self.get_full_name(fname, parent_dir)
       dir = File.dirname(fname)
       file = File.basename(fname)
       full_name = File.expand_path(file,dir)

data/lib/docbook_files/file_ref.rb

@@ -0,0 +1,98 @@
+# -*- encoding:utf-8 -*-
+module DocbookFiles
+
+  # A FileRef represents a file inclusion (<xi:include href='...') or
+  # reference (<imagedata filref=='...') in DocBook. It points to a FileData
+  # instance, that represents the actual file. Multiple FileRefs can point to
+  # the same FileData.
+  #
+  # A FileRef contains
+  # * the parent FileRef
+  # * the kind of relation (included or referenced)
+  # * the FileData instance
+  #
+  class FileRef
+
+    # TODO file and line?
+    attr_accessor :rel_type, :file_data, :parent
+    attr_reader :includes, :refs
+    
+    def initialize(name,parent_dir=".",parent_file=nil)
+      @file_data = FileData.for(name,parent_dir)
+      @parent = (parent_file.nil? ? nil : parent_file.name)
+      @includes = []
+      @refs = []
+    end
+
+    def method_missing(name, *args, &block)
+      @file_data.send(name,*args, &block)
+    end
+
+    def includes=(incs)
+      @includes = incs
+      @file_data.add_includes(incs.map{|inc| inc.file_data})
+    end
+
+    def refs=(refs)
+      @refs = refs
+      @file_data.add_references(refs.map{|ref| ref.file_data})
+    end
+    
+    # Return a hash with the values for the passed symbols.
+    # The type is added.
+    # 
+    # Example: to_hash([:name, :mime]) would return 
+    #  {:type => "main", :name => "name", :mime => "application/xml"}.
+    #
+    def to_hash(props,type)
+      me_hash = {:type => type}
+      props.each {|p| me_hash[p] = self.send(p)}
+      me_hash
+    end
+
+    # Return a tree-like array of maps with the 
+    # requested properties (symbols)
+    def traverse(props=[],type=FileRefTypes::TYPE_MAIN)
+      me = self.to_hash(props,type)
+      me2 = [me]
+      unless self.refs.empty?()
+        me2 += self.refs.map {|r| r.to_hash(props,FileRefTypes::TYPE_REFERENCE)}
+      end
+      if self.includes.empty?()
+        me2
+      else
+        me2 + self.includes.map {|i| i.traverse(props,FileRefTypes::TYPE_INCLUDE)}
+      end
+    end
+
+    # Return the names and parent files of non-existing files
+    def find_non_existing_files
+      files = traverse([:name, :status, :parent])
+      files.flatten.reject{|f| f[:status] != FileData::STATUS_NOT_FOUND}.map{|f| f.delete(:status); f}
+    end
+
+    # Return a tree-like array with all names
+    def names
+      self.traverse([:name])
+    end
+
+    
+    # Return a table-like array of maps with the 
+    # requested properties (symbols). Each entry gets a level 
+    # indicator (:level) to show the tree-level.
+    #
+    def traverse_as_table(props,level=0,type=FileRefTypes::TYPE_MAIN)
+      me = self.to_hash(props,type)
+      me[:level] = level
+      me2 = [me]
+      unless self.refs.empty?()
+        me2 += self.refs.map {|r| x = r.to_hash(props,FileRefTypes::TYPE_REFERENCE); x[:level] = level+1; x}
+      end
+      unless self.includes.empty?()
+        me2 += self.includes.map {|i| i.traverse_as_table(props,level+1,FileRefTypes::TYPE_INCLUDE)}
+      end
+      me2.flatten
+    end
+    
+  end
+end

data/lib/docbook_files/file_ref_types.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+module DocbookFiles
+  
+  # Contains thre reference type for relations between files in DocBook.
+  class FileRefTypes
+    
+    # Type for the main/master file
+    TYPE_MAIN = :main
+    
+    # Type for referenced files (via fileref attribute)
+    TYPE_REFERENCE = :ref
+    TYPE_REFERENCED_BY = :refdby
+    
+    # Type for included files (XInclude)
+    TYPE_INCLUDE = :inc
+    TYPE_INCLUDED_BY = :incdby
+
+  end
+end

data/spec/docbook_files/app_spec.rb

@@ -1,24 +1,17 @@
 # -*- encoding:utf-8 -*-
 require_relative '../spec_helper'
+require 'stringio'
 
 module DocbookFiles
   describe App do
 
     describe "displays file names" do
+      
       it "according to level" do
         a = App.new
-        main_n = '/dir1/dir2/dir3/book.xml'
-        main_d = '/dir1/dir2/dir3/'
-        a.format_name(0,main_n,main_n).should == 'book.xml'
-        a.format_name(2,main_d+'chapter.xml',main_n).should == '    chapter.xml'
-        a.format_name(3,main_d+'dir4/chapter.xml',main_n).should == '      dir4/chapter.xml'
-      end
-
-      it "in full when not below main file" do
-        a = App.new
-        main_n = '/dir1/dir2/dir3/book.xml'
-        main_d = '/dir1/dir2/dir3/'
-        a.format_name(2,'/dir1/dir2/chapter4.xml',main_n).should == '    /dir1/dir2/chapter4.xml'
+        a.format_name(0,'book.xml').should == 'book.xml'
+        a.format_name(2,'chapter.xml').should == '    chapter.xml'
+        a.format_name(3,'chapter.xml').should == '      chapter.xml'
       end
 
       it "shortened when too long" do
@@ -26,10 +19,11 @@ module DocbookFiles
         main_d = '/dir1/dir2'*5
         main_d2 = '/dir0/dir1/dir2'*5
         main_n = main_d+'/book.xml'
-        a.format_name(2,main_d+'/chapter.xml',main_n).should == '    chapter.xml'
+        a.format_name(2,main_d+'/chapter.xml').should ==
+          '    ...r2/dir1/dir2/dir1/dir2/dir1/dir2/dir1/dir2/chapter.xml'
         expected = "    ...r0/dir1/dir2/dir0/dir1/dir2/dir0/dir1/dir2/chapter.xml"
-        a.format_name(2,main_d2+'/chapter.xml',main_n).should == expected
-        a.format_name(2,main_d2+'/chapter.xml',main_n).length.should == 61
+        a.format_name(2,main_d2+'/chapter.xml').should == expected
+        a.format_name(2,main_d2+'/chapter.xml').length.should == 61
       end
 
     end
@@ -47,5 +41,65 @@ module DocbookFiles
       a.format_size(1024 + App::TB).should == "1TB"
       a.format_size(1024 + App::PB).should == "XXL"
     end
+
+    it "can use YAML as output format" do
+      stdout1 = StringIO.new
+      stderr1 = StringIO.new
+      a = App.new({:stdout => stdout1, :stderr => stderr1})
+      a.run(['--outputformat=yaml','spec/fixtures/bookxi.xml'])
+      stderr1.string.should == ""
+      stdout1.string.should_not == ""
+      yml = YAML.load(stdout1.string)
+      yml.size.should == 2
+      hier = yml[:hierarchy]
+      det = yml[:details]
+      hier.size.should == 5      
+      hier[0][:type].should == :main
+      hier[0][:path].should == "bookxi.xml"
+      hier[0][:level].should == 0
+      hier[4][:type].should == :inc
+      hier[4][:path].should == "c4/chapter4xi.xml"
+      hier[4][:level].should == 1
+      det.size.should == 5
+      det[0][:path].should == "bookxi.xml"
+      det[0][:error_string].should be_nil
+      det[0][:includes].should == ["chapter2xi.xml", "chapter3xi.xml", "c4/chapter4xi.xml"]
+      det[0][:included_by].should be_empty
+      det[4][:path].should == "c4/chapter4xi.xml"
+      det[4][:error_string].should be_nil
+      det[4][:includes].should be_empty
+      det[4][:included_by].should == ["bookxi.xml"]      
+    end
+    
+    it "can use JSON as output format" do
+      stdout1 = StringIO.new
+      stderr1 = StringIO.new
+      require 'json'
+      a = App.new({:stdout => stdout1, :stderr => stderr1, :json_available => true})
+      a.run(['--outputformat=json','spec/fixtures/bookxi.xml'])
+      stderr1.string.should == ""
+      stdout1.string.should_not == ""
+      yml = JSON.parse(stdout1.string)
+      yml.size.should == 2
+      hier = yml["hierarchy"]
+      det = yml["details"]
+      hier.size.should == 5 
+      hier[0]["type"].should == "main"
+      hier[0]["path"].should == "bookxi.xml"
+      hier[0]["level"].should == 0
+      hier[4]["type"].should == "inc"
+      hier[4]["path"].should == "c4/chapter4xi.xml"
+      hier[4]["level"].should == 1
+      det.size.should == 5
+      det[0]["path"].should == "bookxi.xml"
+      det[0]["error_string"].should be_nil
+      det[0]["includes"].should == ["chapter2xi.xml", "chapter3xi.xml", "c4/chapter4xi.xml"]
+      det[0]["included_by"].should be_empty
+      det[4]["path"].should == "c4/chapter4xi.xml"
+      det[4]["error_string"].should be_nil
+      det[4]["includes"].should be_empty
+      det[4]["included_by"].should == ["bookxi.xml"]            
+    end
+        
   end
 end