tartan 0.1.1 → 0.2.0

data/lib/tartan.rb

@@ -1,80 +1,9 @@
-#$Id: tartan.rb 159 2006-07-24 08:13:02Z larry $
+#$Id: tartan.rb 194 2007-04-24 07:53:09Z bitherder $
 
 require 'rubygems'
 require 'yaml'
-require 'core_ext/hash'
-require 'core_ext/match_data'
-require 'wiki_rule'
-require 'symbolize'
-require 'core_ext/module'
-require 'core_ext/array'
-
-class Shelf
-    Front = "\001"
-    Back = "\002"
-
-    def initialize
-        @counter = 0
-        @hash = {}
-    end
-
-    def replacement(i)
-        replacement = String.new(Front + i.to_s + Back)
-    end
-
-    def shelve(string)
-        @counter = @counter.next
-        @hash[@counter] = string
-        replacement(@counter)
-    end
-
-    def putback(text)
-      new_text = text.gsub(/#{Front}([[:digit:]]+)#{Back}/) do
-        putback(@hash[$1.to_i])
-      end
-    end
-end
-
-class ParsedText < String
-    def initialize(claimed, value)
-        super(value)
-        @claimed = claimed
-    end
-
-    def claimed?
-        @claimed
-    end
-end
-
-class ParsedTextList < Array
-    def initialize(*args)
-        self
-        
-        if 1 == args.length
-            add_text(false, args[0])
-        end
-    end
-    
-    def add_text(claimed, text)
-      push(ParsedText.new(claimed, text))
-    end
-
-    def add(text_element)
-      push(text_element)
-    end
-    
-    def add_back(text_element)
-      parsed_text = args.first
-      unshift(parsed_text)
-    end
-
-    def add_back_text(claimed, text)
-      unshift(ParsedText.new(claimed, text))
-    end
-
-    alias :to_s :join
-end
-
+require 'core_ext'
+require 'tartan/wiki_rule'
 
 class Object
   def wiki_hash
@@ -100,260 +29,320 @@ class Array
   end
 end
 
-class WikiDefs < Hash
-  class << self
-    def find_file_in_path(file_name)
-      $:.each do |path|
-        file = path+'/'+file_name
-        return file if File.file?(file) 
+
+module Tartan
+  class Shelf
+      Front = "\001"
+      Back = "\002"
+
+      def initialize
+          @counter = 0
+          @hash = {}
+      end
+
+      def replacement(i)
+          replacement = String.new(Front + i.to_s + Back)
+      end
+
+      def shelve(string)
+          @counter = @counter.next
+          @hash[@counter] = string
+          replacement(@counter)
+      end
+
+      def putback(text)
+        new_text = text.gsub(/#{Front}([[:digit:]]+)#{Back}/) do
+          putback(@hash[$1.to_i])
+        end
       end
-      
-      raise ArgumentError, "Can't find file #{file_name} in Ruby library path"
-    end
   end
-  
-  # Initialize initial defs
-  def initialize(external_defs={})
-    add(external_defs)
+
+  class ParsedText < String
+      def initialize(claimed, value)
+          super(value)
+          @claimed = claimed
+      end
+
+      def claimed?
+          @claimed
+      end
   end
 
-  def find_sub_hash_index(hash_array, title)
-    index = hash_array.index { |sub_hash| 
-      sub_hash.title == title
-    }
+  class ParsedTextList < Array
+      def initialize(*args)
+          if 1 == args.length
+              add_text(false, args[0])
+          end
+      end
+    
+      def add_text(claimed, text)
+        push(ParsedText.new(claimed, text))
+      end
+
+      def add(text_element)
+        push(text_element)
+      end
+    
+      def add_back(text_element)
+        parsed_text = args.first
+        unshift(parsed_text)
+      end
+
+      def add_back_text(claimed, text)
+        unshift(ParsedText.new(claimed, text))
+      end
+
+      alias :to_s :join
   end
+
+  class WikiDefs < Hash
+    class << self
+      def find_file_in_path(file_name)
+        $:.each do |path|
+          file = path+'/'+file_name
+          return file if File.file?(file) 
+        end
+      
+        raise ArgumentError, "Can't find file #{file_name} in Ruby library path"
+      end
+    end
   
-  def add_yaml_file(def_file)
-    file_with_path = WikiDefs.find_file_in_path(def_file)
+    # Initialize initial defs
+    def initialize(external_defs={})
+      add(external_defs)
+    end
 
-    defs = YAML.load_file(file_with_path).symbolize
+    def find_sub_hash_index(hash_array, title)
+      index = hash_array.index { |sub_hash| sub_hash.title == title }
+    end
+  
+    def add_yaml_file(def_file)
+      file_with_path = WikiDefs.find_file_in_path(def_file)
+
+      defs = YAML.load_file(file_with_path).symbolize
     
-    add(defs)
-  end
+      add(defs)
+    end
   
-  def add(defs)
-    defs.wiki_hash {|h| add_hash(h)}
-    self
-  end
+    def add(defs)
+      defs.wiki_hash {|h| add_hash(h)}
+      self
+    end
   
-  def add_hash(external_defs)
-    external_defs.each {|context_name, external_rule_list|
-      self[context_name] ||= []
-#      self[context_name] ||= Dictionary.new
-      rule_dictionary = self[context_name]
+    def add_hash(external_defs)
+      external_defs.each {|context_name, external_rule_list|
+        self[context_name] ||= []
+  #      self[context_name] ||= Dictionary.new
+        rule_dictionary = self[context_name]
       
-      external_rule_list.each { |proto_rule|
-        rule = case proto_rule
-          when WikiRule: proto_rule
-          when Symbol, String: WikiRule.new({ proto_rule => true })
-          when Hash: WikiRule.new(proto_rule);
-          else raise ArgumentError, "each matching rule must be a Hash"
-        end
+        external_rule_list.each { |proto_rule|
+          rule = case proto_rule
+            when WikiRule: proto_rule
+            when Symbol, String: WikiRule.new({ proto_rule => true })
+            when Hash: WikiRule.new(proto_rule);
+            else raise ArgumentError, "each matching rule must be a Hash"
+          end
         
-        if rule.template
-          index = find_sub_hash_index(self[context_name], rule.template)
+          if rule.template
+            index = find_sub_hash_index(self[context_name], rule.template)
       
-          rule = WikiRule.new(self[context_name][index].merge(rule))
-        end
+            rule = WikiRule.new(self[context_name][index].merge(rule))
+          end
         
-        if rule.before
-          # rule_dictionary
-          addByPosition(context_name, rule, :before)
-          rule.placed(:before)
-        elsif rule.after
-          addByPosition(context_name, rule, :after, 1)
-          rule.placed(:after)
-        elsif rule.beginning
-          self[context_name].unshift(rule)
-          rule.placed(:beginning)
-        else
-          self[context_name].push(rule)
-        end
+          if rule.before
+            # rule_dictionary
+            addByPosition(context_name, rule, :before)
+            rule.placed(:before)
+          elsif rule.after
+            addByPosition(context_name, rule, :after, 1)
+            rule.placed(:after)
+          elsif rule.beginning
+            self[context_name].unshift(rule)
+            rule.placed(:beginning)
+          else
+            self[context_name].push(rule)
+          end
+        }
       }
-    }
-  end
+    end
   
-  private
+    private
   
-  def addByPosition(context_name, rule, position, index_offset=0)
-    index = find_sub_hash_index(self[context_name], rule[position])
-
-    unless index
-      raise "\"#{rule.title}\" can not be added #{position.to_s}" +
-            " \"#{rule[position]}\", because it does not exist" 
+    def addByPosition(context_name, rule, position, index_offset=0)
+      index = find_sub_hash_index(self[context_name], rule[position])
+      unless index
+        raise "\"#{rule.title}\" can not be added #{position.to_s}" +
+              " \"#{rule[position]}\", because it does not exist" 
+      end
+      self[context_name].insert(index+index_offset, rule)
     end
-    self[context_name].insert(index+index_offset, rule)
   end
-end
 
-class Tartan < String
-  class << self
-    def yaml(file_name)
-      @defs ||= WikiDefs.new
-      @defs.add_yaml_file(file_name)
-    end
+  class Parser < String
+    class << self
+      def yaml(file_name)
+        @defs ||= WikiDefs.new
+        @defs.add_yaml_file(file_name)
+      end
     
-    def defs
-      @defs
-    end
+      def defs
+        @defs
+      end
     
-    def add_defs (def_set)
-      @defs ||= WikiDefs.new
-      @defs.add(def_set)
-    end
+      def add_defs (def_set)
+        @defs ||= WikiDefs.new
+        @defs.add(def_set)
+      end
 
-    alias :set_defs :add_defs
-  end
+      alias :set_defs :add_defs
+    end
   
-  # parser helper methods
+    # parser helper methods
   
-  def initialize_helper
-    @sequences = {}
-  end
+    def initialize_helper
+      @sequences = {}
+    end
 
-  def count(str)
-    str.length
-  end
+    def count(str)
+      str.length
+    end
 
-  def sequence(sequence_id)
-    @sequences[sequence_id] ||= 0
-    @sequences[sequence_id] += 1
-  end
+    def sequence(sequence_id)
+      @sequences[sequence_id] ||= 0
+      @sequences[sequence_id] += 1
+    end
 
-  def sequence_reset(sequence_id)
-    @sequences[sequence_id] = 0
-  end
+    def sequence_reset(sequence_id)
+      @sequences[sequence_id] = 0
+    end
 
-  def untabify(text)
-    text.gsub(/(\n?)(?:([^\t\n]{4})|([^\t\n]*)\t)/n) {$1+[$+].pack("A4")}
-  end
+    def untabify(text)
+      text.gsub(/(\n?)(?:([^\t\n]{4})|([^\t\n]*)\t)/n) {$1+[$+].pack("A4")}
+    end
 
-  def len(text)
-    text.length
-  end
+    def len(text)
+      text.length
+    end
 
-  def finalize(type, text)
-    text
-  end
+    def finalize(type, text)
+      text
+    end
   
-  # core Tartan methods
+    # core Tartan methods
   
-  def initialize(wstring, options=nil)
-      wstring.gsub!(/\r/, '')
+    def initialize(wstring, options=nil)
+        wstring.gsub!(/\r/, '')
     
-      @default_rule = WikiRule.new
+        @default_rule = WikiRule.new
       
-      @shelf = Shelf.new
+        @shelf = Shelf.new
       
-      @wiki_string = wstring
+        @wiki_string = wstring
       
-      if !options
-          if defined? WikiOptions
-              @options = WikiOptions.dup
-          else
-              @options = {}
-          end
-      else
-          @options = options
-      end
+        if !options
+            if defined? WikiOptions
+                @options = WikiOptions.dup
+            else
+                @options = {}
+            end
+        else
+            @options = options
+        end
       
-      initialize_helper
-  end
+        initialize_helper
+    end
 
-  def substitute(string, match)
-      # do function value substutution
-      local_string = string.gsub(/#\{([a-zA-Z_]+)(?:\((.*?)\))?\}/m) {|to_eval|     
-          function_match = $~
+    def substitute(string, match)
+        # do function value substutution
+        local_string = string.gsub(/#\{([a-zA-Z_]+)(?:\((.*?)\))?\}/m) {|to_eval|     
+            function_match = $~
           
-          # break the parameters up
-          # '-1' used to retain all parameters even if they are empty
-          params = function_match[2].split(/,/,-1)
+            # break the parameters up
+            # '-1' used to retain all parameters even if they are empty
+            params = function_match[2].split(/,/,-1)
 
-          params.collect! { |param|
-            "nul param" ": " + string if ! param
-            substitute(param, match)
-          }
+            params.collect! { |param|
+              "nul param" ": " + string if ! param
+              substitute(param, match)
+            }
 
-          send(function_match[1].to_sym, *params)
-      }
+            send(function_match[1].to_sym, *params)
+        }
 
-      local_string = match.replace(local_string) if match
+        local_string = match.replace(local_string) if match
 
-      # do variable substitution
-      return local_string.gsub(/\{\{\{(.+?)\}\}\}/) {|var| get_var($1)}
-  end
+        # do variable substitution
+        return local_string.gsub(/\{\{\{(.+?)\}\}\}/) {|var| get_var($1)}
+    end
   
-  def shelve(string)
-      @shelf.shelve(string)
-  end
+    def shelve(string)
+        @shelf.shelve(string)
+    end
 
-  def to_type(type=:html)
-      out = @shelf.putback(parse_by_context(type, :block, @wiki_string))
-      finalize(type, out)
-  end
+    def to_type(type=:html, context=:block)
+        out = @shelf.putback(parse_by_context(type, context, @wiki_string))
+        finalize(type, out)
+    end
   
-  alias :to_html :to_type
+    alias :to_html :to_type
   
-  def to_db
-      to_type(:db)
-  end
-  
-  def set_vars(var_cluster, match)
-      return unless var_cluster
+    def set_vars(var_cluster, match)
+        return unless var_cluster
       
-      if Array == var_cluster.class
-          var_cluster.each do |a_hash|
-              set_vars(a_hash, match)
-          end
-          return
-      end
+        if Array == var_cluster.class
+            var_cluster.each do |a_hash|
+                set_vars(a_hash, match)
+            end
+            return
+        end
         
-      local_hash = var_cluster.dup
+        local_hash = var_cluster.dup
 
-      var_cluster.each do |var_name,var_val|
-          var_val = substitute(var_val, match)
-          var_name = substitute(var_name, match)
+        var_cluster.each do |var_name,var_val|
+            var_val = substitute(var_val, match)
+            var_name = substitute(var_name, match)
 
-          local_hash[var_name] = var_val
-          # allow case-insensitive names via :set for markdown
-          local_hash[var_name.downcase] = var_val
-      end
-      @options.merge!(local_hash)
-  end
+            local_hash[var_name] = var_val
+            # allow case-insensitive names via :set for markdown
+            local_hash[var_name.downcase] = var_val
+        end
+        @options.merge!(local_hash)
+    end
   
-  def get_var(var)
-      # not all variable names are downcased
-      value = @options[var]
-      value ||= @options[var.downcase]
-      return value
-  end
+    def get_var(var)
+        # not all variable names are downcased
+        value = @options[var]
+        value ||= @options[var.downcase]
+        return value
+    end
 
-  def parse_by_context(parse_type, parse_context, parse_string)
-    parsing = ParsedTextList.new(parse_string)
+    def parse_by_context(parse_type, parse_context, parse_string)
+      parsing = ParsedTextList.new(parse_string)
 
-    self.class.defs[parse_context].each do |rule|
+      self.class.defs[parse_context].each do |rule|
       
-      if rule.default_rule
-        @default_rule = @default_rule.deep_merge(rule)
-        next if rule.ignore
-      else
-        next if rule.ignore
-        rule = @default_rule.deep_merge(rule)
-      end
+        if rule.default_rule
+          @default_rule = @default_rule.deep_merge(rule)
+          next if rule.ignore
+        else
+          next if rule.ignore
+          rule = @default_rule.deep_merge(rule)
+        end
       
-      if !rule.match && rule.vars_to_set
-        set_vars(rule.vars_to_set, nil)
-      end
+        if !rule.match && rule.vars_to_set
+          set_vars(rule.vars_to_set, nil)
+        end
 
-      if rule.match
-        parsing = rule.parse_element(parse_type, parsing, self)
-      end
+        if rule.match
+          parsing = rule.parse_element(parse_type, parsing, self)
+        end
 
-      if rule.rescan
-        parsing = ParsedTextList.new(parsing.to_s)
-      end                    
-    end
+        if rule.rescan
+          parsing = ParsedTextList.new(parsing.to_s)
+        end                    
+      end
             
-    parsing.to_s
+      parsing.to_s
+    end
   end
-end
+end # Tartan

data/test/test-combo.rb

@@ -1,23 +1,30 @@
 #!/usr/bin/env ruby
-#$Id: test-combo.rb 159 2006-07-24 08:13:02Z larry $
+#$Id: test-combo.rb 190 2007-02-22 15:12:19Z bitherder $
 
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 
-require 'tartan_markdown'
-require 'tartan_wikilink_def'
-require 'tartan_table_def'
+require 'tartan/markdown'
+require 'tartan/wikilink/rules'
+require 'tartan/table/rules'
+require 'tartan/test/wiki-test'
 require 'wikilink-test-helper'
-require 'wiki-test'
 
-class TartanTestAll < Tartan
-  include TartanMarkdownDef
-  include TartanWikilinkDef
-  include TartanTableDef
-  include WikilinkTestHelper
+module Tartan
+  module Combo
+    class Parser < Tartan::Parser
+      include Tartan::Markdown::Rules
+      include Tartan::Wikilink::Rules
+      include Tartan::Table::Rules
+      include WikilinkTestHelper
+    end
+  end
 end
 
-cases = WikiTestCases.new(TartanTestAll, 
-                          [ "test-wikilink.yml",
-                            "test-markdown.yml",
-                            "test-tables.yml"])
+cases = WikiTestCases.new(  Tartan::Combo::Parser, 
+                            [ "test-wikilink.yml",
+                              "test-markdown.yml",
+                              "test-tables.yml",
+                              "test-combo.yml"
+                            ]
+                         )
 

data/test/test-combo.yml

@@ -0,0 +1,17 @@
+#$Id: test-tables.yml 124 2006-05-07 16:28:09Z larry $
+
+title: TableInCodeBlock
+in: "    [|bob||jim|]"
+html: |-
+  <pre><code>[|bob||jim|]
+  </code></pre>
+---
+title: TableInBackquotes
+in: '`[|bob||jim|]`'
+html: |-
+  <p><code>[|bob||jim|]</code></p>
+---
+title: 
+in: "[| [[Blog]] (new!) |]"
+html: |-
+  <table class=""><tr><td><a class="existing" href="/prefix/Blog">Blog</a> (new!)</td></tr></table>

data/test/test-markdown-and-wikilink.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+#$Id: test-markdown-and-wikilink.rb 194 2007-04-24 07:53:09Z bitherder $
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'tartan'
+require 'tartan/wikilink/rules'
+require 'tartan/test/wiki-test'
+require 'tartan/test/base_rules'
+require 'wikilink-test-helper'
+
+module Tartan
+  module Wikilink
+    class Parser < Tartan::Parser
+      include Tartan::Markdown::Rules
+      include Tartan::Wikilink::Rules
+      include WikilinkTestHelper
+    end
+  end
+end
+
+cases = WikiTestCases.new(Tartan::Wikilink::Parser, "test-markdown-and-wikilink.yml")