ntxt 1.0.0

data/bin/ntxt

@@ -0,0 +1,87 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'optparse'
+require 'ntxt'
+
+$configs = {
+  :cmd => 'tag',
+  :tag_string => ''
+}
+
+OptionParser.new do |opt|
+
+  opt.on('--trace', 'Trace through the file printing summaries.' ) do |v|
+    $configs[:cmd] = 'trace'
+  end
+  
+  opt.on('-p','--print', 'Print the whole file one block at a time.' ) do |v|
+    $configs[:cmd] = 'print'
+  end
+
+  opt.on('-T', '--print_tags', 'Print all tags in the document.') do |v|
+    $configs[:cmd] = 'print_tags'
+  end
+    
+  opt.on('-t', '--tag=String', 'Search and print the give so-tagged blocks.') do |v|
+    $configs[:cmd] = 'tag'
+    $configs[:tag_string] = v
+  end
+    
+  opt.on('-s','--search=String', 'Search the text for.' ) do |v|
+    $configs[:cmd] = 'search'
+    $configs[:search_string] = v
+  end
+end.parse! ARGV
+
+if ARGV.length > 0
+  $configs[:filename] = ARGV.shift
+else
+  puts "No file specified. Exiting"
+  exit 1
+end
+
+def printNonEmpty(txt)
+  if txt
+    txt = txt.strip
+    print txt, "\n" if txt.length > 0
+  end
+end
+
+$configs[:tag_string] = ARGV.shift if ARGV.length > 0
+
+ntxt = File.open($configs[:filename]) { |io| Ntxt::Ntxt.new(io.read) }
+
+case $configs[:cmd]
+when 'print_tags'
+  # Notice that we are re-wrapping the tags back into square brackets.
+  puts "[#{ntxt.rootBlock.tags.sort.join('] [')}]"
+when 'tag'
+  ntxt.walkText(
+    lambda { |txt, depth, block|
+      printNonEmpty txt if block.tags.join(', ').index( $configs[:tag_string])},
+    lambda { |depth, block| },
+    lambda { |depth, block| } )
+when 'search'
+  ntxt.walkText(
+    lambda { |txt, depth, block|
+      printNonEmpty txt if txt && txt.index( $configs[:search_string])},
+    lambda { |depth, block| },
+    lambda { |depth, block| } )
+when 'print'
+  ntxt.walkText(
+    lambda { |txt, depth, block| print txt },
+    lambda { |depth, block| },
+    lambda { |depth, block| } )
+when 'trace'
+  ntxt.walkText(
+    lambda { |txt, depth, block| print txt },
+    lambda { |depth, block| puts "-----> #{depth} #{block.tags.join(',')}" },
+    lambda { |depth, block| puts "<----- #{depth} " } )
+when ''
+  # nop
+when nil
+  # nop
+else
+  puts "Command #{$configs[:cmd]} not found."
+end

data/lib/ntxt.rb

@@ -0,0 +1,3 @@
+require 'ntxt/block'
+require 'ntxt/parser'
+require 'ntxt/ntxt'

data/lib/ntxt/block.rb

@@ -0,0 +1,99 @@
+
+module Ntxt
+
+  # Block constructor
+  # ntxtObj the root Ntxt object.
+  # parentBlock the parent Block object.
+  # startTxt the starting offset in ntxtObj.text where this starts
+  # stopTxt the offset in ntxtObje.text after the startTxt position.
+  # The block of text submitted must be a valid block, meaning, it may
+  # ONLY contain subblocks.
+  class Block
+  
+    attr_accessor :children, :tags, :start, :offset, :ntxt, :parent
+
+    if RUBY_VERSION =~ /^1.8/
+      def self.blockReMatch(re, txt, offset)
+        re.match(txt[offset..-1])
+      end
+    else
+      def self.blockReMatch(re, txt, offset)
+        re.match(text, offset)
+      end
+    end
+        
+    def initialize(ntxtObj, parentBlock=nil, startTxt=0, stopTxt=0)
+      @children = []
+      @tags = []
+      @start = startTxt
+      @offset = stopTxt || ntxtObj.text.length
+      @ntxt = ntxtObj
+      @parent = parentBlock
+      
+      if @parent
+        re = /\s*\S/m
+        #m = re.match( ntxtObj.text, @start )
+        m = Block::blockReMatch(re, ntxtObj.text, @start)
+        if m
+          @indent = m[0].length
+        else
+          @indent = 0
+        end
+        @parent.children.push(self)
+      else
+        @indent = 0
+      end
+    end
+    
+    def addTag(tag)
+      @tags.push(tag)
+      @parent.addTag(tag) if @parent
+    end
+    
+    def text
+      @ntxt.text[@start, @offset]
+    end
+    
+    def is_root?
+      @parent
+    end
+    
+    def walk(&y)
+      yield self
+      @children.each { |c| c.walk(&y) }
+    end
+    
+    # printFunc is a lambda that takes the text, depth, and the node.
+    # enterChild is a lambda that takes depth and the node.
+    # exitChild is a lambda that takes depth and the node.
+    def walkText(printFunc, enterChild, exitChild)
+      walkTextHelper(printFunc, enterChild, exitChild, 0)
+    end
+    
+    def walkTextHelper(printFunc, enterChild, exitChild, depth)
+      enterChild.call(depth, self)
+      
+      if @children.length == 0
+        printFunc.call(text(), depth, self)
+      else
+        prevEnd = @start
+        
+        @children.each do |child|
+          start = prevEnd
+          offset = child.start - start
+          printFunc.call(@ntxt.text[start, offset], depth, self)
+          child.walkTextHelper(printFunc, enterChild, exitChild, depth+1)
+          prevEnd = child.start + child.offset
+        end # @children.each
+        
+        lastChild = @children[-1]
+        start = lastChild.start + lastChild.offset
+        offset = @start + @offset - start
+        
+        printFunc.call(@ntxt.text[start, offset], depth, self)
+      end # else of if @children.length == 0
+      
+      exitChild.call(depth, self)
+    end
+  end
+end

data/lib/ntxt/ntxt.rb

@@ -0,0 +1,26 @@
+
+module Ntxt
+
+  # Root class that contains the text array that Blocks reference 
+  # and the root block.
+  class Ntxt
+    attr_accessor :text, :rootBlock
+  
+    def initialize(text)
+      @text  = text
+      @rootBlock = (Parser.new).parse(self)
+    end
+
+    # walkText(print, enter, exit)
+    # Walk the ntxt tree with 3 callbacks, print, enter, and exit.
+    # Print is a lambda that takes the text, the depth, and a copy of
+    # the Ntxt::Block it is in.
+    # Enter is the same, but is called with no text argument and is called
+    # when a block is entered (that is, the depth has increased by 1).
+    # Exit is the same, but is called with no text argument and is called
+    # when a block is exited (that is, the depth has decreated by 1).
+    def walkText(print, enter, exit)
+      @rootBlock.walkText(print, enter, exit)
+    end
+  end
+end

data/lib/ntxt/parser.rb

@@ -0,0 +1,237 @@
+require 'ntxt/block'
+
+module Ntxt
+  class Parser
+  
+    ###########################################################################
+    class State
+    
+      attr_accessor :lines, :block, :lineStart, :lineEnd, :line, :start, :offset
+    
+      def initialize(lines, block, lineStart, start, lineEnd)
+        @lines = lines
+        @block = block
+        @lineStart = lineStart
+        @lineEnd = lineEnd
+        @line = lineStart
+        @start = start
+        @offset = 0
+      end
+      
+      # Return the current line.
+      def currLine
+        @lines[@line]
+      end
+      
+      # Shift the state to the next line and return that line.
+      # If this goes out of bounds of the text nil is returned.
+      def nextLine
+        nextLine = @line+1
+        if nextLine < @lineEnd
+          nextOffset = @offset + @lines[@line].length + 1
+          @offset = nextOffset
+          @line = nextLine
+          @lines[nextLine]
+        else
+          nil
+        end
+      end # nextLine
+      
+      # Shift the state to the previous line and return that line.
+      # If this goes out of bounds of the text nil is returned.
+      def prevLine
+        nextLine = @line - 1
+        if nextLine >= @lineStart
+          nextOffset = @offset - @lines[nextLine].length - 1
+          @offset = nextOffset
+          @line = nextLine
+          @lines[nextLine]
+        else
+          nil
+        end
+      end # prevLine
+      
+      # Shift the state starting points to the current position of 
+      # what has been read in this state, effecitvely consuming that input.
+      def consume
+        @start = @start + @offset
+        @offset = 0
+        @lineStart = @line
+      end
+      
+      # Create a new state that is framed from the lineStart+1 of this state
+      # and ends at the current line of the given state.
+      def lowerSubState
+        endOfFrame = @line+1
+        
+        endOfFrame = @lineEnd if endOfFrame > @lineEnd
+        
+        State.new(@lines,
+                  @block,
+                  @lineStart+1,
+                  @start + @lines[@lineStart].length + 1,
+                  endOfFrame)
+      end # lowerSubState
+      
+      # Create a new state that is framed with the remaining contents of
+      # this state
+      def upperSubState
+        State.new(@lines, @block, @line, @start + @offset, @lineEnd)
+      end
+      
+      def to_s
+        "lineStart: %s, lineEnd: %s, line: %s, start: %s, offset: %s"%[
+          @lineStart, @lineEnd, @line, @start, @offset
+        ]
+      end
+      
+      # Seek this state's position to the tiven state's position.
+      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)
+      case line
+      when /^\s*=([^=].*)=\s*$/
+        [ 1, $~[1] ]
+      when /^\s*==([^=].*)==\s*$/
+        [ 2, $~[1] ]
+      when /^\s*===([^=].*)===\s*$/
+        [ 3, $~[1] ]
+      when /^\s*====([^=].*)====\s*$/
+        [ 4, $~[1] ]
+      when /^\s*=====([^=].*)=====\s*$/
+        [ 5, $~[1] ]
+      when /^\s*======([^=].*)======\s*$/
+        [ 6, $~[1] ]
+      else
+        nil
+      end
+    end # self.hlevel
+    
+    def self.extractTags(block, line)
+      while line =~ /^\s*\[([^\[]+)\]/m
+        block.addTag($~[1])
+        matchLength = $~[0].length
+        line = line[matchLength,line.length - matchLength]
+      end
+    end # self.extractTags
+    
+    def parse(ntxtObj)
+    
+      # 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 ) ]
+      
+      parseLines()
+      
+      if @stack.length == 1
+        # parse success!
+        rootBlock
+      else
+        # parse failure.
+        nil
+      end
+    end # parse(ntxtObj)
+    
+    def parseHlevel(level, title)
+      state = @stack[-1]
+      
+      begin
+        line = state.nextLine
+        
+        if line
+          hl = Parser::hlevel(line)
+          
+          if hl && hl[0].to_i <= level
+            state.prevLine # Rewind. We steped onto another h block.
+            break
+          end
+        end
+      end while line
+      
+      block = Block.new(state.block.ntxt,
+                        state.block,
+                        state.start,
+                        state.offset)
+      subState = state.lowerSubState
+      subState.block = block
+      @stack.push subState
+      parseLines
+      @stack.pop
+      state.consume
+    end # parseHlevel(leve, title)
+    
+    def parseIndent(indentLevel, text)
+      state = @stack[-1]
+      line = state.currLine
+      
+      # BUild the block. Update the offset.
+      block = Block.new(state.block.ntxt,
+                        state.block,
+                        state.start,
+                        state.offset)
+                              
+      # Position state at the ed of the block.
+      # Blocks are ended by empty lines or lines with the = starting them.
+      while line
+      
+        break unless line =~ /^(\s*)([^=\s].*)$/
+        
+        nextIndentLevel = $~[1].length
+        nextLine = $~[2]
+        
+        break if nextIndentLevel < indentLevel
+        
+        if nextIndentLevel > indentLevel
+          # Advance to the next line after parsing a subblock.
+          subState = state.upperSubState()
+          subState.block = block
+          @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)
+    
+    def parseLines
+      state = @stack[-1]
+      state.block.children = []
+      line = state.currLine
+      
+      while line
+        tmp = Parser::hlevel(line)
+        
+        if tmp
+          state.consume
+          parseHlevel(tmp[0].to_i, tmp[1])
+        elsif line =~ /^(\s*)(\S.*)$/
+          state.consume
+          parseIndent($~[1].length, $~[2])
+        end # if tmp
+        
+        line = state.nextLine
+      end # while line
+    end # parseLines
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: ntxt
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Sam Baskinger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-30 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: |
+  A collection of tools to assist Sam in coding.
+
+email: basking2@yahoo.com
+executables: 
+- ntxt
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- lib/ntxt/block.rb
+- lib/ntxt/parser.rb
+- lib/ntxt/ntxt.rb
+- lib/ntxt.rb
+- bin/ntxt
+has_rdoc: true
+homepage: http://coffeesgone.wordpress.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A parser and some tools for the ntxt text block format.
+test_files: []
+