org 2009.03.28

data/CHANGELOG

@@ -0,0 +1,36 @@
+[96fa8b5 | Sat Mar 28 06:57:31 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Better rake tasks, now managed by raku
+
+[971a989 | Fri Mar 20 05:23:05 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Spec how lists behave right now
+
+[c21d3fb | Sun Mar 15 06:39:58 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Fix the header spec
+
+[93db8d3 | Sun Mar 15 06:35:43 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Transform input to use \n, add specs for it
+
+[9b1ff3a | Sat Feb 21 04:49:40 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Fix gemspec
+
+[bca87be | Sat Feb 21 04:47:40 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Add the Rakefile
+
+[f304ebf | Sat Feb 21 03:40:35 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Version 2009.02.21
+
+[ca4d900 | Thu Jan 01 14:55:47 UTC 2009] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Org for rakki
+
+[3b1f2d2 | Sun Oct 12 08:22:45 UTC 2008] Michael Fellinger <m.fellinger@gmail.com>
+
+  * Extracted from rakki
+

data/MANIFEST

@@ -0,0 +1,29 @@
+CHANGELOG
+MANIFEST
+README.md
+Rakefile
+doc/syntax.org
+lib/org.rb
+lib/org/markup.rb
+lib/org/rule.rb
+lib/org/rules.rb
+lib/org/scope.rb
+lib/org/scope/org_mode.rb
+lib/org/state.rb
+lib/org/stringscanner.rb
+lib/org/to/html.rb
+lib/org/to/toc.rb
+lib/org/token.rb
+lib/org/version.rb
+org.gemspec
+spec/org.rb
+tasks/bacon.rake
+tasks/changelog.rake
+tasks/gem.rake
+tasks/gem_installer.rake
+tasks/grancher.rake
+tasks/install_dependencies.rake
+tasks/manifest.rake
+tasks/rcov.rake
+tasks/release.rake
+tasks/reversion.rake

data/README.md

@@ -0,0 +1,26 @@
+# Org
+
+Org provides transformation of a selected subset of org-mode markup for wikis.
+
+## About
+
+If you fancy emacs' org-mode and would like to use its power for a wiki based on plain-text files you should check this out.
+Org tries to stay compatible with org-mode, but does not support the full syntax. The most notable features you will find are table of contents, tables, headers, links and simple physical text formatting.
+One feature org-mode doesn't provide (AFAIK) is code highlighting, since the preferred way is to simply link to the file containing the code, but that is a bit impractical in a wiki, so I added this feature.
+
+## Features
+
+* Headers
+* Links
+* Tables
+* Text markup
+
+## Dependencies
+
+* StringScanner (ruby stdlib)
+* CodeRay (optional)
+* Uv (optional)
+
+## Syntax
+
+For a nice intro to the syntax supported by Org please check the [doc/syntax.org] file.

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'time'
+require 'date'
+
+PROJECT_SPECS = Dir['spec/**/*.rb']
+PROJECT_MODULE = 'Org'
+
+GEMSPEC = Gem::Specification.new{|s|
+  s.name         = 'org'
+  s.author       = "Michael 'manveru' Fellinger"
+  s.summary      = "transformation of a subset of org-mode markup to html."
+  s.description  = "transformation of a subset of org-mode markup to html."
+  s.email        = 'm.fellinger@gmail.com'
+  s.homepage     = 'http://github.com/manveru/org'
+  s.platform     = Gem::Platform::RUBY
+  s.version      = (ENV['PROJECT_VERSION'] || Date.today.strftime("%Y.%m.%d"))
+  s.files        = `git ls-files`.split("\n").sort
+  s.has_rdoc     = true
+  s.require_path = 'lib'
+}
+
+Dir['tasks/*.rake'].each{|f| import(f) }
+
+task :default => [:bacon]
+
+CLEAN.include('')

data/doc/syntax.org

@@ -0,0 +1,73 @@
+* OrgMarkup
+
+** Links
+
+Internal Links follow the [[Wiki]] [[Wiki][Wiki Wiki]] style, also WikiWords work.
+
+To recap:
+
+[[Wiki]] is `[[Wiki]]`
+[[Wiki][Wiki]] is `[[Wiki][Wiki]]`
+WikiWords was `WikiWords`
+
+You can easily plug into the handling of links and implement things like `[[flash:screencast-blog][My Screencast about Blogging]]`, but by default there will be no link formatting until I can find a nice set of defaults.
+
+** Lists
+
+ * Lists start with a `*` after one or more spaces from the beginning of a line.
+   * Nested lists are maybe not working correctly yet.
+
+** Headers
+
+Headers are written as follows:
+
+{{{
+* h1
+** h2
+*** h3
+**** h4
+***** h5
+****** h6
+}}}
+
+** Code
+
+You can start a code block with `{{{` and end it with `}}}`, each on its own line. For code inside a line please use =`backticks`=.
+
+{{{
+This is a line of code
+}}}
+
+
+{{{ ruby
+puts "This is a line of Ruby code"
+}}}
+
+You may also use `c`, `delphi`, `html`, `ezamar`, `nitro_xhtml`, `plaintext`, `rhtml`, or `xml`
+
+** Text formatting
+
+/italic/ is `/italic/`
+*bold* is `*bold*`
+_underline_ is `_underline_`
++strikethrough+ is `+strikethrough+`
+~blockquote~ is `~blockquote~`
+=code= is `=code=`
+and `code` is =`code`=
+last, but not least, there's also `----` the horizontal rule
+
+----
+
+** Tables
+
+|--------------+-------------------------+----------------|
+| Name         | Telephone               | Room           |
+|--------------+-------------------------+----------------|
+| Mr. X        | 777-777                 | 42             |
+| Mrs. Y       | 888-888                 | 21             |
+| see?         | tables                  | are            |
+| easy         | enough                  | eh?            |
+|--------------+-------------------------+----------------|
+| you can even | use separating elements | but they won't |
+| show up      | in the                  | endresult.     |
+|--------------+-------------------------+----------------|

data/lib/org.rb

@@ -0,0 +1,28 @@
+require 'strscan'
+require 'pp'
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+module Org
+  module_function
+
+  def escape_html(string)
+    string.to_s.gsub("&", "&").
+      gsub("<", "&lt;").
+      gsub(">", "&gt;").
+      gsub("'", "&#39;").
+      gsub('"', "&quot;")
+  end
+end
+
+require 'org/version'
+require 'org/stringscanner'
+require 'org/markup'
+require 'org/state'
+require 'org/scope'
+require 'org/token'
+require 'org/rule'
+
+require 'org/scope/org_mode'
+require 'org/to/html'
+require 'org/to/toc'

data/lib/org/markup.rb

@@ -0,0 +1,34 @@
+module Org
+  class Markup
+    attr_accessor :string
+
+    def initialize(file = nil)
+      self.string = File.read(file) if file
+    end
+
+    def apply(string = @string)
+      self.string = string
+
+      parent = RootToken.new(:root, nil)
+      scanner = StringScanner.new(self.string)
+      state = State.new(@scope, parent, scanner)
+
+      until scanner.eos?
+        pos = scanner.pos
+        state.step
+        raise("Didn't move: %p" % scanner) if pos == scanner.pos
+      end
+
+      return parent
+    end
+
+    def scope(name, options = {}, &block)
+      @scope = Scope.new(name, options)
+      yield(@scope)
+    end
+
+    def string=(string)
+      @string = string.gsub(/\r\n|\r/, "\n")
+    end
+  end
+end

data/lib/org/rule.rb

@@ -0,0 +1,43 @@
+module Org
+  class Rule
+    DEFAULT = {
+      :bol => false,
+      :start => nil,
+      :end => nil,
+      :unscan => false,
+    }
+
+    attr_accessor :name, :regex
+
+    def initialize(name, regex, options = {}, &block)
+      @name, @regex, @block = name, regex, block
+      @options = DEFAULT.merge(options)
+    end
+
+    def match(state)
+      scope, parent, scanner = state.scope, state.parent, state.scanner
+      return if @options[:bol] and not scanner.bol?
+
+      return false unless scanner.scan(@regex)
+      scanner.unscan if @options[:unscan]
+
+      name = @options[:tag] || @name
+      token = Token.new(name, scanner.captures, &@block)
+      return true if @options[:ignore]
+
+      if mode = @options[:start]
+        # puts "Start #{mode}"
+        state.scope = mode.is_a?(Scope) ? mode : scope.scopes[mode]
+        parent << token
+        state.parent = token
+      elsif mode = @options[:end]
+        # puts "End #{mode}"
+        state.parent = parent.parent
+        state.scope = scope.parent
+      else
+        parent << token
+        return true
+      end
+    end
+  end
+end

data/lib/org/rules.rb

@@ -0,0 +1,108 @@
+require 'org'
+
+# rs = RuleSet.new("~/c/innate/example/app/wiki/pages/Home.owl")
+rs = OrgMarkup.new("test.org")
+
+rs.scope(:block, :indent => true) do |block|
+  block.rule :header, /(\*+)\s+(.*)\n/, :bol => true
+  block.rule :table, /\|([^|]+)/, :bol => true, :start => :table, :unscan => true
+  block.rule :br, /\n/
+  block.rule :p, /(.)/, :bol => true, :start => :inline, :unscan => true
+  block.rule :space, /\s/
+
+  inline_rules = lambda do |parent|
+    # * You can make words *bold*, /italic/, _underlined_, `=code=' and
+    #   `~verbatim~', and, if you must, `+strikethrough+'.  Text in the
+    #   code and verbatim string is not processed for org-mode specific
+    #   syntax, it is exported verbatim.
+    parent.rule :a, /\b([A-Z]\w+[A-Z]\w+)/
+    parent.rule :text, /([A-Za-z0-9,. ]+)/
+    # [[file:foo][My file foo]]
+    parent.rule :a, /\[\[([^:\]]+):([^\]]+)\]\[([^\]]+)\]\]/
+    # [[http://go.to/][Go to]]
+    parent.rule :a, /\[\[([^\]]+)\]\[([^\]]+)\]\]/
+    # [[file:foo]]
+    parent.rule :a, /\[\[([^:\]]+):([^\]]+)\]\]/
+    # [[foo]]
+    parent.rule :a, /\[\[([^\]]+)\]\]/
+    parent.rule :italic, /\/([^\/]+)\//
+    parent.rule :bold, /\*([^*]+)\*/, :tag => :b
+    parent.rule :underline, /_([^_]+)_/
+    parent.rule :strikethrough, /\+([^+]+)\+/
+    parent.rule :verbatim, /~([^~]+)~/
+    parent.rule :code, /\=([^=]+)\=/
+  end
+
+  block.scope(:inline, :indent => false) do |inline|
+    inline.apply(&inline_rules)
+    inline.rule :text, /(.)/
+    inline.rule :close, /\n\n+/, :end => :inline
+    inline.rule :br, /\n/
+  end
+
+  block.scope(:table, :indent => true) do |table|
+#     | name   | telelphone | room |
+#     |--------+------------+------|
+#     | Mr. X  |    777-777 |   42 |
+#     | Mrs. Y |    888-888 |   21 |
+
+    table.rule :tr, /\|([^|]+)/, :bol => true, :unscan => true, :start => :tr
+    table.rule :close, /\n/, :end => :table
+
+    table.scope(:tr, :indent => true) do |tr|
+      tr.rule :table_separator, /\|[+-]+\|/
+      tr.rule :close, /\|\n/, :end => :tr
+      tr.rule :close, /\n/, :end => :tr
+      tr.rule :td, /\|/, :start => :td
+
+      tr.scope :td do |td|
+        td.apply(&inline_rules)
+        td.rule :space, /([\t ]+)/
+        td.rule :text, /([^|])/
+        td.rule :close, /\|/, :end => :td, :unscan => true
+      end
+    end
+  end
+end
+
+require 'pp'
+
+class OrgMarkup
+  module ToHtml
+    def html_link(leader, href = nil, title = nil)
+      case leader
+      when 'rss'
+        link_rss(href, title)
+      when 'file'
+        link_file(href, title)
+      when 'http', 'https', 'ftp'
+        link_out("#{leader}:#{href}", title)
+      else
+        link_in(leader, href)
+      end
+    end
+
+    # Respond to [[rss:href]] and [[rss:href][title]]
+    def link_rss(href, title)
+      "<rss %p %p>" % [href, title]
+      ''
+    end
+
+    # Respond to [[file:href]] and [[file:href][title]]
+    def link_file(href, title)
+      "<file %p %p>" % [href, title]
+      ''
+    end
+
+    def link_out(href, title)
+      "<out %p %p>" % [href, title]
+      tag(:a, title || href, :href => href)
+    end
+
+    # Respond to [[name]] and [[name][title]]
+    def link_in(href, title)
+      "<wiki %p %p>" % [href, title]
+      tag(:a, title || href, :href => "/#{href}")
+    end
+  end
+end

data/lib/org/scope.rb

@@ -0,0 +1,35 @@
+module Org
+  class Scope
+    attr_accessor :parent, :name, :scopes
+
+    def initialize(name, options = {})
+      @rules = []
+      @name, @options = name, options
+      @scopes = {}
+    end
+
+    def scope(name, options = {}, &block)
+      scope = Scope.new(name, options)
+      scope.parent = self
+      yield @scopes[name] = scope
+    end
+
+    def rule(name, regex, options = {})
+      @rules << Rule.new(name, regex, options)
+    end
+
+    def apply
+      yield(self)
+    end
+
+    def step(state)
+      @rules.find do |rule|
+        rule.match(state)
+      end
+    end
+
+    def inspect
+      "<Scope #{name}>"
+    end
+  end
+end

data/lib/org/scope/org_mode.rb

@@ -0,0 +1,93 @@
+module Org
+  OrgMode = Markup.new
+  eol = /\n/ # we keep this simple and convert the input string instead
+
+  OrgMode.scope(:block, :indent => true) do |block|
+    block.rule :header, /(\*+)\s+(.*)(#{eol}|\z)/, :bol => true
+    block.rule :table, /\|([^|]+)/, :bol => true, :start => :table, :unscan => true
+    block.rule :ul, /[ \t]+[\*\+\-]+\s*(.*)/, :start => :ul, :unscan => true, :bol => true
+    block.rule :ol, /[ \t]+[0-9]+[\.\)]\s*(.*)/, :start => :ol, :unscan => true, :bol => true
+    block.rule :br, eol
+    block.rule :p, /(.)/, :bol => true, :start => :inline, :unscan => true
+    block.rule :space, /\s/
+
+    inline_rules = lambda do |parent|
+      # * You can make words *bold*, /italic/, _underlined_, `=code=' and
+      #   `~verbatim~', and, if you must, `+strikethrough+'.  Text in the
+      #   code and verbatim string is not processed for org-mode specific
+      #   syntax, it is exported verbatim.
+      parent.rule :a, /\b([A-Z]\w+[A-Z]\w+)/
+      parent.rule :text, /([A-Za-z0-9,. ]+)/
+      #      parent.rule :text, /(\/\/)/
+      parent.rule :a, /\[\[([^\]]+)\]\[([^\]]+)\]\]/
+      parent.rule :a, /\[\[(.+?)\]\]/
+      parent.rule :italic, /\/([^\/ ]+)\//, :tag => :i
+      parent.rule :bold, /\*([^* ]+)\*/, :tag => :b
+      parent.rule :underline, /_([^_ ]+)_/, :tag => :u
+      parent.rule :strikethrough, /\+([^+ ]+)\+/, :tag => :s
+      parent.rule :blockquote, /~([^~ ]+)~/
+      parent.rule :code, /\=([^= ]+)\=/
+      parent.rule :code, /`([^`]+)`/
+      parent.rule :hr, /---+/, :bol => true
+    end
+
+    block.scope :ul do |ul|
+      ul.rule :li, /[ \t]+[\*\+\-]+\s*/, :start => :li, :bol => true
+      ul.rule :close, eol, :end => :ul
+      ul.rule :close, /(.)/, :end => :ul, :unscan => true
+
+      ul.scope :li do |li|
+        li.apply(&inline_rules)
+        li.rule :text, /(.)/
+        li.rule :ul, /[ \t]+[\*\+\-]+\s*/, :start => ul, :bol => true
+        li.rule :close, eol, :end => :li
+      end
+    end
+
+    block.scope :ol do |ol|
+      ol.rule :li, /[ \t]+[0-9]+[\.\)]\s*/, :start => :li, :bol => true
+      # ol.rule :ul, /[ \t]+[\*\-\+]+\s*/, :start => :ul, :bol => true, :unscan => true
+      ol.rule :close, eol, :end => :ol
+      ol.rule :close, /(.)/, :end => :ol, :unscan => true
+
+      ol.scope :li do |li|
+        li.apply(&inline_rules)
+        li.rule :text, /(.)/
+        li.rule :close, eol, :end => :li
+      end
+    end
+
+    block.scope(:inline, :indent => false) do |inline|
+      inline.apply(&inline_rules)
+      inline.rule :highlight, /\{\{\{[\t ]*(\S+)#{eol}(.*?)#{eol}\}\}\}/m
+      inline.rule :highlight, /\{\{\{#{eol}(.*?)#{eol}\}\}\}/m
+      inline.rule :text, /(.)/
+      inline.rule :close, /#{eol}#{eol}+/, :end => :inline
+      inline.rule :br, eol
+    end
+
+    block.scope(:table, :indent => true) do |table|
+      # | name   | telelphone | room |
+      # |--------+------------+------|
+      # | Mr. X  |    777-777 |   42 |
+      # | Mrs. Y |    888-888 |   21 |
+
+      table.rule :tr, /\|([^|]+)/, :bol => true, :unscan => true, :start => :tr
+      table.rule :close, eol, :end => :table
+
+      table.scope(:tr, :indent => true) do |tr|
+        tr.rule :table_separator, /\|[+-]+\|/, :ignore => true
+        tr.rule :close, /\|#{eol}/, :end => :tr
+        tr.rule :close, eol, :end => :tr
+        tr.rule :td, /\|/, :start => :td
+
+        tr.scope :td do |td|
+          td.apply(&inline_rules)
+          td.rule :space, /([\t ]+)/
+          td.rule :text, /([^|])/
+          td.rule :close, /\|/, :end => :td, :unscan => true
+        end
+      end
+    end
+  end
+end

data/lib/org/state.rb

@@ -0,0 +1,12 @@
+module Org
+  class State < Struct.new(:scope, :parent, :scanner)
+    def step
+      loop do
+        # before = scanner.string[0...scanner.pos][-25, 25]
+        # after = scanner.string[scanner.pos..-1][0, 50]
+        # p "%40s@%40s" % [before, after]
+        break unless scope.step(self)
+      end
+    end
+  end
+end

data/lib/org/stringscanner.rb

@@ -0,0 +1,16 @@
+require 'strscan'
+
+module Org
+  # Adding some comfort
+  class StringScanner < ::StringScanner
+    # Equivalent to Regexp#captures, returns Array of all matches
+    def captures
+      n = 0
+      found = []
+      while n += 1
+        return found unless element = self[n]
+        found << element
+      end
+    end
+  end
+end

data/lib/org/to/html.rb

@@ -0,0 +1,91 @@
+module Org
+  class RootToken < Token
+    # little optimization, avoid check for root
+    def to_html
+      @childs.map{|child| child.to_html }.join
+    end
+  end
+
+  module ToHtml
+    def to_html
+      method = "html_#{@name}"
+
+      if respond_to?(method)
+        send(method)
+      elsif @childs.empty?
+        Tag.new(name, values)
+      else
+        Tag.new(name, values){ @childs.map{|c| c.to_html }.join }
+      end
+    end
+
+    def html_text
+      Org.escape_html(values.join)
+    end
+
+    # unify toc_id somwhere?
+    def html_header
+      level, text = values[0].size, values[1]
+      id = respond_to?(:toc_id) ? toc_id : text.gsub(/\W/, '-').squeeze('-').downcase
+      Tag.new("h#{level}", text, :id => id)
+    end
+
+    def html_space
+      ' '
+    end
+
+    # TODO: find a simple way of caching highlighted code from Uv,
+    #       gives us much more possibilities in highlighting compared
+    #       to coderay, but is also _really_ slow.
+    def html_highlight
+      language, code = *values
+      require 'coderay'
+      language = 'nitro_xhtml' if language == 'ezamar'
+
+      case language
+      when *%w[ruby c delphi html nitro_xhtml plaintext rhtml xml]
+        tokens = CodeRay.scan(code, language)
+        html = tokens.html(:wrap => :div)
+      when *%w[diff]
+        require 'uv'
+        Uv.parse(code, output = 'xhtml', syntax_name = language, line_numbers = false, render_style = 'amy', headers = false)
+      else
+        code = language if not code or code.strip.empty?
+        html = tag(:pre, code)
+      end
+    end
+
+    def tag(*args)
+      Tag.new(*args)
+    end
+  end
+
+  # Extracted from Ramaze Gestalt
+  class Tag
+    def initialize(name, value, args = {}, &block)
+      @name, @value, @args, @block = name, value, args, block
+    end
+
+    def to_s
+      @out = ''
+      build_tag(@name, @args, @value, &@block)
+      @out
+    end
+
+    def build_tag(name, attr = {}, text = [])
+      @out << "<#{name}"
+      @out << attr.map{|k,v| %[ #{k}="#{Org.escape_html(v)}"] }.join
+      if text != [] or block_given?
+        @out << ">"
+        @out << Org.escape_html([text].join)
+        if block_given?
+          text = yield
+          @out << text.to_str if text != @out and text.respond_to?(:to_str)
+        end
+        @out << "</#{name}>"
+      else
+        @out << ' />'
+      end
+    end
+  end
+end

data/lib/org/to/toc.rb

@@ -0,0 +1,51 @@
+module Org
+  class RootToken
+    def to_toc
+      found = @childs.map{|child| child.to_toc }.flatten.compact
+
+      out = []
+      nest = 0
+
+      while token = found.shift
+        level, text = *token.values
+        level = level.size
+
+        if level > nest
+          out << '<ol>'
+        elsif level < nest
+          out << '</ol>'
+        end
+        nest = level
+
+        out << "<li>#{token.toc_link}</li>"
+      end
+
+      nest.times do
+        out << '</ol>'
+      end
+
+      out
+    end
+  end
+
+  module ToToc
+    TOC_ENTRIES = [:header]
+
+    def to_toc
+      case @name
+      when *TOC_ENTRIES
+        self
+      else
+        @childs.map{|child| child.to_toc }
+      end
+    end
+
+    def toc_link
+      tag(:a, values[1], :href => "##{toc_id}")
+    end
+
+    def toc_id
+      values[1].gsub(/\W/, '-').squeeze('-').downcase
+    end
+  end
+end

data/lib/org/token.rb

@@ -0,0 +1,20 @@
+module Org
+  class Token
+    attr_accessor :name, :values, :options, :block, :childs, :parent
+
+    def initialize(name, values, options = {}, &block)
+      @name, @values, @options, @block = name, values, options, block
+      @childs = []
+    end
+
+    def <<(token)
+      token.parent = self
+      @childs << token
+    end
+
+    def pretty_inspect
+      {[name, values] => childs}.pretty_inspect
+    end
+    alias inspect pretty_inspect
+  end
+end

data/lib/org/version.rb

@@ -0,0 +1,3 @@
+module Org
+  VERSION = "2009.03.28"
+end

data/org.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{org}
+  s.version = "2009.03.28"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael 'manveru' Fellinger"]
+  s.date = %q{2009-03-28}
+  s.description = %q{transformation of a subset of org-mode markup to html.}
+  s.email = %q{m.fellinger@gmail.com}
+  s.files = ["CHANGELOG", "MANIFEST", "README.md", "Rakefile", "doc/syntax.org", "lib/org.rb", "lib/org/markup.rb", "lib/org/rule.rb", "lib/org/rules.rb", "lib/org/scope.rb", "lib/org/scope/org_mode.rb", "lib/org/state.rb", "lib/org/stringscanner.rb", "lib/org/to/html.rb", "lib/org/to/toc.rb", "lib/org/token.rb", "lib/org/version.rb", "org.gemspec", "spec/org.rb", "tasks/bacon.rake", "tasks/changelog.rake", "tasks/gem.rake", "tasks/gem_installer.rake", "tasks/grancher.rake", "tasks/install_dependencies.rake", "tasks/manifest.rake", "tasks/rcov.rake", "tasks/release.rake", "tasks/reversion.rake"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/manveru/org}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{transformation of a subset of org-mode markup to html.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/org.rb

@@ -0,0 +1,92 @@
+require 'lib/org'
+require 'org/scope/org_mode'
+require 'org/to/html'
+
+module Org
+  class Token
+    include ToHtml
+    include ToToc
+
+    def html_a(*args)
+      link, desc = *values
+      href = link =~ /^https?:\/\// ? link : "/#{link}"
+      tag(:a, (desc || link), :href => href)
+    end
+  end
+end
+
+require 'bacon'
+require 'hpricot'
+
+Bacon.extend(Bacon::TestUnitOutput)
+Bacon.summary_on_exit
+
+describe Org::Markup do
+  def t(string) # short for transform
+    Org::OrgMode.apply(string).to_html
+  end
+
+  should 'markup headers' do
+    t("* header"     ).should == '<h1 id="header">header</h1>'
+    t("** header"    ).should == '<h2 id="header">header</h2>'
+    t("*** header"   ).should == '<h3 id="header">header</h3>'
+    t("**** header"  ).should == '<h4 id="header">header</h4>'
+    t("***** header" ).should == '<h5 id="header">header</h5>'
+    t("****** header").should == '<h6 id="header">header</h6>'
+  end
+
+  should 'markup inline' do
+    t('*foo*').should == '<p><b>foo</b></p>'
+    t('/foo/').should == '<p><i>foo</i></p>'
+    t('_foo_').should == '<p><u>foo</u></p>'
+    t('+foo+').should == '<p><s>foo</s></p>'
+    t('~foo~').should == '<p><blockquote>foo</blockquote></p>'
+    t('=foo=').should == '<p><code>foo</code></p>'
+  end
+
+  should 'markup table' do
+    table = Hpricot(t("|name|address|\n|manveru|home|\n|gojira|tokyo|\n")).at(:table)
+    (table/:tr).map{|tr| (tr/:td).map{|td| td.inner_text } }.
+      should == [%w[name address], %w[manveru home], %w[gojira tokyo]]
+  end
+
+  should 'markup link' do
+    t('[[home]]').should == '<p><a href="/home">home</a></p>'
+    t('[[home][Home]]').should == '<p><a href="/home">Home</a></p>'
+    t('[[http://go.to/]]').should == '<p><a href="http://go.to/">http://go.to/</a></p>'
+    t('[[http://go.to/][Go to]]').should == '<p><a href="http://go.to/">Go to</a></p>'
+  end
+
+  should 'work with \r, \n, and \n\r' do
+    t("a\nb").should == '<p>a<br />b</p>'
+    t("a\r\nb").should == t("a\nb")
+    t("a\rb").should == t("a\nb")
+  end
+
+  should 'markup unorderd lists' do
+    t(" * one").should == '<ul><li>one</li></ul>'
+    t(" * one\n * two").should == '<ul><li>one</li><li>two</li></ul>'
+    t(" * one
+ * two
+ * three").should == '<ul><li>one</li><li>two</li><li>three</li></ul>'
+    t(" + one").should == '<ul><li>one</li></ul>'
+    t(" - one").should == '<ul><li>one</li></ul>'
+  end
+
+  should 'markup ordered lists' do
+    t(" 1. one").should == '<ol><li>one</li></ol>'
+    t(" 1) one").should == '<ol><li>one</li></ol>'
+    t(" 1. one\n 2. two").should == '<ol><li>one</li><li>two</li></ol>'
+  end
+
+  should 'markup nested lists' do
+    t(" * one\n + nest1\n + nest2\n * two\n").should ==
+      '<ul><li>one</li><ul><li>nest1</li><li>nest2</li></ul></ul>'
+    t(" 1. one\n + nest1\n + nest2\n 2. two\n").should ==
+      '<ol><li>one</li><ul><li>nest1</li><li>nest2</li></ul></ol>'
+  end
+
+  should 'markup inline in lists' do
+    t(' * first _foo_ /bar/').should == '<ul><li>first <u>foo</u> <i>bar</i></li></ul>'
+  end
+end

data/tasks/bacon.rake

@@ -0,0 +1,49 @@
+desc 'Run all bacon specs with pretty output'
+task :bacon => :install_dependencies do
+  require 'open3'
+  require 'scanf'
+
+  specs = PROJECT_SPECS
+
+  some_failed = false
+  total = specs.size
+  len = specs.map{|s| s.size }.sort.last
+  tt = ta = tf = te = 0
+
+  red, yellow, green = "\e[31m%s\e[0m", "\e[33m%s\e[0m", "\e[32m%s\e[0m"
+  left_format = "%4d/%d: %-#{len + 11}s"
+  spec_format = "%d specifications (%d requirements), %d failures, %d errors"
+
+  specs.each_with_index do |spec, idx|
+    print(left_format % [idx + 1, total, spec])
+
+    Open3.popen3(RUBY, spec) do |sin, sout, serr|
+      out = sout.read
+      err = serr.read
+
+      ran = false
+
+      out.each_line do |line|
+        tests, assertions, failures, errors = all = line.scanf(spec_format)
+        next unless all.any?
+        ran = true
+        tt += tests; ta += assertions; tf += failures; te += errors
+
+        if tests == 0 || failures + errors > 0
+          puts((red % spec_format) % all)
+          puts out
+          puts err
+        else
+          puts((green % "%6d passed") % tests)
+        end
+
+        break
+      end
+
+      puts(yellow % "       skipped") unless ran
+    end
+  end
+
+  puts(spec_format % [tt, ta, tf, te])
+  exit 1 if some_failed
+end

data/tasks/changelog.rake

@@ -0,0 +1,18 @@
+desc 'update changelog'
+task :changelog do
+  File.open('CHANGELOG', 'w+') do |changelog|
+    `git log -z --abbrev-commit`.split("\0").each do |commit|
+      next if commit =~ /^Merge: \d*/
+      ref, author, time, _, title, _, message = commit.split("\n", 7)
+      ref    = ref[/commit ([0-9a-f]+)/, 1]
+      author = author[/Author: (.*)/, 1].strip
+      time   = Time.parse(time[/Date: (.*)/, 1]).utc
+      title.strip!
+
+      changelog.puts "[#{ref} | #{time}] #{author}"
+      changelog.puts '', "  * #{title}"
+      changelog.puts '', message.rstrip if message
+      changelog.puts
+    end
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,22 @@
+require 'rake/gempackagetask'
+
+task :gemspec => [:manifest, :changelog] do
+  gemspec_file = "#{GEMSPEC.name}.gemspec"
+  File.open(gemspec_file, 'w+'){|gs| gs.puts(GEMSPEC.to_ruby) }
+end
+
+desc "package and install from gemspec"
+task :install => [:gemspec] do
+  sh "gem build #{GEMSPEC.name}.gemspec"
+  sh "gem install #{GEMSPEC.name}-#{GEMSPEC.version}.gem"
+end
+
+desc "uninstall the gem"
+task :uninstall => [:clean] do
+  sh %{gem uninstall -x #{GEMSPEC.name}}
+end
+
+Rake::GemPackageTask.new(GEMSPEC) do |p|
+  p.need_tar = true
+  p.need_zip = true
+end

data/tasks/gem_installer.rake

@@ -0,0 +1,76 @@
+task :gem_installer do
+  class GemInstaller
+    def initialize(options = {}, &block)
+      @gems = []
+      @options = options
+
+      run(&block)
+    end
+
+    def run(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    def gem(name, version = nil, options = {})
+      if version.respond_to?(:merge!)
+        options = version
+      else
+        options[:version] = version
+      end
+
+      @gems << [name, options]
+    end
+
+    def setup_gemspec(gemspec)
+      gemspec.dependencies.each do |dependency|
+        dependency.version_requirements.as_list.each do |version|
+          gem(dependency.name, version)
+        end
+      end
+
+      setup
+    end
+
+    def setup
+      require 'rubygems'
+      require 'rubygems/dependency_installer'
+
+      @gems.each do |name, options|
+        setup_gem(name, options)
+      end
+    end
+
+    def setup_gem(name, options, try_install = true)
+      print "activating #{name} ... "
+      Gem.activate(name, *[options[:version]].compact)
+      require(options[:lib] || name)
+      puts "success."
+    rescue LoadError => error
+      puts error
+      install_gem(name, options) if try_install
+      setup_gem(name, options, try_install = false)
+    end
+
+    def install_gem(name, options)
+      installer = Gem::DependencyInstaller.new(options)
+
+      temp_argv(options[:extconf]) do
+        print "Installing #{name} ... "
+        installer.install(name, options[:version])
+        puts "done."
+      end
+    end
+
+    def temp_argv(extconf)
+      if extconf ||= @options[:extconf]
+        old_argv = ARGV.clone
+        ARGV.replace(extconf.split(' '))
+      end
+
+      yield
+
+    ensure
+      ARGV.replace(old_argv) if extconf
+    end
+  end
+end

data/tasks/grancher.rake

@@ -0,0 +1,12 @@
+begin
+  require 'grancher/task'
+
+  Grancher::Task.new do |g|
+    g.branch = 'gh-pages'
+    g.push_to = 'origin'
+    g.message = 'Updated website'
+    g.directory 'ydoc', 'doc'
+  end
+rescue LoadError
+  # oh well :)
+end

data/tasks/install_dependencies.rake

@@ -0,0 +1,6 @@
+desc 'install dependencies'
+task :install_dependencies => [:gem_installer] do
+  GemInstaller.new do
+    setup_gemspec(GEMSPEC)
+  end
+end

data/tasks/manifest.rake

@@ -0,0 +1,4 @@
+desc 'update manifest'
+task :manifest do
+  File.open('MANIFEST', 'w+'){|io| io.puts(*GEMSPEC.files) }
+end

data/tasks/rcov.rake

@@ -0,0 +1,19 @@
+desc 'code coverage'
+task :rcov => :clean do
+  specs = Dir['spec/innate/**/*.rb']
+  specs -= Dir['spec/innate/cache/common.rb']
+
+  # we ignore adapter as this has extensive specs in rack already.
+  ignore = %w[ gem rack bacon innate/adapter\.rb ]
+  ignore << 'fiber\.rb' if RUBY_VERSION < '1.9'
+
+  ignored = ignore.join(',')
+
+  cmd = "rcov --aggregate coverage.data --sort coverage -t --%s -x '#{ignored}' %s"
+
+  while spec = specs.shift
+    puts '', "Gather coverage for #{spec} ..."
+    html = specs.empty? ? 'html' : 'no-html'
+    sh(cmd % [html, spec])
+  end
+end

data/tasks/release.rake

@@ -0,0 +1,12 @@
+desc 'publish to github'
+task :release => [:reversion, :gemspec] do
+  name, version = GEMSPEC.name, GEMSPEC.version
+
+  sh("git add MANIFEST CHANGELOG #{name}.gemspec lib/#{name}/version.rb")
+
+  puts "I added the relevant files, you can now run:", ''
+  puts "git commit -m 'Version #{version}'"
+  puts "git tag -a -m '#{version}' '#{version}'"
+  puts "git push"
+  puts
+end

data/tasks/reversion.rake

@@ -0,0 +1,8 @@
+desc "update version.rb"
+task :reversion do
+  File.open("lib/#{GEMSPEC.name}/version.rb", 'w+') do |file|
+    file.puts("module #{PROJECT_MODULE}")
+    file.puts('  VERSION = %p' % GEMSPEC.version.to_s)
+    file.puts('end')
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: org
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 2009
+  - 3
+  - 28
+  version: 2009.03.28
+platform: ruby
+authors: 
+- Michael 'manveru' Fellinger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-28 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: transformation of a subset of org-mode markup to html.
+email: m.fellinger@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- MANIFEST
+- README.md
+- Rakefile
+- doc/syntax.org
+- lib/org.rb
+- lib/org/markup.rb
+- lib/org/rule.rb
+- lib/org/rules.rb
+- lib/org/scope.rb
+- lib/org/scope/org_mode.rb
+- lib/org/state.rb
+- lib/org/stringscanner.rb
+- lib/org/to/html.rb
+- lib/org/to/toc.rb
+- lib/org/token.rb
+- lib/org/version.rb
+- org.gemspec
+- spec/org.rb
+- tasks/bacon.rake
+- tasks/changelog.rake
+- tasks/gem.rake
+- tasks/gem_installer.rake
+- tasks/grancher.rake
+- tasks/install_dependencies.rake
+- tasks/manifest.rake
+- tasks/rcov.rake
+- tasks/release.rake
+- tasks/reversion.rake
+has_rdoc: true
+homepage: http://github.com/manveru/org
+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: 2
+summary: transformation of a subset of org-mode markup to html.
+test_files: []
+