notroff 0.2.1

data/lib/notroff/html_renderer.rb

@@ -0,0 +1,92 @@
+require 'rexml/document'
+require 'pp'
+
+class HtmlRenderer < Processor
+  include Tokenize
+  include REXML
+
+  def process( paragraphs )
+    body = Element.new('body')
+    paragraphs.each do |paragraph|
+      new_element = format( paragraph )
+      body.add new_element if new_element
+    end
+    body
+  end
+
+  def format( p )
+    type = p[:type]
+    text = p.string
+
+    return nil if text.empty? and :type != :code
+
+    if type == :code
+      code_element(type, text)
+    else
+      text_element(type, text)
+    end
+  end
+
+  def text_element(type, text)
+    element = Element.new(tag_for(type))
+    add_body_text(text, element)
+    element
+  end
+
+  def tag_for(type)
+    case type
+    when :body
+      'p'
+    when :text
+      'p'
+    when :author
+      'h3'
+    when :section
+      'h3'
+    when :sec
+      'h3'
+    when :chapter
+      'h2'
+    when :title
+      'h1'
+    else
+        raise "Dont know what to do with #{type}"
+    end
+  end
+
+  def add_body_text( text, element )
+    tokens = tokenize_body_text( text )
+    tokens.each {|token| add_span( token, element ) }
+  end
+
+  def add_span( token, element )
+    case token[:type]
+    when :italic
+      element.add(span_for(token.string, "em"))
+    when :code
+      element.add(span_for(token.string, "code"))
+    when :bold
+      element.add(span_for(token.string, "b"))
+    when :normal
+      element.add_text(token.string)
+    when :footnote
+      add_body_text(" [#{token.string}] ", element)
+    else
+      raise "Dont know what to do with type #{token[:type]} - #{token}"
+    end
+  end
+
+  def code_element(type, text)
+    element = Element.new('code')
+    pre_element = Element.new('pre')
+    element.add pre_element
+    pre_element.add_text text
+    element
+  end
+
+  def span_for( text, style )
+    span = Element.new( style )
+    span.text = remove_escapes(text)
+    span
+  end
+end

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/logger.rb

@@ -0,0 +1,13 @@
+
+module Logger
+  @verbose = false
+
+  def self.verbose=(value)
+    @verbose = value
+  end
+
+  def self.log(*args)
+    return unless @verbose
+    puts args.join(' ')
+  end
+end

data/lib/notroff/odt_renderer.rb

@@ -0,0 +1,154 @@
+require 'rexml/document'
+require 'pp'
+
+
+class OdtRenderer < Processor
+  include Tokenize
+  include REXML
+
+  LONG_DASH_CODE = 0xe1.chr + 0x80.chr + 0x93.chr
+
+  PARAGRAPH_STYLES = { 
+    :body => 'BodyNoIndent',
+    :title => 'HB',
+    :section => 'HC',
+    :sec => 'HC',
+    :first_code => 'CDT1',
+    :middle_code => 'CDT',
+    :end_code => 'CDTX',
+    :author => 'AU',
+    :quote => 'Quotation',
+    :single_code => 'C1',
+    :pn => 'PN',
+    :pt => 'PT',
+    :cn => 'HA',
+    :chapter => 'HA',
+    :ct => 'HB' }
+
+  @@footnote_number = 1
+
+  def process( paragraphs )
+    elements = []
+    paragraphs.each do |paragraph|
+      new_element = format( paragraph )
+      elements << new_element if new_element
+    end
+    elements
+  end
+
+  def format( para )
+    Logger.log "Format: #{para.inspect}"
+    type = para[:type]
+    text = para
+
+    return nil if text.empty? and ! code_type?( type )
+
+    result = new_text_element( type )
+
+    if [ :author, :section, :sec, :title, :pn, :pt, :chapter ].include?( type )
+      result.add_text( text.string )
+    elsif [:body, :quote].include?(type)
+      add_body_text( text, result )
+    elsif code_type?(type)
+      add_code_text( text, result )
+    else
+      raise "Dont know what to do with type [#{type}]"
+    end
+    result
+  end
+
+  def code_type?( type )
+    [ :first_code, :middle_code, :end_code, :single_code ].include?(type)
+  end
+
+  def new_text_element( type )
+    result = Element.new( "text:p" )
+    result.attributes["text:style-name"] = PARAGRAPH_STYLES[type]
+    result
+  end
+
+  def add_body_text( text, element )
+    tokens = tokenize_body_text( text )
+    tokens.each {|token| add_span( token, element ) }
+  end
+
+  def add_code_text( text, element )
+    text = text.dup
+    re = /\S+|\s+/
+    until text.empty?
+      chunk = text.slice!( re )
+      if chunk !~ /^ /
+        element.add_text( chunk.string )
+      else
+        space_element = Element.new( 'text:s' )
+        space_element.attributes['text:c'] = chunk.size.to_s
+        element.add( space_element )
+      end
+    end
+  end
+
+  def add_span( token, element )
+    case token[:type]
+    when :italic
+      element.add( span_for( token.string, "T1" ))
+    when :code
+      element.add( span_for( token.string, "CD1" ))
+    when :bold
+      element.add( span_for( token.string, "T2" ))
+    when :normal
+      element.add_text( token.string )
+    when :footnote
+      element.add( footnote_for( token.string ) )
+    else
+      raise "Dont know what to do with #{token}"
+    end
+  end
+
+  def span_for( text, style )
+    span = Element.new( "text:span" )
+    span.attributes['text:style-name'] = style
+    span.text = remove_escapes(text)
+    span
+  end
+
+  def remove_escapes( text )
+    text = text.clone
+
+    results = ''
+
+    until text.empty?
+      match = /\\(.)/.match( text )
+      if match.nil?
+        results << text
+        text = ''
+      else
+        unless match.pre_match.empty?
+          results << match.pre_match
+        end
+        results << match[1]
+        text = match.post_match
+      end
+    end
+    results
+  end
+
+  def footnote_for(text )
+    note_element = Element.new( "text:note" )
+    note_element.attributes["text:id"] ="ftn#{@@footnote_number}"
+    note_element.attributes["text:note-class"] ="footnote"
+
+    cit = Element.new( "text:note-citation" )
+    cit.add_text( "#{@@footnote_number}" )
+    note_element.add( cit )
+
+    note_body = Element.new( "text:note-body" )
+    note_paragraph = Element.new( "text:p" )
+    note_paragraph.attributes['text:style-name'] = 'FTN'
+    add_body_text(text, note_paragraph)
+
+    note_body.add( note_paragraph )
+    note_element.add( note_body )
+    @@footnote_number += 1
+    note_element
+  end
+end

data/lib/notroff/odt_replacer.rb

@@ -0,0 +1,22 @@
+require 'pp'
+require 'zip/zipfilesystem'
+require 'fileutils'
+
+SKEL = File.expand_path('../skel.odt', __FILE__)
+
+class OdtReplacer < Processor
+
+  def initialize( output_path )
+    @output_path = output_path
+  end
+
+  def process( new_content )
+    FileUtils.cp( SKEL, @output_path )
+
+    Zip::ZipFile.open( @output_path ) do |zipfile|
+      zipfile.file.open("content.xml", "w") do |content|
+        content.print( new_content )
+      end
+    end
+  end
+end

data/lib/notroff/paragraph_joiner.rb

@@ -0,0 +1,53 @@
+class ParagraphJoiner
+  def process( paragraphs )
+    processed_paragraphs = []
+    new_p = nil
+    paragraphs.each do |paragraph|
+      do_join = join?(paragraph)
+
+      if join?(paragraph)
+        if new_p
+          new_p.string += " "
+          new_p.string += paragraph
+        else
+          new_p = paragraph
+        end
+      else
+        if new_p
+          processed_paragraphs << new_p
+          new_p = nil
+        end
+        processed_paragraphs << paragraph unless skip?(paragraph)
+      end
+    end
+    processed_paragraphs << new_p if new_p
+    processed_paragraphs
+  end
+
+  def join?(paragraph)
+    false
+  end
+
+  def skip?(paragraph)
+    false
+  end
+end
+
+class BodyParagraphJoiner < ParagraphJoiner
+  def join?(paragraph)
+    return false unless paragraph[:type] == :body
+    return false if paragraph.empty?
+    true
+  end
+
+  def skip?(paragraph)
+    paragraph[:type] == :body && paragraph.empty?
+  end
+end
+
+class CodeParagraphJoiner < ParagraphJoiner
+  def join?(paragraph)
+    return false unless paragraph[:type] == :code
+    true
+  end
+end

data/lib/notroff/processor.rb

@@ -0,0 +1,192 @@
+class Processor
+end
+
+class TextPrinter
+  def process( text )
+    puts text
+  end
+end
+
+class FileWriter
+  def initialize(output_file)
+    @output_file = output_file
+  end
+
+  def process(content)
+    File.open(@output_file, 'w') do |f|
+      f.print(content.to_s)
+    end
+  end
+end
+
+class Printer
+  def process( paragraphs )
+    paragraphs.each {|p| puts "#{p.type}: #{p.text}"}
+  end
+end
+
+class TextReader < Processor
+  def initialize( path )
+    @path = path
+  end
+
+  def process( ignored )
+    lines = File.open( @path ).readlines
+    lines.map! { |line| line.rstrip }
+    lines
+  end
+end
+
+#class CommandProcessor
+#
+#  def process( lines )
+#    paragraphs = []
+#    lines.each do |line|
+#      cmd, text = parse_line( line )
+#      if cmd.empty?
+#        cmd = :text
+#      else
+#        cmd = cmd.sub(/^./, '').to_sym
+#      end
+#
+#      text.attr(:type, cmd)
+#      text.attr(:original_text, line)
+#      paragraphs << text
+#    end
+#    paragraphs
+#  end
+#
+#  def parse_line( line )
+#    match_data = /^(\.\w+ ?)(.*)/.match(line)
+#    if match_data
+#      cmd = match_data[1].strip
+#      text = match_data[2]
+#    else
+#      cmd = ''
+#      text = line
+#    end
+#    [ cmd.strip, text ]
+#  end
+#end
+#
+#class ParagraphTypeAssigner
+#  def process( paragraphs )
+#    processed_paragraphs = []
+#
+#    current_type = :body
+#
+#    paragraphs.each do |paragraph|
+#      type = paragraph | :type
+#      if (type == :body) or (type == :code) or (type == :quote)
+#        current_type = type
+#
+#      elsif type == :text
+#        new_p = paragraph.clone
+#        new_p.attr(:type, current_type)
+#        processed_paragraphs << new_p
+#
+#      else
+#        processed_paragraphs << paragraph
+#      end
+#
+#      current_type = :body if [ :section, :title, :code1 ].include?(type)
+#    end
+#    processed_paragraphs
+#  end
+#end
+#
+#class CodeTypeRefiner
+#  def process( paragraphs )
+#    processed_paragraphs = []
+#
+#    previous_type = nil
+#
+#    paragraphs.each_with_index do |paragraph, i|
+#      type = paragraph | :type
+#      previous_type = ( paragraphs.first == paragraph) ? nil : paragraphs[i-1] | :type
+#      next_type = ( paragraphs.last == paragraph) ? nil : paragraphs[i+1] | :type
+#      new_type = code_type_for( previous_type, type, next_type )
+#      new_p = paragraph.clone
+#      new_p.attr(:type, new_type)
+#      processed_paragraphs << new_p
+#    end
+#    processed_paragraphs
+#  end
+#
+#  def code_type_for( previous_type, type, next_type )
+#    if type != :code
+#      new_type = type
+#
+#    elsif previous_type == :code and next_type == :code
+#      new_type = :middle_code
+#
+#    elsif previous_type == :code
+#      new_type = :end_code
+#
+#    elsif next_type == :code
+#      new_type = :first_code
+#
+#    else
+#      new_type = :single_code
+#    end
+#
+#    new_type
+#  end
+#end
+#
+#class SimilarParagraphJoiner
+#  def initialize(target_type)
+#    @target_type = target_type
+#  end
+#
+#  def process( paragraphs )
+#    processed_paragraphs = []
+#    new_p = nil
+#    paragraphs.each do |paragraph|
+#      if (paragraph | :type)  != @target_type
+#        processed_paragraphs << new_p if new_p
+#        new_p = nil
+#        processed_paragraphs << paragraph
+#
+#      elsif new_p
+#        new_p += "\n"
+#        new_p += paragraph
+#
+#      else
+#        new_p = paragraph 
+#      end
+#    end
+#    processed_paragraphs << new_p if new_p
+#    processed_paragraphs
+#  end
+#end
+#
+#class TextParagraphJoiner
+#  def process( paragraphs )
+#    processed_paragraphs = []
+#
+#    new_p = nil
+#
+#    paragraphs.each do |paragraph|
+#      if (paragraph | type  != :body) and (paragraph | type  != :quote)
+#        processed_paragraphs << new_p if new_p
+#        new_p = nil
+#        processed_paragraphs << paragraph
+#
+#      elsif paragraph.blank?
+#        processed_paragraphs << new_p if new_p
+#        new_p = nil
+#
+#      elsif new_p
+#        new_p +=  paragraph.text
+#
+#      else
+#        new_p = paragraph 
+#      end
+#    end
+#    processed_paragraphs << new_p if new_p
+#    processed_paragraphs
+#  end
+#end
+#
+#

data/lib/notroff/string_extensions.rb

@@ -0,0 +1,6 @@
+class String
+  # Return the number of leading blanks
+  def indent_depth
+    /^ */.match(self).to_s.size
+  end
+end

data/lib/notroff/template_expander.rb

@@ -0,0 +1,15 @@
+require 'erb'
+
+TEMPLATE = File.expand_path('../content.xml.erb', __FILE__)
+
+class TemplateExpander < Processor
+
+  def initialize
+    @template = ERB.new(File.read(TEMPLATE))
+  end
+
+  def process( elements )
+    content = elements.join( "\n" )
+    @template.result(binding)
+  end
+end

data/lib/notroff/text.rb

@@ -0,0 +1,67 @@
+require 'delegate'
+
+class Text
+  attr_accessor :string, :attrs
+
+  def initialize(initial_string, initial_attrs={})
+    @string = initial_string.to_str.clone
+    @attrs = initial_attrs.clone
+  end
+
+  def self.wrap_method(method_name)
+    define_method method_name do |*args|
+      result = @string.send(method_name, *args)
+      return Text.new(result, attrs) if result.kind_of? String
+      result
+    end
+  end
+
+  def self.wrap_methods(method_names)
+    method_names.each {|name| wrap_method(name)}
+  end
+
+  wrap_methods( String.instance_methods(false) )
+
+  def [](name)
+    @attrs[name]
+  end
+
+  def []=(name, value)
+    @attrs[name] = value
+  end
+
+  def ==(other)
+    return false unless other.kind_of? Text
+    @string == other.string && @attrs == other.attrs
+  end
+
+  def clone
+    Text.new(string, attrs)
+  end
+
+  def to_str
+    #puts "To string: #{@string.class} #{@string}"
+    @string
+  end
+
+  def to_s
+    @string
+  end
+
+  def inspect
+    "#{@string.inspect} :: #{@attrs.inspect}"
+  end
+end
+
+class String
+  def to_text
+    Text.new(self)
+  end
+
+  alias_method :old_double_equals, :'=='
+
+  def ==(other)
+    return self == other.string if other.kind_of?(Text)
+    old_double_equals(other)
+  end
+end

data/lib/notroff/text_replacer.rb

@@ -0,0 +1,65 @@
+#require 'rexml/document'
+require 'pp'
+#require 'zip/zipfilesystem'
+#require 'fileutils'
+#require 'erb'
+
+FormatOdtDir = File.dirname(__FILE__)
+
+require "#{FormatOdtDir}/utils"
+require "#{FormatOdtDir}/processor"
+require "#{FormatOdtDir}/code_processors"
+require "#{FormatOdtDir}/odt_renderer"
+require "#{FormatOdtDir}/odt_replacer"
+require "#{FormatOdtDir}/template_expander"
+
+
+class Editor
+  def initialize( input, output )
+    @input = input
+    @output = output
+    @processors = []
+    @processors << TextReader.new( @input )
+    @processors << CommandProcessor.new
+    @processors << ParagraphTypeAssigner.new
+    @processors << ProgramOutputInserter.new
+    @processors << C1Inserter.new
+    @processors << IncInserter.new
+    @processors << CodeInserter.new
+    @processors << LastOutputInserter.new
+    @processors << CodeTagFilter.new
+    @processors << CodeTypeRefiner.new
+    @processors << OdtRenderer.new
+    @processors << TemplateExpander.new( File.read( ContentTemplate ) )
+    @processors << OdtReplacer.new( OdtSkeleton, @output )
+  end
+
+  def process
+    result = nil
+    @processors.each do |processor|
+      result = processor.process( result )
+    end
+  end
+end
+   
+
+f = Editor.new( ARGV[0], ARGV[1]  )
+f.process
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+