ntxt 1.0.5 → 1.0.6

data/bin/ntxt

@@ -26,13 +26,16 @@ if File.exists?(DEFAULT_CONFIG_FILE)
     $configs.merge!(YAML::load(io))
   end
 else
+  puts("Creating configuration file #{DEFAULT_CONFIG_FILE}")
   File.open(DEFAULT_CONFIG_FILE, 'w') do |io|
     YAML::dump($configs, io)
   end
 end
 
 OptionParser.new do |opt|
-  opt.version="1.0.5"
+  opt.version="1.0.6"
+  opt.banner = "Ussage: #{$0} [options] [ntxt file]\n\n" +
+               "Options:\n"
 
   opt.on('--trace', 'Trace through the file printing summaries.' ) do |v|
     $configs[:cmd] = 'trace'
@@ -55,10 +58,10 @@ OptionParser.new do |opt|
     $configs[:tag_string] = v
   end
   
-  opt.on('--path', 'Print the path down the tree.') do |v|
+  opt.on('--path', 'Print the path to tagged block.') do |v|
     $configs[:tag_print_mode] = 'path'
   end
-  opt.on('--parent', 'Print the whole parent block.') do |v|
+  opt.on('--parent', 'Print parent block of a tagged block.') do |v|
     $configs[:tag_print_mode] = 'parent'
   end
   opt.on('--leaf', 'Print only the tagged block.') do |v|
@@ -154,8 +157,7 @@ module TagPrintModes
   end
 end
 
-$configs[:tag_string] = ARGV.shift if ARGV.length > 0
-
+# Attempt to open the n.txt file or fail with clean error.
 begin
   ntxt = File.open($configs[:filename]) { |io| Ntxt::Ntxt.new(io.read) }
 rescue Errno::ENOENT => e
@@ -163,6 +165,7 @@ rescue Errno::ENOENT => e
   exit 1
 end
 
+# Execute the application command.
 case $configs[:cmd]
 when 'print_tags'
   # Notice that we are re-wrapping the tags back into square brackets.

data/lib/ntxt/block.rb

@@ -29,6 +29,12 @@ module Ntxt
     # The parent Block or nil if this is a root Block.
     attr_accessor :parent
 
+    # The current header level. 0 for no header. 1-6 otherwise.
+    attr_accessor :header
+
+    # The current indent level. If this is a header block, ident=0.
+    attr_accessor :indent
+
     # Create a new Block. Typically you will never need to do this.
     # Blocks are created by Parser.
     # [ntxtObj] The Ntxt object that this block belongs to.
@@ -43,6 +49,8 @@ module Ntxt
       @offset = stopTxt || ntxtObj.text.length
       @ntxt = ntxtObj
       @parent = parentBlock
+      @indent = 0
+      @header = 0
       
       if @parent
         re = /\s*\S/m
@@ -84,7 +92,7 @@ module Ntxt
     end
     
     # Return true if the parent object is nil.
-    def is_root?
+    def root?
       @parent.nil?
     end
     

data/lib/ntxt/parser.rb

@@ -7,158 +7,73 @@ module Ntxt
   # with the exception of Parser.parse.
   class Parser
   
-    # An internal class that contains the current parse position
-    # and current limits on that parse, such as an artificial end-of-file
-    # marker to terminate a sub-parsing of a sub-block.    
-    class State
-    
-      # Array of lines. The result of Ntxt.text being split on '\n'
-      attr_accessor :lines
-      
-      # The current Block being built up.
-      attr_accessor :block
-      
-      # The index into #lines to start parsing at
-      # and before which #prevLine should return nil.
-      attr_accessor :lineStart
-      
-      # The index into #lines at which #nextLine should return nil.
-      # This defaults to #lines.length
-      attr_accessor :lineEnd
-      
-      # The current line this State points at.
-      attr_accessor :line
-      
-      # The index into Ntxt.text that corresponds to the first
-      # character of the #currLine.
-      attr_accessor :start
-      
-      # The offset from #start. The substring of Ntxt.text
-      # starting at #start and of length #offset will produce the
-      # text being considered by this State.
-      attr_accessor :offset
-    
-      def initialize(lines, block, lineStart, start, lineEnd)
-        @lines     = lines      # The array of lines to parse.
-        @block     = block      # The block this state is operating on.
-        @lineStart = lineStart  # The starting line in this state.
-        @line      = lineStart  # The current line this state points at.
-        @lineEnd   = lineEnd    # The last line. @lineEnd <= @lines.length.
-        @start     = start      # Start index in text.
-        @offset    = 0          # Offset from @start.
-      end
-      
-      # Return the current line. If #prevLine or #nextLine has
-      # walked outside of the #lineStart or #lineEnd limits this will
-      # return nil.
-      def currLine
-        if @line < @lineEnd && @line >= @lineStart
-          @lines[@line]
-        else
-          nil
-        end
-      end
-      
-      # Return the next line (#line + 1) unless we step beyond #lineEnd.
-      # If we exceed #lineEnd, nil is returned.
-      # Notice that this also updates #offset.
-      def nextLine
-      
-        # If we are already past the end, return nil, do nothing.
-        if @line >= @lineEnd
-          nil
-          
-        # Otherwise we are updating some state.
-        else
-          @offset = @offset + @lines[@line].length + 1
-          @line = @line + 1
-          
-          # Recheck if we are inside the array and return nil if we are not.
-          (@line < @lineEnd) ? @lines[@line] : nil
-        end        
-      end # nextLine
-      
-      # Return the previous line (#line - 1) unless we step before #lineStart.
-      # If we exceed #lineStart, nil is returned.
-      # Notice that this also updates #offset.
-      def prevLine
-        if @line < @lineStart
-          nil
-        else
-          nLine = @line - 1
-          @offset = @offset - @lines[nLine].length - 1
-          @line = nLine
-          @lines[nLine]
-        end
-      end # prevLine
-      
-      # Shift the state starting points to the current position of 
-      # what has been read in this state, effecitvely consuming that input.
-      #
-      # The #start field is moved to #start+offset. The #offset is set to 0.
-      # Finally the #lineStart is set to #line.
-      def consume
-        @start = @start + @offset
-        @offset = 0
-        @lineStart = @line
-      end
-      
-      # Print as a string.
-      def to_s
-        "lineStart: %s, lineEnd: %s, line: %s, start: %s, offset: %s"%[
-          @lineStart, @lineEnd, @line, @start, @offset
-        ]
-      end
-      
-      # Seek this state's position forward to the given state's position.
-      # If a state with a position behind the current state's position is
-      # passed in as an argument the behavior is undefined.
-      def seek(state)
-        @line = state.line
-        @offset = (state.start + state.offset - @start).abs()
-      end # seek
-      
-    end # Parser::State
-
-
-    
     # Return an array in which the first element is the indent length and
     # the second element is the contained text. Nil otherwise.
-    def self.hlevel(line)
+    def hlevel()
+      line = @lines[@currentLine]
+
+      nextLine = if @lines.length > @currentLine + 1
+        @lines[@currentLine+1]
+      else
+        nil
+      end
+
       case line
       when /^\s*=([^=].*)=\s*$/
-        [ 1, $~[1] ]
+        [ 1, $~[1], 1 ]
       when /^\s*==([^=].*)==\s*$/
-        [ 2, $~[1] ]
+        [ 2, $~[1], 1 ]
       when /^\s*===([^=].*)===\s*$/
-        [ 3, $~[1] ]
+        [ 3, $~[1], 1 ]
       when /^\s*====([^=].*)====\s*$/
-        [ 4, $~[1] ]
+        [ 4, $~[1], 1 ]
       when /^\s*=====([^=].*)=====\s*$/
-        [ 5, $~[1] ]
+        [ 5, $~[1], 1 ]
       when /^\s*======([^=].*)======\s*$/
-        [ 6, $~[1] ]
+        [ 6, $~[1], 1 ]
+      when /^\s*#\s*(.*)$/
+        [ 1, $~[1], 1 ]
+      when /^\s*##\s*(.*)$/
+        [ 2, $~[1], 1 ]
+      when /^\s*###\s*(.*)$/
+        [ 3, $~[1], 1 ]
+      when /^\s*####\s*(.*)$/
+        [ 4, $~[1], 1 ]
+      when /^\s*#####\s*(.*)$/
+        [ 5, $~[1], 1 ]
+      when /^\s*######\s*(.*)$/
+        [ 6, $~[1], 1 ]
       else
-        nil
+        if nextLine && nextLine =~ /\s*==+\s*$/
+          [ 1, line, 2 ]
+        elsif nextLine && nextLine =~ /\s*--+\s*$/
+          [ 2, line, 2 ]
+        else
+          nil
+        end
       end
-    end # self.hlevel
-    
+    end # hlevel
+
+    def computeIndent
+      /^(\s*).*$/.match(@lines[@currentLine])[1].length
+    end
+
+    def closeBlock
+      @currentBlock.offset = @currentOffset - @currentBlock.start - 1
+      @currentBlock = @currentBlock.parent
+    end
+
     # Extract all the tags from the given line.
-    # [block] The block to which all tags will be added with Block#addTag.
-    #         All parent blocks recieve copies of the child block's tag.
-    # [line] The line to extract all tags from. Tags are
-    #        square-bracket-enclosed strings found in sequence at the
-    #        beginning of a line. If the sequence is broken, extraction stops.
     #    Some tag examples:
     #      [a tag] [another tag]
-    #      [a tag] [another tag] Not a tag. [not a tag]
+    #      [a tag] [another tag] Not a tag. [a tag]
     #      No tag on this line.
-    #      No tag on this line either. [not a tag]
-    def self.extractTags(block, line)
-      while line =~ /^\s*\[([^\[]+)\]/m
-        block.addTag($~[1])
-        matchLength = $~[0].length
-        line = line[matchLength,line.length - matchLength]
+    def extractTags()
+      line = @lines[@currentLine]
+      re = /\[([^\[]+)\]/m
+      while line =~ re
+        @currentBlock.addTag($~[1])
+        line = line.sub(re, '')
       end
     end # self.extractTags
     
@@ -171,141 +86,66 @@ module Ntxt
       # If ntxtObj isn't an Ntxt, create it as one.
       ( ntxtObj = Ntxt.new(ntxtObj) ) unless ntxtObj.is_a?( Ntxt )
 
-      lines = ntxtObj.text.split("\n")
-      
       rootBlock = Block.new(ntxtObj)
-      
-      @stack = [ State.new( lines, rootBlock, 0, 0, lines.length ) ]
+
+      @lines = ntxtObj.text.split("\n")
+      @currentLine = 0
+      @currentOffset = 0
+      @currentIndent = 0
+      @currentBlock = rootBlock
       
       parseLines()
       
-      if @stack.length == 1
-        # parse success!
-        rootBlock
-      else
-        # parse failure.
-        nil
-      end
+      rootBlock
     end # parse(ntxtObj)
 
-    # Take the state off the top of the #stack and attempt to parse
-    # an Hlevel block. An HLevel block is a wiki-like header block of text.
-    # For example:
-    #   = Header 1 =
-    #   == Header 2 ==
-    # [level] an integer from 1 to 6.
-    # [title] a string of the text found between the equal signs.
-    def parseHlevel(level, title)
-      state = @stack[-1]
-      
-      # If in parseHlevel, don't get the current line. That is contained
-      # in the title argument. Instead, get the next line and proceed.
-      line = state.nextLine
+    def nextLine
+      @currentOffset += @lines[@currentLine].length + 1
+      @currentLine += 1
+    end
 
-      while line
-        # Check if we have discovered another block in the form of an hlevel.
-        hl = Parser::hlevel(line)
-        
-        break if hl && hl[0] <= level
-        
-        line = state.nextLine
-      end
-      
-      block = Block.new(
-        state.block.ntxt,
-        state.block,
-        state.start,
-        state.offset)
+    def parseLines
+      while @currentLine < @lines.length do
+        extractTags
 
-      subState = State.new(
-        state.lines,
-        block,
-        state.lineStart+1,
-        state.start + state.lines[state.lineStart].length + 1,
-        state.line)
-      
-      @stack.push subState
-      parseLines
-      @stack.pop
-      state.consume
-    end # parseHlevel(leve, title)
-    
-    # Parse blocks of text that are indented at the given level or greater.
-    # [indentLevel] an integer denoteing the number of characters this line is
-    #               indented at.
-    # [text] the content of the line that was indented.
-    def parseIndent(indentLevel, text)
-      state = @stack[-1]
-      line = state.currLine
+        hlvl = hlevel
 
-      # Build the block. Update the offset.
-      block = Block.new(state.block.ntxt,
-                        state.block,
-                        state.start,
-                        state.offset)
+        if hlvl
+          while @currentBlock.header >= hlvl[0] do
+            closeBlock
+          end
 
-      # Position state at the ed of the block.
-      # Blocks are ended by empty lines or lines with the = starting them.
-      while line
+          @currentBlock = Block.new(
+            @currentBlock.ntxt,
+            @currentBlock,
+            @currentOffset)
+          @currentBlock.header = hlvl[0]
 
-        break if Parser::hlevel(line)
-        break unless line =~ /^(\s*)(..*)$/
+          hlvl[2].times { nextLine }
+          @currentIndent = 0
 
-        nextIndentLevel = $~[1].length
-        nextLine = $~[2]
-        
-        break if nextIndentLevel < indentLevel
+          next
+        end
 
-        if nextIndentLevel > indentLevel
-          # Advance to the next line after parsing a subblock.
-          subState = State.new(
-            state.lines,
-            block,
-            state.line, 
-            state.start + state.offset,
-            state.lineEnd)
+        indent = computeIndent
+        if indent < @currentIndent
+          closeBlock
+          @currentIndent = indent
+        elsif indent > @currentIndent
+          @currentBlock = Block.new(
+            @currentBlock.ntxt,
+            @currentBlock,
+            @currentOffset)
+          @currentBlock.indent = indent
+          @currentIndent = indent
+        end
 
-          @stack.push subState
-          parseIndent(nextIndentLevel, nextLine)
-          @stack.pop
-          state.seek subState
-          line = state.currLine
-        else
-          Parser::extractTags(block, line)
-          line = state.nextLine
-        end # if nextIndentLevel > indentLevel
-        
-      end # while line
-      block.offset = state.offset
-      state.consume
-    end # parseIndent(indentLevel, text)
-    
-    # This is the root of the parser's call tree after #parse sets up
-    # the parse. This plucks the State off the Parser.stack, obtains the
-    # State.currLine.
-    # 
-    # When an indented line is found, #parseIndent is called.
-    # When a header line is found, #parseHlevel is caled.
-    # Otherwise, we move to the next line.
-    def parseLines
-      state = @stack[-1]
-      line = state.currLine
-      
-      while line
-        tmp = Parser::hlevel(line)
+        nextLine
+      end
 
-        if tmp
-          state.consume
-          parseHlevel(tmp[0].to_i, tmp[1])
-          line = state.currLine
-        elsif line =~ /^(\s*)(\S.*)$/
-          state.consume
-          parseIndent($~[1].length, $~[2])
-          line = state.currLine
-        else
-          line = state.nextLine
-        end # if tmp
-      end # while line
+      while not @currentBlock.root?
+        closeBlock
+      end
     end # parseLines
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ntxt
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-25 00:00:00.000000000 Z
+date: 2013-02-28 00:00:00.000000000 Z
 dependencies: []
 description: ! 'A library and command line tool for parsing plain text into blocks
   by