Class: Deplate::Regions::R

Inherits:

Deplate::Region

• Object
• Element
• Deplate::Region
• Deplate::Regions::R

Defined in:

lib/deplate/regions.rb

Constant Summary

@@RAutoN =

0

Class Method Summary

• .run(container, r, out) ⇒ Object

Instance Method Summary

• #do_drop(r, out) ⇒ Object
• #do_normal(r, out) ⇒ Object
• #do_R ⇒ Object
• #do_verbatim(r, out) ⇒ Object
• #do_xtable(r, out) ⇒ Object
• #finish ⇒ Object
• #run(r, out) ⇒ Object
• #send_to_R(r, out) ⇒ Object
• #table_scanner(strings) ⇒ Object
• #xtable_postprocess_text(text) ⇒ Object

Methods inherited from Deplate::Region

check_file, clean_strings, #deprecated_regnote, deprecated_regnote, #finish_accum, #format_compound, regions, register_as, set_line_cont, #setup

Methods inherited from Element

#join_lines, #join_lines_re_zh_cn

Class Method Details

.run(container, r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 1120

def run(container, r, out)
    Deplate::External.r(container, r, out)
end

Instance Method Details

#do_drop(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 976

def do_drop(r, out)
    send_to_R(r, out)
    return nil
end

#do_normal(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 990

def do_normal(r, out)
    if send_to_R(r, out)
        scn = table_scanner(@accum)
        @accum.collect! do |r|
            if r =~ /^\s*$/
                "|   |"
            elsif @args['guess'] or @args['scanTable'] or @deplate.variables['rScanTable']
                cells = scn.match(r)
                if cells
                    cells = cells.captures.collect do |c|
                        v = c.strip
                        v.empty? ? @deplate.formatter.table_empty_cell : v
                    end
                    ['|', cells.join(' | '), '|'].join(' ')
                else
                    puts @accum.join("\n")
                    raise 'DBG: Error in table scanner (please report)'
                end
            else
                "| %s |" % Deplate::Particle::Code.markup(r.gsub(/ /, "\\\\ "))
            end
        end
        accum = @deplate.parsed_array_from_strings(@accum, 1 + @source.begin, @source.file)
        # if accum.size != 1 and accum[0].class != Deplate::Element::Table
        if accum[0].class != Deplate::Element::Table
            log(["Expected exactly one element of type Table", accum.collect {|e| e.class}.join(" ")], :error)
        end
        rOut = accum[0]
        if rOut
            rOut.collapse = false
        else
            log(["R yielded no output", out], :error)
        end
        return rOut
    end
end

#do_R ⇒ Object

# File 'lib/deplate/regions.rb', line 883

def do_R
    pre = @deplate.variables['rPrelude']
    if pre
        @accum = [pre, @accum].flatten.compact
    end
    id  = @args["id"]
    unless id
        @@RAutoN += 1
        id = @deplate.auxiliary_auto_filename('r', @@RAutoN, @accum)
    end
    r   = "#{id}.R"
    out = "#{id}.Rout"
    case @regNote.strip
    when "xtable"
        rOut = do_xtable(r, out)
    when "drop", "swallow"
        rOut = do_drop(r, out)
    when "verb", "verbatim"
        rOut = do_verbatim(r, out)
    else
        rOut = do_normal(r, out)
    end
    if rOut
        rOut.args.update(@args)
        return rOut
    end
end

#do_verbatim(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 981

def do_verbatim(r, out)
    if send_to_R(r, out)
        @elt = @accum.join("\n")
        rOut = Deplate::Regions::Verbatim.new(@deplate, @source, @text, @match, self)
        rOut.finish
        return rOut
    end
end

#do_xtable(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 911

def do_xtable(r, out)
    @accum.unshift(%{library(xtable)})
    if send_to_R(r, out)
        table = []
        pre   = []
        # cap   = nil
        post  = []
        mode  = :pre
        for l in @accum
            xtable_postprocess_text(l)
            m = /^\s*\<([^> ]+).*?\>(.*)?(\<\/(\S+)\>)?\s*$/.match(l)
            if m
                case m[1]
                when "!--"
                    next
                when "TABLE"
                    mode = :table
                when "/TABLE"
                    mode = :post
                when "TR"
                    row = l.scan(/\<TH.*?\>\s*(.*?)\s*<\/TH\>/).flatten
                    unless row.empty?
                        table << "|| #{row.join(" || ")} ||"
                    else
                        row = l.scan(/\<TD.*?\>\s*(.*?)\s*\<\/TD\>/).flatten
                        table << "| #{row.join(" | ")} |" unless row.empty?
                    end
                    log(["R xtable: row", row], :debug)
                    # when "CAPTION"
                    # mc = /\<CAPTION.*?\> (.*) \<\/CAPTION\>$/.match(l)
                    # cap = mc[1]
                else
                    log(["Skip", m[1]])
                end
            else
                case mode
                when :pre
                    pre << l
                when :post
                    post << l
                end
            end
        end
        accum = @deplate.parsed_array_from_strings(table, 1 + @source.begin, @source.file)
        if accum.size != 1
            log(["Unexpected R output (too many elements)", 
                out, accum.collect {|e| e.class}], :error)
        end
        until accum.empty? or accum[0].kind_of?(Deplate::Element::Table)
            e = accum.shift
            log(["Unexpected R output (Please check the output for errors!)",
                out, e.class], :error)
        end
        rOut = accum[0]
        if rOut
            rOut.collapse = false
            rOut.preNote  = pre.join("\n")
            rOut.postNote = post.join("\n")
            log(["R xtable: pre", rOut.preNote],   :debug)
            log(["R xtable: post", rOut.postNote], :debug)
            return rOut
        end
    end
end

#finish ⇒ Object

# File 'lib/deplate/regions.rb', line 867

def finish
    finish_accum
    if @deplate.formatter.respond_to?(:region_R)
        return Deplate::Element::PseudoElement.new(@deplate, @source, self) do |invoker|
            @deplate.formatter.send(:region_R, self, @accum)
        end
    else
        begin
            return do_R
        rescue StandardError => e
            log(["Program call failed", e, e.backtrace[0..10]], :error)
            return nil
        end
    end
end

#run(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 1115

def run(r, out)
    return Deplate::Regions::R.run(self, r, out)
end

#send_to_R(r, out) ⇒ Object

# File 'lib/deplate/regions.rb', line 1079

def send_to_R(r, out)
    pwd = Dir.pwd
    d   = File.dirname(@deplate.dest)
    rv  = false
    @deplate.in_working_dir do
        log(["Running R", d, r, out])
        begin
            @accum.unshift(%{deplate.fmt <- "#{@deplate.formatter.formatter_name}"})
            @accum << %{q(runLast=FALSE)}
            if Deplate::Region.check_file(self, out, r, @accum)
                log(["Files exist! Using", out], :anyway)
            else
                unless @deplate.options.force
                    for f in [r, out]
                        if File.exist?(f)
                            raise "Please delete '#{f}' or change the id before proceeding\nUse the --force option to avoid this message."
                        end
                    end
                end
                Deplate::External.write_file(self, r) {|io| io.puts(@accum.join("\n"))}
                run(r, out)
            end
            @accum = File.open(out) {|io| io.read}.split(/[\n\r]+/)
            skip = @args["skip"]
            if skip
                head, tail = Deplate::Core.split_list(skip, nil, nil, @source).collect {|n| n.to_i}
                @accum = @accum[(head || 0) .. (@accum.size - tail - 1 || -1)] || []
            end
            rv = true
        rescue StandardError => e
            log("#R: #{e}", :error)
        end
    end
    return rv
end

#table_scanner(strings) ⇒ Object

# File 'lib/deplate/regions.rb', line 1027

def table_scanner(strings)
    max = 0
    for l in strings
        ls = l.size
        if ls > max
            max = ls
        end
    end
    blanks = [true] * max
    for l in strings
        for i in 0..(l.size - 1)
            if l[i] != 32
                blanks[i] &&= false
            end
        end
    end
    lst = true
    blanks.collect! do |c|
        if c and lst
            rv = false
        else
            rv = c
        end
        lst = c
        rv
    end
    acc = []
    lst = -1
    blanks.each_with_index do |c, i|
        if c
            d   = i - lst
            lst = i
            acc << ' ' unless acc.empty?
            acc << '(' << '.' * (d - 1) << ')'
        end
    end
    d = max - 1 - lst
    if d > 1
        acc << ' ' unless acc.empty?
        acc << '(' << '.' * (d - 1) << ')'
    end
    Regexp.new(acc.join)
end

#xtable_postprocess_text(text) ⇒ Object

# File 'lib/deplate/regions.rb', line 1071

def xtable_postprocess_text(text)
    text.gsub!(/&?/,  %{&})
    text.gsub!(/&lt;?/,   %{<})
    text.gsub!(/&gt;?/,   %{>})
    text.gsub!(/&quot;?/, %{"})
    text
end