parity-RedCloth 4.2.9

data/spec/formatters/class_filtered_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "class_filtered_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:filter_classes]).to_html
+  end
+end

data/spec/formatters/filtered_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "filtered_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:filter_html]).to_html
+  end
+end

data/spec/formatters/html_no_breaks_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "html_no_breaks" do
+  examples_from_yaml do |doc|
+    red = RedCloth.new(doc['in'])
+    red.hard_breaks = false
+    red.to_html
+  end
+end

data/spec/formatters/html_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "HTML" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in']).to_html
+  end
+  
+  it "should not raise an error when orphaned parentheses in a link are followed by punctuation and words in HTML" do
+    lambda {
+      RedCloth.new(%Q{Test "(read this":http://test.host), ok}).to_html
+    }.should_not raise_error
+  end
+end

data/spec/formatters/id_filtered_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "id_filtered_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:filter_ids]).to_html
+  end
+end

data/spec/formatters/latex_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "LaTeX" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in']).to_latex
+  end
+  
+  it "should not raise an error when orphaned parentheses in a link are followed by punctuation and words in LaTeX" do
+    lambda { 
+      RedCloth.new(%Q{Test "(read this":http://test.host), ok}).to_latex
+    }.should_not raise_error
+  end
+end

data/spec/formatters/lite_mode_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "lite_mode_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:lite_mode]).to_html
+  end
+end

data/spec/formatters/no_span_caps_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "no_span_caps_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:no_span_caps]).to_html
+  end
+end

data/spec/formatters/sanitized_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "sanitized_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:sanitize_html]).to_html
+  end
+end

data/spec/formatters/style_filtered_html_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "style_filtered_html" do
+  examples_from_yaml do |doc|
+    RedCloth.new(doc['in'], [:filter_styles]).to_html
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RedCloth do
+  
+  describe "#new" do
+    it "should accept options" do
+      lambda {
+        RedCloth.new("test", [:hard_breaks])
+      }.should_not raise_error(ArgumentError)
+    end
+  end
+  
+  it "should have a VERSION" do
+    RedCloth.const_defined?("VERSION").should be_true
+    RedCloth::VERSION.const_defined?("STRING").should be_true
+  end
+  
+  it "should show the version as a string" do
+    RedCloth::VERSION::STRING.should == RedCloth::VERSION.to_s
+    RedCloth::VERSION.should == RedCloth::VERSION::STRING
+  end
+  
+  it "should have EXTENSION_LANGUAGE" do
+    RedCloth.const_defined?("EXTENSION_LANGUAGE").should be_true
+    RedCloth::EXTENSION_LANGUAGE.should_not be_empty
+    RedCloth::DESCRIPTION.should include(RedCloth::EXTENSION_LANGUAGE)
+  end
+  
+  it "should not segfault on a badly formatted table" do
+    RedCloth.new(%Q{| one | two |\nthree | four |}).to_html.should =~ /td/
+  end
+  
+  it "should not segfault on a table without a block end" do
+    RedCloth.new("| a | b |\n| c | d |\nh3. foo").to_html.should =~ /h3/
+  end
+  
+  it "should not segfault on a table with empty cells" do
+    RedCloth.new(%Q{|one || |\nthree | four |}).to_html.should =~ /td/
+  end
+  
+  it "should not segfault on an unfinished html block with filter_html" do
+    lambda { RedCloth.new(%Q{<hr> Some text}, [:filter_html]).to_html }.should_not raise_error
+  end
+  
+  it "should parse RedCloth::VERSION in input" do
+    RedCloth.new("RedCloth::VERSION").to_html.should == "<p>#{RedCloth::VERSION::STRING}</p>"
+  end
+  
+  it "should not parse RedCloth::VERSION if it's not on a line by itself" do
+    input = "RedCloth::VERSION won't output the RedCloth::VERSION unless it's on a line all by itself.\n\nRedCloth::VERSION"
+    html = "<p>RedCloth::<span class=\"caps\">VERSION</span> won&#8217;t output the RedCloth::<span class=\"caps\">VERSION</span> unless it&#8217;s on a line all by itself.</p>\n<p>#{RedCloth::VERSION::STRING}</p>"
+    RedCloth.new(input).to_html.should == html
+  end
+  
+  it "should output the RedCloth::VERSION if it's labeled on a line by itself" do
+    input = "RedCloth::VERSION: RedCloth::VERSION"
+    html = "<p>RedCloth::VERSION: #{RedCloth::VERSION::STRING}</p>"
+    RedCloth.new(input).to_html.should == html
+  end
+  
+  it "should output the RedCloth::VERSION if it's labeled in a sentence on a line by itself" do
+    input = "RedCloth version RedCloth::VERSION"
+    html = "<p>RedCloth version #{RedCloth::VERSION::STRING}</p>"
+    RedCloth.new(input).to_html.should == html
+  end
+  
+  it "should output the RedCloth::VERSION in brackets" do
+    input = "The current RedCloth version is [RedCloth::VERSION]"
+    html = "<p>The current RedCloth version is #{RedCloth::VERSION::STRING}</p>"
+    RedCloth.new(input).to_html.should == html
+  end
+  
+  it "should strip carriage returns" do
+    input = "This is a paragraph\r\n\r\nThis is a\r\nline break.\r\n\r\n<div>\r\ntest\r\n\r\n</div>"
+    html = "<p>This is a paragraph</p>\n<p>This is a<br />\nline break.</p>\n<div>\n<p>test</p>\n</div>"
+    RedCloth.new(input).to_html.should == html
+  end
+
+  it "should not add spurious li tags to the end of markup" do
+    input         = "* one\n* two\n* three \n\n"
+    failing_input = "* one\n* two\n* three \n\n\n"
+    RedCloth.new(input).to_html.should_not match(/<li>$/)
+    RedCloth.new(failing_input).to_html.should_not match(/<li>$/)
+  end
+  
+  if RUBY_VERSION > "1.9.0"
+    it "should preserve character encoding" do
+      input = "This is an ISO-8859-1 string"
+      input.force_encoding 'iso-8859-1'
+      output = RedCloth.new(input).to_html
+      
+      output.should == "<p>This is an <span class=\"caps\">ISO</span>-8859-1 string</p>"
+      output.encoding.to_s.should == "ISO-8859-1"
+    end
+    
+    it "should not raise ArgumentError: invalid byte sequence" do
+      s = "\xa3"
+      s.force_encoding 'iso-8859-1'
+      lambda { RedCloth.new(s).to_html }.should_not raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'redcloth'
+require 'yaml'
+  
+def examples_from_yaml(&block)
+  formatter = description.downcase
+  define_method("format_as_#{formatter}", &block)
+  
+  fixtures.each do |name, doc|
+    if doc[formatter]
+      example("should output #{formatter} for #{name}") do
+        output = method("format_as_#{formatter}").call(doc)
+        output.should == doc[formatter]
+      end
+    else
+      example("should not raise errors when rendering #{formatter} for #{name}") do
+        lambda { method("format_as_#{formatter}").call(doc) }.should_not raise_error
+      end
+    end
+  end
+end
+
+def fixtures
+  return @fixtures if @fixtures
+  @fixtures = {}
+  Dir[File.join(File.dirname(__FILE__), *%w[fixtures *.yml])].each do |testfile|
+    testgroup = File.basename(testfile, '.yml')
+    num = 0
+    YAML::load_documents(File.open(testfile)) do |doc|
+      name = doc['name'] || num
+      @fixtures["#{testgroup} #{name}"] = doc
+      num += 1
+    end
+  end
+  @fixtures
+end

data/tasks/compile.rake

@@ -0,0 +1,47 @@
+CLEAN.include [
+  'tmp',
+  '**/*.{o,obj,class,pdb,lib,def,exp,log,rbc}',
+  'ext/redcloth_scan/**/redcloth_*.rb',
+  'ext/redcloth_scan/Makefile',  'ext/redcloth_scan/extconf.rb',
+]
+CLOBBER.include [
+  'pkg',
+  '**/*.{c,java}',
+  'lib/**/*.{bundle,so,o,obj,pdb,lib,def,exp,jar}',
+  'lib/redcloth_scan.rb',
+]
+
+# Load the Gem specification for the current platform (Ruby or JRuby).
+def gemspec(platform = RUBY_PLATFORM[/java/] || 'ruby')
+  Gem::Specification.load(File.expand_path('../../redcloth.gemspec', __FILE__))
+end
+
+require 'rake/extensiontask'
+require 'rake/javaextensiontask'
+require File.dirname(__FILE__) + '/ragel_extension_task'
+
+if defined?(JRUBY_VERSION)
+  Rake::JavaRagelExtensionTask.new('redcloth_scan', gemspec)
+else
+  extconf = "ext/redcloth_scan/extconf.rb"
+  file extconf do
+    FileUtils.mkdir(File.dirname(extconf)) unless File.directory?(File.dirname(extconf))
+    File.open(extconf, "w") do |io|
+      io.write(<<-EOF)
+require 'mkmf'
+CONFIG['warnflags'].gsub!(/-Wshorten-64-to-32/, '') if CONFIG['warnflags']
+$CFLAGS << ' -O0 -Wall ' if CONFIG['CC'] =~ /gcc/
+dir_config("redcloth_scan")
+have_library("c", "main")
+create_makefile("redcloth_scan")
+      EOF
+    end
+  end
+
+  Rake::RagelExtensionTask.new("redcloth_scan", gemspec) do |ext|
+    if ENV['RUBY_CC_VERSION']
+      ext.cross_compile = true
+      ext.cross_platform = ['i386-mingw32', 'i386-mswin32-60']
+    end
+  end
+end

data/tasks/gems.rake

@@ -0,0 +1,37 @@
+Rake::Task['build'].prerequisites.unshift('compile')
+
+namespace :build do
+    desc "Generate Windows binary gems"
+    task :win do
+      unless File.directory?(File.expand_path('~/.rake-compiler'))
+        STDERR.puts <<-EOM
+
+  You must install Windows rubies to ~/.rake-compiler with:
+
+    rake-compiler cross-ruby VERSION=1.8.6-p398
+    # (Later 1.9.1 patch levels don't compile on mingw) 
+    rake-compiler cross-ruby VERSION=1.9.1-p243
+  EOM
+        exit(1)
+      end
+      # rvm and mingw ruby versions have to match to avoid errors
+      sh "rvm ruby-1.8.6-p398@redcloth rake cross compile RUBY_CC_VERSION=1.8.6"
+      sh "rvm ruby-1.9.1-p243@redcloth rake cross compile RUBY_CC_VERSION=1.9.1"
+      # This will copy the .so files to the proper place
+      sh "rake cross native gem RUBY_CC_VERSION=1.8.6:1.9.1"
+    end
+
+    desc 'Generate JRuby binary gem'
+    task :jruby do
+      sh "rvm jruby@redcloth rake java gem"
+    end
+
+    desc "Build ruby, windows, and jruby gems into the pkg directory"
+    task :all => [
+      :clobber,
+      "rvm:spec",
+      :jruby,
+      :win,
+      :build
+    ]
+end

data/tasks/ragel_extension_task.rb

@@ -0,0 +1,127 @@
+module Rake
+  module RagelGenerationTasks
+    RAGEL_INCLUDE_PATTERN = /include \w+ "([^"]+)";/
+    RAGEL_VERSION_COMMAND = "ragel -v"
+    
+    attr_accessor :rl_dir
+    attr_accessor :machines
+    
+    def init(name = nil, gem_spec = nil)
+      super
+      
+      @rl_dir = "ragel"
+      @machines = %w(scan inline attributes)
+    end
+    
+    def lang
+      raise NotImplementedError
+    end
+    
+    def source_files
+      @source_files ||= machines.map {|m| target(m) }
+    end
+    
+    def define
+      super
+      define_ragel_tasks
+    end
+    
+    def define_ragel_tasks
+      machines.each do |machine|
+        file target(machine) => [*ragel_sources(machine)] do
+          mkdir_p(File.dirname(target(machine))) unless File.directory?(File.dirname(target(machine)))
+          ensure_ragel_version
+          sh "ragel #{flags} #{lang_ragel(machine)} -o #{target(machine)}"
+        end
+        
+        file extconf => [target(machine)] if lang == 'c'
+      end
+    end
+
+    def target(machine)
+      {
+        'scan' => {
+          'c'    => "#{@ext_dir}/redcloth_scan.c",
+          'java' => "#{@ext_dir}/RedclothScanService.java",
+          'rb'   => "#{@ext_dir}/redcloth_scan.rb"
+        },
+        'inline' => {
+          'c'    => "#{@ext_dir}/redcloth_inline.c",
+          'java' => "#{@ext_dir}/RedclothInline.java",
+          'rb'   => "#{@ext_dir}/redcloth_inline.rb"
+        },
+        'attributes' => {
+          'c'    => "#{@ext_dir}/redcloth_attributes.c",
+          'java' => "#{@ext_dir}/RedclothAttributes.java",
+          'rb'   => "#{@ext_dir}/redcloth_attributes.rb"
+        }
+      }[machine][lang]
+    end
+
+    def lang_ragel(machine)
+      "#{@rl_dir}/redcloth_#{machine}.#{lang}.rl"
+    end
+
+    def ragel_sources(machine)
+      deps = [lang_ragel(machine), ragel_file_dependencies(lang_ragel(machine))].flatten.dup
+      deps += ["#{@ext_dir}/redcloth.h"] if lang == 'c'
+      deps
+      # FIXME: merge that header file into other places so it can be eliminated?
+    end
+    
+    def ragel_file_dependencies(ragel_file)
+      found = find_ragel_includes(ragel_file)
+      found + found.collect {|file| ragel_file_dependencies(file)}
+    end
+    
+    def find_ragel_includes(file)
+      File.open(file).grep(RAGEL_INCLUDE_PATTERN) { $1 }.map do |file|
+        "#{@rl_dir}/#{file}"
+      end
+    end
+
+    def flags
+      code_style_flag = preferred_code_style ? " -" + preferred_code_style : ""
+      "-#{host_language_flag}#{code_style_flag}"
+    end
+
+    def host_language_flag
+      {
+        'c'      => 'C',
+        'java'   => 'J',
+        'rb'     => 'R'
+      }[lang]
+    end
+
+    def preferred_code_style
+      {
+        'c'      => 'T0',
+        'java'   => nil,
+        'rb'     => 'F1'
+      }[lang]
+    end
+
+    def ensure_ragel_version
+      @ragel_v ||= `ragel -v`[/(version )(\S*)/,2].split('.').map{|s| s.to_i}
+      raise unless @ragel_v[0] > 6 || (@ragel_v[0] == 6 && @ragel_v[1] >= 3)
+    rescue
+      STDERR.puts "Ragel 6.3 or greater is required."
+      exit(1)
+    end
+    
+  end
+  class RagelExtensionTask < ExtensionTask
+    include RagelGenerationTasks
+
+    def lang
+      "c"
+    end
+  end  
+  class JavaRagelExtensionTask < JavaExtensionTask
+    include RagelGenerationTasks
+    
+    def lang
+      "java"
+    end
+  end
+end

data/tasks/release.rake

@@ -0,0 +1,15 @@
+namespace :release do
+  desc 'Upload all packages and tag git'
+  task :all => ['build:all', :release, :push_native_gems]
+
+  desc 'Push all gems to rubygems.org (gemcutter)'
+  task :push_native_gems do
+    Dir.chdir('pkg') do
+      Dir['*.gem'].select {|g| g =~ /\w+-[^-]+-\w+.gem/ }.each do |gem_file|
+        sh("gem push #{gem_file}")
+      end
+    end
+  end
+end
+
+Rake::Task['release'].prerequisites.unshift('build')

data/tasks/rspec.rake

@@ -0,0 +1,13 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/}
+end
+
+task :default  => :spec
+task :spec     => :compile
+
+RSpec::Core::RakeTask.new(:test) # for rubygems-test

data/tasks/rvm.rake

@@ -0,0 +1,79 @@
+namespace :rvm do
+  
+  RVM_RUBIES = ['jruby-1.5.6' , 'ruby-1.8.6-p398', 'ruby-1.9.1-p243', 'ruby-1.9.2-p136', 'ree-1.8.7-2010.02']
+  RVM_GEMSET_NAME = 'redcloth'
+  
+  task :setup do
+    unless @rvm_setup
+      rvm_lib_path = "#{`echo $rvm_path`.strip}/lib"
+      $LOAD_PATH.unshift(rvm_lib_path) unless $LOAD_PATH.include?(rvm_lib_path)
+      require 'rvm'
+      require 'tmpdir'
+      @rvm_setup = true
+    end
+  end
+  
+  desc "Runs specs under each rvm ruby"
+  task :spec => :setup do
+    puts rvm_rubies.join(',')
+    rvm_each_rubie do
+      # Make sure all dependencies are installed but ignore Gemfile.lock. It 
+      # gets confused when locked to java and running ruby and vice-versa.
+      STDERR << RVM.run('bundle update').stderr 
+            
+      result = RVM.perform_set_operation(:rake)
+      STDOUT << result.stdout
+      STDERR << result.stderr
+    end
+  end
+  
+  desc "Show rubies"
+  task :rubies => :setup do
+    puts rvm_rubies.join(",")
+  end
+  
+  namespace :install do
+    task :rubies => :setup do
+      installed_rubies = RVM.list_strings
+      RVM_RUBIES.each do |rubie|
+        if installed_rubies.include?(rubie)
+          puts "info: Rubie #{rubie} already installed."
+        else
+          good_msg = "info: Rubie #{rubie} installed."
+          bad_msg = "Failed #{rubie} install! Check RVM logs here: #{RVM.path}/log/#{rubie}"
+          puts "info: Rubie #{rubie} installation inprogress. This could take awhile..."
+          if RVM.install(rubie,{})
+            puts(good_msg)
+            RVM.use(rubie)
+            RVM.perform_set_operation(:gem, 'install', 'bundler')
+            RVM.reset_current!
+          else
+            abort(bad_msg)
+          end
+        end
+      end
+    end
+  end
+
+  task :remove => :setup do
+    rvm_rubies.each { |rubie| RVM.remove(rubie) }
+  end
+end
+
+
+# RVM Helper Methods
+
+def rvm_each_rubie
+  rvm_rubies.each do |rubie|
+    RVM.use(rubie)
+    puts "Using #{rubie}"
+    yield
+  end
+ensure
+  RVM.reset_current!
+end
+
+def rvm_rubies(options={})
+  RVM_RUBIES.map{ |rubie| "#{rubie}@#{RVM_GEMSET_NAME}" }
+end
+