notroff 0.2.11 → 0.2.13

data/lib/notroff/#io.rb#

@@ -0,0 +1,18 @@
+class FileProcessor
+  def initialize(path)
+    @path = path
+  end
+end
+
+class FileReader < FileProcessor
+  def process(ignored)
+    paras = File.readlines(@path)
+    paras.map! {|p| p.rstrip}
+  end
+end
+
+class FileWriter < FileProcessor
+  def process(output)
+    File.open(@path, 'w') {|f| f.write(output)}
+  end
+end

data/lib/notroff/embedded.rb

@@ -1,3 +1,13 @@
+class SkipFilter
+  def initialize(re1)
+    @re = re
+  end
+
+  def process(paras)
+    paras.find_all {|p| p != re}
+  end
+end
+
 class BetweenFilter
   def initialize(re1, re2=re1)
     @re1 = re1
@@ -83,41 +93,81 @@ class EmbeddedRubyProcessor
   def process_command(ruby_expression)
     Logger.log "Ruby expression: #{ruby_expression}"
     paras = eval(ruby_expression, binding)
-    paras = [paras] unless paras.kind_of?(Array)
-    paras.map! {|p| Text.new(p, :type => :code)}
+    paras.keep_if {|p| p[:included]}
   end
 
-  def embed(*filters, &block)
-    paras = block.call.map {|line| line.rstrip}
-    Logger.log "EMBED: #{paras}"
-    unless filters.empty?
-      filters.each {|f| paras = f.process(paras)}
-      paras = paras.find_all {|p| p[:included]}
+  def embed(type, inc_all=true, lines)
+    lines.map! do |line| 
+      result = Text.new(line.rstrip, :type => type)
+      result[:original_text] = line.rstrip
+      result[:included] = inc_all
+      result
     end
-    paras
+    lines
   end
 
-  def inc(path, *filters)
-    embed(*filters) {File.readlines(path)}
+  def skip(re, paras)
+    paras.each do |para|
+      para[:included] = false if (para =~ re)
+    end
   end
 
-  def run(shell_command, *filters)
-    embed(*filters) {File.popen(shell_command).readlines}
+  def inc(path, inc_all=true, type=:code)
+    embed(type, inc_all, File.readlines(path))
   end
 
-  def ex(ruby_command, *filters)
+  def run(shell_command, type=:code)
+    embed(type, File.popen(shell_command).readlines)
+  end
+
+  def ex(ruby_command, type=:code)
     puts "ruby_command: #{ruby_command}"
-    embed(*filters) {eval(ruby_command).to_s.split("\n")}
+    embed(type, eval(ruby_command).to_s.split("\n"))
   end
 
-  def matches(re1, re2=re1)
-    BetweenFilter.new(re1, re2)
+  def stdinc(path, re1=/##A/, re2=/##Z/, type=:code)
+    skip(/##X/, between(re1, re2, inc(path, false, type)))
   end
 
-  def method(name, include_body=true)
-    MethodFilter.new(name, include_body)
+  def between(re1, re2, paras)
+    state = :before_first
+    paras.each do |para|
+      if state == :before_first and re1 =~ para
+        state = :after_first
+        break if para =~ re2
+      elsif state == :after_first
+        break if para =~ re2
+        para[:included] = true
+      end
+    end
+    paras
+  end
+
+  def definition(def_re, include_body, paras)
+    state = :before_def
+    end_re = nil
+    paras.each do |para|
+      Logger.log para, (def_re =~ para)
+      if state == :before_def and def_re =~ para
+        para[:included] = true
+        end_re = Regexp.new( "^#{' ' * para.string.indent_depth}end" )
+        state = :after_def
+      elsif state == :after_def and end_re =~ para.string
+        para[:included] = true
+        break
+      elsif state == :after_def and include_body
+        para[:included] = true
+      end
+    end
+    paras
+  end
+
+
+  def meth(method_name, include_body, paras)
+    definition(/^ *def +#{method_name}(\(|$| )/, include_body, paras)
   end
 
+=begin
   def clazz(name, include_body=true)
     ClassFilter.new(name, include_body)
   end
@@ -125,6 +175,7 @@ class EmbeddedRubyProcessor
   def mod(name, include_body=true)
     ModuleFilter.new(name, include_body)
   end
+=end
 
   def indent(delta_indent, paragraphs)
     paragraphs.map do |p| 

data/lib/notroff/formatter.rb

@@ -37,9 +37,13 @@ class OdtFormatter < Formatter
   def initialize(input, output)
     super()
     prepend_processor FileReader.new(input)
+    add_processor BodyTypeRefiner.new
     add_processor CodeTypeRefiner.new
+    add_processor CodeTypeRefiner.new(:listing, :first_listing, :middle_listing, :end_listing)
     add_processor Grouper.new(:bullet)
     add_processor Grouper.new(:list)
+    add_processor Grouper.new(:quote)
+    add_processor Grouper.new(:attribution)
     add_processor OdtRenderer.new
     add_processor TemplateExpander.new
     add_processor OdtReplacer.new(output)

data/lib/notroff/odt_renderer.rb

@@ -9,16 +9,24 @@ class OdtRenderer < Processor
   LONG_DASH_CODE = 0xe1.chr + 0x80.chr + 0x93.chr
 
   PARAGRAPH_STYLES = { 
-    :body => 'BodyNoIndent',
-    :title => 'HB',
+    :body => 'FT',
+    :body2 => 'IT',
+    :title => 'HA',
+    :subtitle => 'HB',
     :section => 'HC',
     :sec => 'HC',
+    :subsec => 'HD',
     :first_code => 'CDT1',
     :middle_code => 'CDT',
     :end_code => 'CDTX',
     :author => 'AU',
     :quote => 'Quotation',
+    :attribution => 'Quotation Attribution',
     :single_code => 'C1',
+    :ltitle => 'LH',
+    :first_listing => 'LC',
+    :middle_listing => 'LC2',
+    :end_listing => 'LX',
     :pn => 'PN',
     :pt => 'PT',
     :cn => 'HA',
@@ -45,19 +53,30 @@ class OdtRenderer < Processor
 
     result = nil
 
-    if [ :author, :section, :sec, :title, :pn, :pt, :chapter ].include?( type )
-      result = new_text_element( type )
-      result.add_text( text.string )
-    elsif [:body, :quote].include?(type)
+
+    if [:body, :body2].include?(type)
+      Logger.log("Rendering bodyish para of type ", type )
       result = new_text_element( type )
       add_body_text( text, result )
+
+    elsif quote_type?(para)
+      result = new_quote_element(para[:kid_type], para[:kids])
+
     elsif list_type?(para)
       result = new_list_element(para[:kids])
+
     elsif bullet_type?(para)
       result = new_bullet_element(para[:kids])
+
     elsif code_type?(type)
       result = new_text_element( type )
       add_code_text( text, result )
+
+    elsif PARAGRAPH_STYLES[type]
+      Logger.log("Rendering simple para of type ", type )
+      result = new_text_element( type )
+      result.add_text( text.string )
+
     else
       raise "Dont know what to do with type [#{type}]"
     end
@@ -68,6 +87,10 @@ class OdtRenderer < Processor
     para[:type] == :group
   end
 
+  def quote_type?(para)
+    group?(para) and [:quote, :attribution].include?(para[:kid_type])
+  end
+
   def list_type?(para)
     group?(para) and para[:kid_type] == :list
   end
@@ -77,21 +100,21 @@ class OdtRenderer < Processor
   end
 
   def code_type?( type )
-    [ :first_code, :middle_code, :end_code, :single_code ].include?(type)
+    [ :first_code, :middle_code, :end_code, :single_code,
+      :listing, :first_listing, :middle_listing, :end_listing ].include?(type)
   end
 
-#      <text:list xml:id="list899615401" text:style-name="L2">
-#        <text:list-item>
-#          <text:p text:style-name="P7">first</text:p>
-#        </text:list-item>
-#        <text:list-item>
-#          <text:p text:style-name="P3">second</text:p>
-#        </text:list-item>
-#        <text:list-item>
-#          <text:p text:style-name="P4">third</text:p>
-#        </text:list-item>
-#      </text:list>
-
+  def new_quote_element(type, items)
+    p = new_text_element(type)
+    items.each_with_index do |item, i|
+      p.add( Element.new('text:line-break')) unless i == 0
+      el = Element.new('text:span')
+      add_body_text(item.string, el)
+      p.add(el)
+    end
+    puts p.to_s
+    p
+  end
 
   def new_list_element(items)
     list = Element.new('text:list')

data/lib/notroff/type_assigner.rb

@@ -6,8 +6,11 @@ class TypeAssigner
 
     paragraphs.each do |paragraph|
       type = paragraph[:type]
-      if (type == :body) or (type == :code) or (type == :quote)
+      if (type == :body) or (type == :code) or (type == :listing)
         current_type = type
+      elsif type == :quote
+        paragraph[:type] = :quote
+        processed_paragraphs << paragraph
       elsif type == :c1 || type == :code1
         paragraph[:type] = :code
         processed_paragraphs << paragraph

data/lib/notroff/type_refiner.rb

@@ -28,22 +28,45 @@ class TypeRefiner
 end
 
 class CodeTypeRefiner < TypeRefiner
+  def initialize(base_type=:code, first_type=:first_code, middle_type=:middle_code,
+    end_type=:end_code, single_type=middle_type)
+    @base_type = base_type
+    @first_type = first_type
+    @middle_type = middle_type
+    @end_type = end_type
+    @single_type = single_type
+  end
+
   def type_for( previous_type, type, next_type )
     Logger.log "code type for [#{previous_type}] [#{type}] [#{next_type}]"
-    if type != :code
+    if type != @base_type
       new_type = type
 
-    elsif previous_type == :code and next_type == :code
-      new_type = :middle_code
+    elsif previous_type ==@base_type and next_type == @base_type
+      new_type = @middle_type
 
-    elsif previous_type == :code
-      new_type = :end_code
+    elsif previous_type == @base_type
+      new_type = @end_type
 
-    elsif next_type == :code
-      new_type = :first_code
+    elsif next_type == @base_type
+      new_type = @first_type
 
     else
-      new_type = :single_code
+      new_type = @single_type
+    end
+
+    Logger.log("new type: #{new_type}")
+    new_type
+  end
+end
+
+class BodyTypeRefiner < TypeRefiner
+  def type_for( previous_type, type, next_type )
+    Logger.log "body type for [#{previous_type}] [#{type}] [#{next_type}]"
+
+    new_type = type
+    if (type == :body) and (previous_type == :body)
+      new_type = :body2
     end
 
     Logger.log("new type: #{new_type}")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: notroff
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.13
   prerelease: 
 platform: ruby
 authors:
@@ -32,6 +32,7 @@ files:
 - spec/text_spec.rb
 - spec/type_assigner_spec.rb
 - spec/with_commands.nr
+- lib/notroff/#io.rb#
 - lib/notroff/code_scrubber.rb
 - lib/notroff/command_processor.rb
 - lib/notroff/composite_processor.rb