deplate 0.7.3

data/lib/deplate/etc.rb

@@ -0,0 +1,199 @@
+# etc.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     16-Okt-2005.
+# @Last Change: 01-Nov-2005.
+# @Revision:    0.30
+
+require 'deplate/common'
+
+class Deplate::PseudoContainer < Deplate::BaseElement
+    attr_accessor :registered_metadata
+    attr_reader   :destination
+    
+    def initialize(deplate, args)
+        super(deplate, args)
+        @level_as_string     = args[:level_as_string]
+        @top_heading         = args[:top] || deplate.get_current_top
+        @registered_metadata = args[:metadata] || []
+        @accum               = args[:accum] || []
+        @destination         = ''
+    end
+    
+    def log(text, condition=nil)
+        Deplate::Core.log(text, condition, @source)
+    end
+
+    def output_file_name(args={})
+        basename = args[:basename]
+        rv = @top_heading ? @top_heading.output_file_name : @destination
+        if basename
+            return File.basename(rv)
+        else
+            return rv
+        end
+    end
+end
+
+
+class Deplate::NullTop < Deplate::PseudoContainer
+    attr_reader   :args, :caption
+    attr_accessor :first_top, :last_top, :description
+
+    def initialize(deplate, args)
+        super
+        @destination = args[:destination]
+        @args        = {:id => "deplateNullTop"}
+        @caption     = deplate.msg("[Start]")
+        @description = nil
+        @first_top   = false
+        @last_top    = false
+    end
+    
+    alias :output_location :output_file_name
+end
+
+
+class Deplate::Source
+    attr_accessor :file, :begin, :end, :level_as_string, :stats
+    
+    def initialize(*args)
+        @file, @stats, @begin, @end, @level_as_string = args
+    end
+
+    def log(text, mode)
+        Deplate::Core.log(text, mode, self)
+    end
+end
+
+
+module Deplate::Symbols
+end
+
+
+class Deplate::Variables < Hash
+    attr_accessor :deplate
+    
+    def initialize(deplate=nil)
+        super()
+        @deplate = deplate
+    end
+  
+    def update(hash)
+        for key, val in hash
+            self[key] = val
+        end
+    end
+    
+    def []=(name, value)
+        if (m = /^(\S+)\[(\S+)?\]$/.match(name))
+            key   = m[1]
+            field = m[2]
+            var   = self[key]
+            if !var
+                if !field
+                    self[key] = [value]
+                elsif field =~ /^[0-9]$/
+                    self[key] = []
+                    self[key][field.to_i] = value
+                else
+                    self[key] = {field => value}
+                end
+            elsif var.kind_of?(Struct) || var.kind_of?(OpenStruct)
+                var.send("#{field}=", value)
+            elsif var.kind_of?(Hash)
+                var[field] = value
+            elsif var.kind_of?(Array)
+                if !field
+                    var << value
+                elsif field =~ /^[0-9]+$/
+                    field = field.to_i
+                    var[field] = value
+                else
+                    Deplate::Core.log(["Wrong index", field, name, var.class], :error)
+                end
+            elsif var
+                Deplate::Core.log(["Doc variable has wrong type", key, var.class], :error)
+            end
+        else
+            super
+        end
+    end
+    
+    def [](name)
+        begin
+            if keys.include?(name)
+                return super
+            elsif name =~ /^\S+\(.*\)$/
+                m = /^(\S+)\((.*?)?\)$/.match(name)
+                if m
+                    method = m[1]
+                    args   = m[2]
+                    args, text = @deplate.input.parse_args(args, nil, false)
+                    return @deplate.invoke_service(method, args, text)
+                else
+                    Deplate::Core.log(["Malformed variable name", name], :error)
+                end
+            elsif (m = /^(\S+)\[(\S+)\]$/.match(name))
+                key   = m[1]
+                field = m[2]
+                var   = self[key]
+                if var.kind_of?(Struct) || var.kind_of?(OpenStruct)
+                    return var.send(field)
+                elsif var.kind_of?(Hash)
+                    return var[field]
+                elsif var.kind_of?(Array)
+                    if field =~ /^[0-9]+$/
+                        field = field.to_i
+                        return var[field]
+                    else
+                        Deplate::Core.log(['Wrong index', field, name, var.class], :error)
+                    end
+                elsif var
+                    # <+TBD+> this is unsave
+                    # return var.send(field)
+                    Deplate::Core.log(['Variable has wrong type', key, var.class], :error)
+                else
+                    Deplate::Core.log(['Unknown variable', key], :error)
+                end
+            end
+        rescue Exception => e
+            Deplate::Core.log(['Retrieving doc variable failed', name, e], :error)
+        end
+        return nil
+    end
+end
+
+module Deplate::Void
+end
+
+# Based on code by:
+# From: Florian Gross, flgr AT ccan.de
+# Newsgroups: comp.lang.ruby
+# Subject: Re: safe eval?
+# Date: Mon, 10 May 2004 19:52:27 +0200
+# Message-ID: <2g9tqcFbpc6U1@uni-berlin.de>
+module Deplate::Safe; end
+class << Deplate::Safe
+    def safe(level, code, sandbox=nil)
+        error = nil
+
+        begin
+            thread = Thread.new do
+                $-w = nil
+                sandbox ||= Object.new.taint
+                yield(sandbox) if block_given?
+                $SAFE = level
+                eval(code, sandbox.send(:binding))
+            end
+            value = thread.value
+            result = Marshal.load(Marshal.dump(thread.value))
+        rescue Exception => error
+            error = Marshal.load(Marshal.dump(error))
+        end
+
+        return result, error
+    end
+end
+

data/lib/deplate/external.rb

@@ -0,0 +1,135 @@
+# external.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     04-Sep-2004.
+# @Last Change: 28-Okt-2005.
+# @Revision:    0.168
+
+require "ps2ppm"
+
+# Description:
+# 
+# Usage:
+# 
+# TODO:
+# 
+# CHANGES:
+# 
+
+module Deplate::External
+    @@apps = {}
+    
+    module_function
+    def def_app(name, filename)
+        @@apps[name] = filename
+    end
+
+    def get_app(name, default=nil)
+        @@apps[name] || default || name
+    end
+
+    def log_popen(container, cmd)
+        rv = []
+        if container.deplate.options.allow_external
+            container.log(["PWD", Dir.pwd])
+            container.log(["Exec", cmd])
+            begin
+                IO.popen(cmd, "w+") do |io|
+                    if block_given?
+                        yield(io)
+                    else
+                        until io.eof
+                            l = io.gets
+                            rv << l
+                            puts l
+                        end
+                    end
+                end
+            rescue StandardError => e
+                container.log(["Error when running command", cmd, e], :error)
+            end
+        else
+            container.log(["Disabled", cmd], :error)
+            container.log("Use -X command line option to enable external commands", :newbie)
+        end
+        return rv.join("\n")
+    end
+
+    # The method assumes that the file should be created in the current 
+    # directory, i.e., that the proper working directory was previously  
+    # set
+    def write_file(container, filename, &block)
+        if container.deplate.options.allow_external
+            File.open(filename, "w") {|io| block.call(io)}
+        end
+    end
+
+    def latex(instance, texfile)
+        log_popen(instance, "#{get_app('latex')} -interaction=nonstopmode #{texfile}")
+    end
+
+    def kpsewhich(instance, bibfile)
+        bibfile = File.basename(bibfile)
+        log_popen(instance, "#{get_app('kpsewhich')} #{bibfile}")
+    end
+    
+    def dvi2ps(instance, dvifile, psfile, other_options=nil)
+        log_popen(instance, "#{get_app('dvips')} -E -Z -D 300 #{other_options} -o #{psfile} #{dvifile}")
+    end
+
+    def ps2img(instance, device, psfile, outfile, args)
+        r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 96
+        # r = args["rx"] || instance.deplate.variables["ps2imgRes"] || 120
+        # r = args["rx"] || 140
+        # case device
+        # when "pdf"
+        #     log_popen(instance, "#{get_app('ps2pdf'} #{psfile} #{outfile}")
+        # else
+        #     log_popen(instance, "#{get_app('ps2ppm'} -o -r #{r} -g -t -f #{device} #{psfile}")
+        #     log_popen(instance, "#{get_app('convert'} -antialias -density #{r}x#{r} #{psfile} #{outfile}")
+            Ps2ppm.run(psfile, "o" => true, "r" => r, "g" => true, "t" => true, "f" => device)
+        # end
+    end
+
+    def dot(instance, device, dotfile, outfile, command_line_args=[])
+        c = command_line_args.join(" ")
+        log_popen(instance, "#{get_app('dot')} -T#{device} -o#{outfile} #{c} #{dotfile}")
+    end
+
+    def neato(instance, device, dotfile, outfile, command_line_args=[])
+        c = command_line_args.join(" ")
+        log_popen(instance, "#{get_app('neato')} -T#{device} -o#{outfile} #{c} #{dotfile}")
+    end
+
+    def r(instance, rfile, outfile)
+        c = "#{get_app('R')} CMD BATCH --slave --restore --no-save #{rfile} #{outfile}"
+        log_popen(instance, c)
+    end
+
+    # return the bounding box as [bw, bh, bx, by]
+    def image_dimension(filename)
+        # `identify "#{filename}"`.scan(/(\d+)x(\d+)\+(\d+)\+(\d+)/).flatten
+        rv = {}
+        begin
+            unless filename =~ /\.(pdf)$/
+                for line in `#{get_app('identify')} -verbose "#{filename}"`
+                    if line =~ /^\s*Geometry: /
+                        bw = line.scan(/(\d+)x(\d+)(\+(\d+)\+(\d+))?/).flatten
+                        bw.delete_at(2)
+                        rv[:bw] = bw.collect {|x| x ? x.to_i : nil}
+                    elsif line =~ /^\s*Resolution:/
+                        res = line.scan(/(\d+)x(\d+)/).flatten
+                        rv[:res] = res[0].to_i
+                    end
+                end
+            end
+            return rv
+        rescue Exception => e
+            Deplate::Core.log(["Running identify failed", filename, e], :error)
+        end
+        return nil
+    end
+
+end
+

data/lib/deplate/fmt/dbk-article-4.1.2.rb

@@ -0,0 +1,21 @@
+# dbk-article.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.2056
+
+require "deplate/docbook"
+require "deplate/fmt/dbk-article"
+
+class Deplate::Formatter::DbkArticle412 < Deplate::Formatter::DbkArticle
+    self.myname = "dbk-article-4.1.2"
+    self.rx     = /dbk|dbk-article|docbook/i
+
+    def setup
+        @deplate.variables['dbkClass']   ||= 'article'
+        @deplate.variables['dbkVersion'] ||= '4.1.2'
+    end
+end
+

data/lib/deplate/fmt/dbk-article.rb

@@ -0,0 +1,46 @@
+# dbk-article.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.2058
+
+require "deplate/docbook"
+
+class Deplate::Formatter::DbkArticle < Deplate::Formatter::Docbook
+    self.myname = "dbk-article"
+    self.rx     = /dbk|dbk-article|docbook/i
+    
+    def initialize(deplate, args)
+        @headings = ['sect1', 'sect2', 'sect3', 'sect4', 'sect5', 'sect6']
+        super
+    end
+    
+    def setup
+        @deplate.variables['dbkClass']   ||= 'article'
+    end
+    
+    # Document skeleton
+    def get_doc_open(args)
+        o = []
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            o << %{ lang="#{lang}"}
+        end
+        return "<article%s>" % o.join
+    end
+
+    def get_doc_close(args)
+        return "</article>"
+    end
+
+    def get_doc_head_open(args)
+        return "<articleinfo>"
+    end
+
+    def get_doc_head_close(args)
+        return "</articleinfo>"
+    end
+end
+

data/lib/deplate/fmt/dbk-book.rb

@@ -0,0 +1,46 @@
+# dbk-book.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.2052
+
+require "deplate/docbook"
+
+class Deplate::Formatter::DbkBook < Deplate::Formatter::Docbook
+    self.myname = "dbk-book"
+    self.rx     = /dbk|dbk-book|docbook/i
+
+    def initialize(deplate, args)
+        @headings = ["chapter", "sect1", "sect2", "sect3", "sect4", "sect5", "sect6"]
+        super
+    end
+    
+    def setup
+        @deplate.variables['dbkClass']   ||= 'book'
+    end
+    
+    # Document skeleton
+    def get_doc_open(args)
+        o = []
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            o << %{ lang="#{lang}"}
+        end
+        return "<book%s>" % o.join
+    end
+
+    def get_doc_close(args)
+        return "</book>"
+    end
+
+    def get_doc_head_open(args)
+        return "<bookinfo>"
+    end
+
+    def get_doc_head_close(args)
+        return "</bookinfo>"
+    end
+end
+