notroff 0.2.1

data/lib/notroff/tokenize.rb

@@ -0,0 +1,64 @@
+require 'rexml/document'
+
+module Tokenize
+  def tokenize_body_text( text )
+    text = text.dup
+    re = /\~\~.*?\~\~|\@\@.*?\@\@+|\{\{.*?\}\}|!!.*?!!/
+    results = []
+    until text.empty?
+      match = re.match( text )
+      if match.nil?
+        results << Text.new(text, :type=>:normal)
+        text = ''
+      else
+        unless match.pre_match.empty?
+          results << Text.new(match.pre_match, :type=>:normal)
+        end
+        token =  match.to_s
+        results << Text.new(token_text(token), :type=>token_type(token))
+        text = match.post_match
+      end
+    end
+    results
+  end
+
+  def token_type( token )
+    case token
+    when /^\~/
+      :italic
+    when /^\@/
+      :code
+    when /^\{/
+      :footnote
+    when /^!/
+      :bold
+    end 
+  end
+
+  def token_text( token )
+    result = token.sub( /^../, '' ).sub( /..$/, '')
+    #print "token text for #{token} [[#{result}]]"
+    result
+  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
+end

data/lib/notroff/type_assigner.rb

@@ -0,0 +1,25 @@
+class TypeAssigner
+  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 == :code1
+        paragraph[:type] = :code
+        processed_paragraphs << paragraph
+      elsif type == :text
+        paragraph[:type] = current_type
+        processed_paragraphs << paragraph
+      else
+        processed_paragraphs << paragraph
+      end
+
+      current_type = :body if [ :section, :title, :code1 ].include?(type)
+    end
+    processed_paragraphs
+  end
+end

data/lib/notroff.rb

@@ -0,0 +1,23 @@
+Verbose = false unless defined?(Verbose)
+
+require "notroff/logger"
+require "notroff/string_extensions"
+require "notroff/text"
+require "notroff/io"
+require "notroff/filter"
+require "notroff/code_scrubber"
+require "notroff/embedded"
+require "notroff/paragraph_joiner"
+require "notroff/type_assigner"
+require "notroff/processor"
+require "notroff/command_processor"
+require "notroff/composite_processor"
+require "notroff/tokenize"
+require "notroff/html_renderer"
+require "notroff/docbook_renderer"
+require "notroff/odt_renderer"
+require "notroff/odt_replacer"
+require "notroff/template_expander"
+require "notroff/code_typer"
+require "notroff/formatter"
+require "notroff/filter"

data/readme.nr

@@ -0,0 +1,58 @@
+NotRoff Text Formatter
+========
+
+NotRoff is a simple plain text file format that allows you to embed all sort of styling, including fixed width, italics and bold into your work using plain text markers. The included notroff program will turn the plain text into an Open Office .odt document. I used NotRoff to format Eloquent Ruby.
+
+Creating plain text in notroff is very easy -- you just write each paragraph in its own line, separated by blank lines. You can add styling to your text with simple tags: words surrounded by !! become bold, while ~~ tags italics and @@ tags code, for example like this:
+
+!!This!! is bold, but ~~this~~ is italics and @@all of this@@ looks like code.
+
+To do fancier stuff there are also dot commands. Each dot command starts with a period, followed by the name of the command, and then -- for most dot commands -- an argument or two. For example, there is a dot command for creating section headers:
+
+.section NotRoff Includes Section Headers
+
+There is also a dot command to include some program code from a source code into your final document: 
+
+.inc gutted_doc.rb
+
+Frequently you don't want the whole file, just a chunk of it. To do that, you can add a second argument to your .inc command, a !!tag!! which will pick out a tagged section of the file. Here's what a .inc command with a tag looks like:
+
+.inc ex_lazy_document.rb  base_doc
+
+And here is what the corresponding source file looks like:
+
+.code
+# This comment is not included in the .odt file
+
+puts "first included line"   ##(base_doc
+puts "also included"
+puts "last included line"    ##base_doc)
+.body
+
+There is a short cut if you want to include a single line from your source file -- Just tag it with ##+tag, like this:
+
+open_file = File.open( '/etc/passwd' )   ##+open
+
+You can also explicitly exclude a line with ##--tag.
+
+One of the problems with including code into text is that the indentation is frequently wrong: The code wants to have indentation that makes sense within the larger program which sometimes looks bad in the text. To deal with this, the .inc command lets you specify a 3rd parameter, the number of spaces that you want to set the indentation to:
+
+.c1 .inc type_check_spec.rb bad_type 2
+
+Along with pulling code from a file, you can also include single lines of code directly into the NotRoff file:
+
+.c1  doc = get_some_kind_of_document 
+
+Or multiple lines of code:
+
+.code
+  puts "Title: #{doc.title}" 
+  puts "Author: #{doc.author}" 
+  puts "Content: #{doc.content}" 
+.body
+
+Using notroff is simple: Just run the notroff script, supplying the path to the plain text file as the first argument and the path to your new OpenOffice .odt file as the second:
+
+.c1 notroff example.nr example.odt
+
+

data/spec/command_processor_spec.rb

@@ -0,0 +1,15 @@
+describe CommandProcessor do
+  let(:cp) { CommandProcessor.new }
+
+  it 'should turn a plain line of text into a .text command' do
+    lines = [ 'line 1', 'line 2' ]
+    new_lines = cp.process(lines)
+    new_lines.size.should == 2
+    new_lines[0].string.should == 'line 1'
+    new_lines[1].string.should == 'line 2'
+    new_lines[0][:type].should == :text
+    new_lines[1][:type].should == :text
+    new_lines[0][:original_text].should == 'line 1'
+    new_lines[1][:original_text].should == 'line 2'
+  end
+end

data/spec/composite_processor_spec.rb

@@ -0,0 +1,35 @@
+class PUp
+  def process(paras)
+    paras.map {|p| p.upcase}
+  end
+end
+
+class PDown
+  def process(paras)
+    paras.map {|p| p.downcase}
+  end
+end
+
+describe CompositeProcessor do
+  let(:cp) { CompositeProcessor.new() }
+
+  let(:paras) { %W{ para1 para2 para3 } }
+
+  it 'should do nothing with no processors' do
+    new_paras = CompositeProcessor.new.process(paras)
+    new_paras.should == %W{ para1 para2 para3 }
+  end
+
+  it 'should work like a single processor with one subprocessor' do
+    cp.add_processor(PUp.new)
+    new_paras = cp.process(paras)
+    new_paras.should == %W{ PARA1 PARA2 PARA3 }
+  end
+
+  it 'should apply several processors in turn' do
+    cp.add_processor(PUp.new)
+    cp.add_processor(PDown.new)
+    new_paras = cp.process(paras)
+    new_paras.should == %W{ para1 para2 para3 }
+  end
+end

data/spec/filter_spec.rb

@@ -0,0 +1,16 @@
+describe IncludedFilter do
+  let(:filter) { IncludedFilter.new }
+
+  let(:paras) do
+    paras = %W{ para1 para2 para3 para4 para5}
+    paras.map {|p| Text.new(p) }
+  end
+
+  it 'should filter out paras that dont have the included tag' do
+    paras[1][:included] = paras[3][:included] = true
+    new_paras = filter.process(paras)
+    new_paras.size.should == 2
+    new_paras[0].string.should == 'para2'
+    new_paras[1].string.should == 'para4'
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,22 @@
+describe Formatter do
+  let(:formatter) { Formatter.new }
+
+  let(:text_paras) { %W{ para1 para2 para3 para4 para5} }
+
+  it 'should turn join a series of text paragraphs into a single body' do
+    new_paras = formatter.process(text_paras)
+    new_paras.size.should == 1
+    new_paras[0][:type].should == :body
+    new_paras[0].string.should == "para1 para2 para3 para4 para5"
+  end
+
+  it 'should deal with sticky commands' do
+    new_paras = formatter.process( %W{body1 .code code1 code2 .body body2} )
+    pp new_paras
+    new_paras.size.should == 4
+    new_paras[0][:type].should == :body
+    new_paras[1][:type].should == :code
+    new_paras[2][:type].should == :code
+    new_paras[3][:type].should == :body
+  end
+end

data/spec/hello.rb

@@ -0,0 +1 @@
+puts "hello ruby"

data/spec/hello.rb.out

@@ -0,0 +1 @@
+hello ruby

data/spec/paragraph_joiner_spec.rb

@@ -0,0 +1,26 @@
+describe BodyParagraphJoiner do
+  let(:pj) { BodyParagraphJoiner.new(:body) }
+
+  let(:paras) do
+    paras = %W{ para1 para2 para3 para4 para5}
+    paras.map {|p| Text.new(p, :type => :body) }
+  end
+
+  it 'should turn join a series of similar paragraphs together' do
+    new_paras = pj.process(paras)
+    new_paras.size.should == 1
+    new_paras[0][:type].should == :body
+    new_paras[0].string.should == "para1 para2 para3 para4 para5"
+  end
+
+  it 'should turn stop joining on an empty paragraph' do
+    paras[2].string = ''
+    new_paras = pj.process(paras)
+    pp new_paras
+    new_paras.size.should == 2
+    new_paras[0][:type].should == :body
+    new_paras[0].string.should == "para1 para2"
+    new_paras[1][:type].should == :body
+    new_paras[1].string.should == "para4 para5"
+  end
+end

data/spec/simple.nr

@@ -0,0 +1,3 @@
+first line
+second line
+third line

data/spec/string_extensions_spec.rb

@@ -0,0 +1,22 @@
+describe String do
+  it 'should let you turn a string into a Text' do
+    t = 'abc'.to_text
+    t.class.should == Text
+    t.string.should == 'abc'
+    t.attrs.should == {}
+  end
+
+  it 'should still have a working ==' do
+    s = 'abc'
+    s.should == 'abc'
+    s.should_not == 'xxx'
+    s.should_not == 123
+    s.should_not == nil
+  end
+
+  it 'should be == to Text instances with the same string' do
+    s = 'abc'
+    s.should == Text.new('abc')
+    s.should_not == Text.new('xxx')
+  end
+end

data/spec/text_spec.rb

@@ -0,0 +1,55 @@
+describe Text do
+  let(:t) { Text.new('abc') }
+
+  it 'should be creatable with a string and an attr hash' do
+    text = Text.new('abc', :name => 'russ')
+    text.string.should == 'abc'
+    text.attrs.should == {:name => 'russ'}
+  end
+
+  it 'should provide access to the original string' do
+    t.string.should == 'abc'
+    t.string.class.should == String
+  end
+
+  it 'should have a size method like a string' do
+    t.size.should == 3
+  end
+
+  it 'should support a sub method which should return a Text' do
+    new_t = t.sub('b', 'B')
+    new_t.class.should == Text
+    new_t.string.should == 'aBc'
+  end
+
+  it 'should return attributes when you do arithmetic' do
+    t[:name] = 'russ'
+    new_t = t + "xxx"
+    new_t[:name].should == 'russ'
+    new_t.string.should == 'abcxxx'
+  end
+
+  it 'should support setting and getting attrs via the attrs method' do
+    t.attrs[:name] = 'russ'
+    t.attrs[:name].should == 'russ'
+    t.attrs.should == { :name => 'russ' }
+  end
+
+  it 'should support setting and getting attrs via subscripting' do
+    t[:name] = 'russ'
+    t[:name].should == 'russ'
+  end
+
+  it 'should take attrs into account in ==' do
+    t_new = Text.new('abc')
+    t_new[:name] = 'russ'
+    t[:name] = 'russ'
+
+    t.should == t_new
+
+    t_new[:name] = 'bob'
+puts "T class: #{t.class}"
+puts "Tnew class: #{t_new.class}"
+    t.should_not == t_new
+  end
+end

data/spec/type_assigner_spec.rb

@@ -0,0 +1,39 @@
+describe TypeAssigner do
+  let(:ta) { TypeAssigner.new }
+  let(:paras) do
+    paras = %W{ para1 para2 para3 para4 para5}
+    paras.map {|p| Text.new(p, :type => :text) }
+  end
+
+  it 'should turn plain text paras into body paras' do
+    new_paras = ta.process(paras)
+    new_paras.each {|p| p[:type].should == :body}
+  end
+
+  it 'should make .code commands sticky while droping the code command' do
+    paras[0] = Text.new( '', :type => :code)
+    new_paras = ta.process(paras)
+    new_paras.size.should == 4
+    new_paras.each {|p| p[:type].should == :code}
+  end
+
+  it 'should make switch between .code and .body commands' do
+    paras[0] = Text.new( '', :type => :code)
+    paras[3] = Text.new( '', :type => :body)
+    new_paras = ta.process(paras)
+    new_paras.size.should == 3
+    new_paras[0][:type].should == :code
+    new_paras[1][:type].should == :code
+    new_paras[2][:type].should == :body
+  end
+
+  it 'should know that section and code1 are automatically followed by body' do
+    paras[0] = Text.new( 'section!', :type => :sec)
+    paras[2] = Text.new( 'code1!', :type => :code1)
+    new_paras = ta.process(paras)
+    new_paras[0][:type].should == :sec
+    new_paras[1][:type].should == :body
+    new_paras[2][:type].should == :code
+    new_paras[3][:type].should == :body
+  end
+end

data/spec/with_commands.nr

@@ -0,0 +1,6 @@
+para1
+.command1
+para2
+.command2 arg1 arg2
+para3
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: notroff
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Russ Olsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-15 00:00:00.000000000Z
+dependencies: []
+description: NotRoff A simple text to openoffice filter
+email: russ@russolsen.com
+executables:
+- notroff
+extensions: []
+extra_rdoc_files: []
+files:
+- readme.nr
+- spec/command_processor_spec.rb
+- spec/composite_processor_spec.rb
+- spec/filter_spec.rb
+- spec/formatter_spec.rb
+- spec/hello.rb
+- spec/hello.rb.out
+- spec/paragraph_joiner_spec.rb
+- spec/simple.nr
+- spec/string_extensions_spec.rb
+- spec/text_spec.rb
+- spec/type_assigner_spec.rb
+- spec/with_commands.nr
+- lib/notroff/code_scrubber.rb
+- lib/notroff/code_typer.rb
+- lib/notroff/command_processor.rb
+- lib/notroff/composite_processor.rb
+- lib/notroff/content.xml.erb
+- lib/notroff/docbook_renderer.rb
+- lib/notroff/embedded.rb
+- lib/notroff/filter.rb
+- lib/notroff/formatter.rb
+- lib/notroff/html_renderer.rb
+- lib/notroff/io.rb
+- lib/notroff/logger.rb
+- lib/notroff/odt_renderer.rb
+- lib/notroff/odt_replacer.rb
+- lib/notroff/paragraph_joiner.rb
+- lib/notroff/processor.rb
+- lib/notroff/skel.odt
+- lib/notroff/string_extensions.rb
+- lib/notroff/template_expander.rb
+- lib/notroff/text.rb
+- lib/notroff/text_replacer.rb
+- lib/notroff/tokenize.rb
+- lib/notroff/type_assigner.rb
+- lib/notroff.rb
+- bin/notroff
+homepage: http://www.russolsen.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: NotRoff A simple text to openoffice filter
+test_files: []