tartan 0.1.0

data/lib/symbolize.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+#
+#  Created by Larry Baltz
+#  Copyright (c) 2006. All rights reserved.
+
+class Object
+  def symbolize; self; end
+end
+
+class String
+    def symbolize; match(/\A\w+\z/) ? to_sym : self; end
+end
+
+class Array
+  def symbolize; map { |e| e.symbolize }; end
+end
+
+class Hash
+  def symbolize
+    inject({}) do |hash, (attribute, value)|
+      hash[attribute.symbolize] = value.symbolize
+      hash
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+  
+  class TestSymbolize < Test::Unit::TestCase
+    def test_integer_symbolize
+      assert_equal(1, 1.symbolize)
+    end
+    
+    def test_string_symbolize
+      assert_equal(:expected, "expected".symbolize)
+    end
+    
+    def test_array_symbolize
+      array = ('a'..'d').to_a
+      expected = array.map { |e| e.to_sym }
+      
+      assert_equal(expected, array.symbolize)
+    end
+    
+    def test_hash_symbolize
+      hash = {'a' => 'x', 'b' => 'y', 'c' => 'z'}
+      
+      expected = hash.inject({}) { |h, (a, v)|  h[a.to_sym] = v.to_sym; h }
+      
+      assert_equal(expected, hash.symbolize)
+    end
+
+    def test_array_with_non_word_element
+      assert_equal([:a, :b, :c, 'x x'], ['a', 'b', 'c', 'x x'].symbolize)
+    end
+
+    def test_hash_with_non_word_strings
+      assert_equal( {:a => :x, :b => :y, :c => 'a b', 'x x' => :c},
+                    { 'a' => 'x', 
+                      'b' => 'y', 
+                      'c' => 'a b', 
+                      'x x' => 'c'
+                    }.symbolize 
+                  )
+    end
+
+    def test_hash_with_array_inside
+      assert_equal( {:a => :x, :b => [ :c, :d, 'x x']},
+                    {'a' => 'x', 'b' => [ 'c', 'd', 'x x']}.symbolize )
+    end
+    
+    def test_array_with_hash_inside                             
+      assert_equal( [:a , { :b => :c, :d => 'x x'}],
+                    ['a' , { 'b' => 'c', 'd' => 'x x'}].symbolize )
+    end
+  end
+end

data/lib/table.yml

@@ -0,0 +1,63 @@
+block:
+  - title: table
+    html: 
+      start_mark: "<table class=\"\\1\">\n"
+      end_mark: </table>
+    after: html_comment
+    match: |-
+      / (?:\[([\w]*)[|!](?:.*?)\|\])
+        (?:\s*)
+        (?:(?:\[[|!](?:.*?)\|\])(?:\s*))*/mx
+    subparse: table
+table: 
+  - title: spanrow
+    match: "/\[(?:[\w]*)([|!]\s*.*?\s*\|)\](?:\s*)/"
+    subparse: 
+      match_group: 1
+      context: span_table_row
+    html: 
+      start_mark: <tr>
+      end_mark: "</tr>\n"
+  - title: blockrow
+    match: "/\[(?:[\w]*)([|!]\s*.*?\s*\|)\](?:\s*)/m"
+    subparse: 
+      match_group: 1
+      context: block_table_row
+    html: 
+      start_mark: <tr>
+      end_mark: "</tr>\n"
+span_table_row: 
+  - title: span_th
+    match: "/\! \s* (.*?) \s* \|(?=[|!]|\z)/mx"
+    subparse: 
+      match_group: 1
+      context: span
+    html: 
+      start_mark: <th>
+      end_mark: </th>
+  - title: span_td
+    match: "/\| \s* (.*?) \s* \|(?=[|!]|\z)/mx"
+    subparse: 
+      match_group: 1
+      context: span
+    html: 
+      start_mark: <td>
+      end_mark: </td>
+block_table_row: 
+  - title: block_th
+    match: "/\! \s* (.*?) \s* \|(?=[|!]|\z)/mx"
+    subparse: 
+      match_group: 1
+      context: block
+    html: 
+      start_mark: <th>
+      end_mark: </th>
+  - title: block_td
+    match: "/\| \s* (.*?) \s* \|(?=[|!]|\z)/mx"
+    subparse: 
+      match_group: 1
+      context: block
+    html: 
+      start_mark: <td>
+      end_mark: </td>
+

data/lib/tartan.rb

@@ -0,0 +1,359 @@
+#$Id: tartan.rb 159 2006-07-24 08:13:02Z larry $
+
+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
+
+
+class Object
+  def wiki_hash
+    raise ArgumentError, "Argument can not generate a WikiDef"
+  end
+end
+
+class Hash
+  def wiki_hash
+    yield self
+  end
+end
+
+class String
+  def wiki_hash
+    yield YAML.load(self).symbolize
+  end
+end
+
+class Array
+  def wiki_hash
+    each { |element| yield element }
+  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) 
+      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)
+  end
+
+  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
+  
+  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]
+      
+      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)
+      
+          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
+      }
+    }
+  end
+  
+  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" 
+    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
+    
+    def defs
+      @defs
+    end
+    
+    def add_defs (def_set)
+      @defs ||= WikiDefs.new
+      @defs.add(def_set)
+    end
+
+    alias :set_defs :add_defs
+  end
+  
+  # parser helper methods
+  
+  def initialize_helper
+    @sequences = {}
+  end
+
+  def count(str)
+    str.length
+  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 untabify(text)
+    text.gsub(/(\n?)(?:([^\t\n]{4})|([^\t\n]*)\t)/n) {$1+[$+].pack("A4")}
+  end
+
+  def len(text)
+    text.length
+  end
+
+  def finalize(type, text)
+    text
+  end
+  
+  # core Tartan methods
+  
+  def initialize(wstring, options=nil)
+      wstring.gsub!(/\r/, '')
+    
+      @default_rule = WikiRule.new
+      
+      @shelf = Shelf.new
+      
+      @wiki_string = wstring
+      
+      if !options
+          if defined? WikiOptions
+              @options = WikiOptions.dup
+          else
+              @options = {}
+          end
+      else
+          @options = options
+      end
+      
+      initialize_helper
+  end
+
+  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)
+
+          params.collect! { |param|
+            "nul param" ": " + string if ! param
+            substitute(param, match)
+          }
+
+          send(function_match[1].to_sym, *params)
+      }
+
+      local_string = match.replace(local_string) if match
+
+      # do variable substitution
+      return local_string.gsub(/\{\{\{(.+?)\}\}\}/) {|var| get_var($1)}
+  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
+  
+  alias :to_html :to_type
+  
+  def to_db
+      to_type(:db)
+  end
+  
+  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
+        
+      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)
+
+          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 parse_by_context(parse_type, parse_context, parse_string)
+    parsing = ParsedTextList.new(parse_string)
+
+    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.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.rescan
+        parsing = ParsedTextList.new(parsing.to_s)
+      end                    
+    end
+            
+    parsing.to_s
+  end
+end