asuka 0.5.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jonathan Palardy
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= asuka
+
+Safe and pleasant text to HTML converer.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Jonathan Palardy. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "asuka"
+    gem.summary = %Q{Safe and pleasant text-to-HTML converter.}
+    gem.description = %Q{Markdown and textile -inspired markup that's XSS safe.}
+    gem.email = "jonathan@fetlife.com"
+    gem.homepage = "http://fetlife.com"
+    gem.authors = ["Jonathan Palardy"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "asuka #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.3

data/bin/asuka

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'asuka'
+
+puts Asuka.new(ARGF.read).to_html
+

data/lib/asuka.rb

@@ -0,0 +1,16 @@
+
+require 'asuka/accumulator'
+require 'asuka/document'
+
+require 'asuka/formatter'
+require 'asuka/line_formatter'
+require 'asuka/rules'
+
+require 'asuka/parser'
+
+module Asuka
+  def self.new(*args, &block)
+    Asuka::Document.new(*args, &block)
+  end
+end
+

data/lib/asuka/accumulator.rb

@@ -0,0 +1,27 @@
+module Asuka
+  class Accumulator
+    def initialize
+      @lines = []
+    end
+
+    def push(line)
+      lines << line
+    end
+
+    def empty?
+      lines.empty?
+    end
+
+    def flush
+      return [] if empty?
+
+      yield @lines if block_given?
+
+      result, @lines = lines, []
+      result
+    end
+
+    private
+      attr_accessor :lines
+  end
+end

data/lib/asuka/document.rb

@@ -0,0 +1,122 @@
+module Asuka
+  module HTMLable
+    def to_html
+      raise NotImplementedError, "%s does not implement the #to_html method" % [self.class.name]
+    end
+
+    def wrap(tag, content, indent=false)
+      ["<#{tag}>", content, "</#{tag}>"].join(indent ? "\n" : "")
+    end
+
+    def wrap_indent(tag, content)
+      wrap(tag, content, true)
+    end
+
+    def ==(other)
+      to_html == other.to_html
+    end
+  end
+
+  class LineGroup
+    include HTMLable
+
+    def initialize(lines)
+      @lines = lines
+    end
+
+    private
+      attr_accessor :lines
+  end
+
+  class Document < LineGroup
+    def initialize(lines, parser=Parser.new)
+      super(lines)
+      @parser = parser
+    end
+
+    def to_html
+      children.map { |child| child.to_html }.join("\n")
+    end
+
+    private
+      attr_accessor :parser
+
+      def children
+        @children ||= parse
+      end
+
+      def parse
+        parser.parse(lines)
+      end
+  end
+
+  class Block < LineGroup
+    def initialize(lines, tag)
+      super(lines)
+      @tag = tag
+    end
+
+    def to_html
+      wrap tag, lines.join("<br/>\n")
+    end
+
+    private
+      attr_accessor :tag
+  end
+
+  class Paragraph < Block
+    def initialize(lines)
+      super(lines, "p")
+    end
+  end
+
+  class Blockquote < Block
+    def initialize(lines)
+      super(lines, "blockquote")
+    end
+  end
+
+  class List < LineGroup
+    def initialize(lines, tag)
+      super(lines)
+      @tag = tag
+    end
+
+    def to_html
+      wrap_indent tag, lines.map { |line| ["<li>", line, "</li>"].join }.join("\n")
+    end
+
+    private
+      attr_accessor :tag
+  end
+
+  class UnorderedList < List
+    def initialize(lines)
+      super(lines, "ul")
+    end
+  end
+
+  class Rule
+    include HTMLable
+
+    def to_html
+      "<hr/>"
+    end
+  end
+
+  class Header
+    include HTMLable
+
+    def initialize(line, level)
+      @line  = line
+      @tag = "h#{level}"
+    end
+
+    def to_html
+      wrap tag, line
+    end
+
+    private
+      attr_accessor :line, :tag
+  end
+end

data/lib/asuka/formatter.rb

@@ -0,0 +1,53 @@
+require 'cgi'
+
+module Asuka
+  class Formatter
+    def default_steps
+      [:bold, :italic, :named_link]
+    end
+
+    def bold(line)
+      line.gsub(/\*\*([^*]+)\*\*/, '<strong>\1</strong>')
+    end
+
+    def italic(line)
+      line.gsub(/\*([^*]+)\*/,     '<em>\1</em>')
+    end
+
+    # helper
+    def make_link(text, href, tags={})
+      tags          = tags.merge(:href => href.strip)
+      tags_to_attrs = tags.sort_by { |name, value| name.to_s }.
+                           map     { |name, value| %Q{ #{name}="#{value}"} }
+
+      "<a#{tags_to_attrs}>#{text.strip}</a>"
+    end
+
+    def named_link(line)
+      # up to ] (spaces allowed)
+      up_to                 = /[^\]]+?/
+      brackets_without_http = /\[(#{up_to})\]/
+
+      # up to ] (spaces NOT allowed)
+      up_to                 = /[^\]\s]+/
+      brackets_with_http    = /\[\s*(https?:\/\/#{up_to})\s*\]/
+
+      line.gsub(/#{brackets_without_http}#{brackets_with_http}/) { |match| make_link($1, $2) }.
+           gsub(/#{brackets_with_http}#{brackets_without_http}/) { |match| make_link($2, $1) }
+    end
+  end
+
+  class PreFormatter
+    def default_steps
+      [:strip, :html_escape]
+    end
+
+    def strip(line)
+      line.strip
+    end
+
+    def html_escape(line)
+      CGI::escapeHTML(line)
+    end
+  end
+end

data/lib/asuka/line_formatter.rb

@@ -0,0 +1,24 @@
+module Asuka
+  class LineFormatter
+    attr_accessor :steps, :formatter
+
+    def initialize(formatter, *steps)
+      steps = steps.flatten
+
+      if steps.empty? && formatter.respond_to?(:default_steps)
+        @steps = formatter.default_steps
+      else
+        @steps = steps
+      end
+
+      @formatter = formatter
+    end
+
+    def format(line)
+      steps.inject(line) { |line, step| formatter.send(step, line) }
+    end
+  end
+
+  DEFAULT_LINE_FORMATTER     = LineFormatter.new(Formatter.new)
+  DEFAULT_PRE_LINE_FORMATTER = LineFormatter.new(PreFormatter.new)
+end

data/lib/asuka/parser.rb

@@ -0,0 +1,42 @@
+require "stringio"
+
+module Asuka
+  class Parser
+    attr_accessor :line_formatter, :pre_line_formatter
+
+    def rules
+      [Rules::Initial, Rules::UnorderedList, Rules::Blockquote, Rules::Rule, Rules::Header, Rules::Paragraph]
+    end
+
+    def initialize(line_formatter=DEFAULT_LINE_FORMATTER, pre_line_formatter=DEFAULT_PRE_LINE_FORMATTER)
+      @line_formatter     = line_formatter
+      @pre_line_formatter = pre_line_formatter
+    end
+
+    def parse(content)
+      lines = content.respond_to?(:join) ? content : StringIO.new(content).readlines
+      parse_lines(lines)
+    end
+
+    def parse_lines(lines)
+      result = []
+      acc = Accumulator.new
+
+      set = Rules::Set.new(rules.map { |rule| rule.new(acc, result, line_formatter) })
+
+      pstate = set.rules.first
+      lines.each do |line|
+        line   = pre_line_formatter.format(line)
+
+        cstate = set.rule_for(line)
+        pstate.transition if cstate != pstate
+        cstate.process(line)
+
+        pstate = cstate
+      end
+      pstate.transition # flush last state
+
+      result
+    end
+  end
+end

data/lib/asuka/rules.rb

@@ -0,0 +1,106 @@
+module Asuka
+  module Rules
+    class Set
+      attr_accessor :rules
+      def initialize(rules=[])
+        @rules = rules
+      end
+
+      def rule_for(line)
+        rules.detect { |r| r.match?(line) }
+      end
+    end
+
+    class Abstract
+      attr_reader :acc, :result, :line_formatter
+
+      def initialize(acc, result, line_formatter)
+        @acc            = acc
+        @result         = result
+        @line_formatter = line_formatter
+      end
+
+      def match?(line)
+        raise NotImplementedError, "%s does not implement the #match? method" % [self.class.name]
+      end
+
+      def transition
+        # no-op
+      end
+
+      def process(line)
+        # no-op
+      end
+    end
+
+    class Initial < Abstract
+      def match?(line)
+        line == ""
+      end
+    end
+
+    class Paragraph < Abstract
+      # override
+      def match?(line)
+        true # paragraph match everything!
+      end
+
+      def transition
+        result << Asuka::Paragraph.new(acc.flush)
+      end
+
+      def process(line)
+        acc.push(line_formatter.format(line))
+      end
+    end
+
+    class Blockquote < Abstract
+      def match?(line)
+        line =~ /^&gt; /
+      end
+
+      def transition
+        result << Asuka::Blockquote.new(acc.flush)
+      end
+
+      def process(line)
+        acc.push(line_formatter.format(line[5..-1]))
+      end
+    end
+
+    class UnorderedList < Abstract
+      def match?(line)
+        line =~ /^\* /
+      end
+
+      def transition
+        result << Asuka::UnorderedList.new(acc.flush)
+      end
+
+      def process(line)
+        acc.push(line_formatter.format(line[2..-1]))
+      end
+    end
+
+    class Rule < Abstract
+      def match?(line)
+        line =~ /^(-{3,}|_{3,})$/
+      end
+
+      def process(line)
+        result << Asuka::Rule.new
+      end
+    end
+
+    class Header < Abstract
+      def match?(line)
+        line =~ /^\#{1,6} /
+      end
+
+      def process(line)
+        level = line[/^\#{1,6}/].size
+        result << Asuka::Header.new(line_formatter.format(line[level+1..-1]), level)
+      end
+    end
+  end
+end