breakout_parser 0.0.23 → 0.0.31

data/spec/obj_proxy.rb

@@ -0,0 +1,22 @@
+module Breakout
+  # A proxy class that will initialize it's internal object only when some other
+  # code will need something from it, and will call any method on a proxy object.
+  # On first call internal object will be initialized, and all further method
+  # calls (including a first one) will be proxied to it.
+  class ObjProxy
+    def initialize &block
+      @creator_block = block
+    end
+    def method_missing mname, *args
+      @obj = @creator_block.call unless @obj
+      @obj.send(mname,*args)
+    end
+    def inspect
+      @obj ? "ObjProxy: #{@obj.inspect}" : super
+    end
+    def to_str
+      @obj = @creator_block.call unless @obj
+      @obj.respond_to?(:to_str) ? @obj.to_str : ''
+    end
+  end
+end

data/spec/parser_examples_spec.rb

@@ -0,0 +1,115 @@
+require 'breakout_parser'
+
+describe 'BreakoutParser' do
+
+  describe "bad examples" do
+    Dir["examples/orig/*.bad"].sort.each do |fname|
+      it "should not die on #{fname} " do
+        data = File.read(fname)
+        parse_file(fname).size.should >= File.read(fname).strip.gsub(/\s+/,' ').size
+      end
+      it "should parse #{fname} differently from preparsed (or fix me)" do
+        preparsed = unify(preparsed_data(fname))
+        parsed    = unify(parse_file(fname))
+
+        parsed.should_not == preparsed
+      end
+    end
+  end
+  describe "pending examples" do
+    Dir["examples/orig/*.pending"].sort.each do |fname|
+      it "should parse #{fname} "
+      it "should not die on #{fname} " do
+        data = File.read(fname)
+        parse_file(fname).size.should >= File.read(fname).strip.gsub(/\s+/,' ').size
+      end
+      it "should parse #{fname} differently from preparsed (or fix me)" do
+        preparsed = unify(preparsed_data(fname))
+        parsed    = unify(parse_file(fname))
+
+        parsed.should_not == preparsed
+      end
+    end
+  end
+
+  describe "preparsed examples" do
+    Dir["examples/orig/*.txt"].sort.each do |fname|
+      it "should parse #{fname} " do
+        preparsed = unify(preparsed_data(fname))
+        parsed    = unify(parse_file(fname))
+
+        if parsed != preparsed
+#          File.open("last-parsed.tmp","w"){ |f| f << parsed }
+#          File.open("last-preparsed.tmp","w"){ |f| f << preparsed }
+          pos = 0
+          pos += 1 while parsed[0..pos] == preparsed[0..pos]
+          pos -= 5
+          pos = 0 if pos<0
+          parsed[pos..-1].should == preparsed[pos..-1]
+        end
+        parsed.should == preparsed
+      end
+    end
+  end
+
+  # unifies texts stripping unnecessary whitespaces
+  # b/c amounts of spaces can be different among parsers
+  def unify text
+    text.downcase.
+      gsub(/(\s*<br \/>\s*)+/,' ').
+      gsub(/\n\s*/,"\n").
+      gsub(/>[ \t]+/,">").
+      gsub(/[ \t]+</,"<").
+      gsub(/[\r\n \t]+/," ").
+      gsub("<a rel=\"nofollow\"","<a").
+      strip
+  end
+
+  def preparsed_data fname
+    bname = File.basename(fname,".*")
+    preparsed = File.read("examples/parsed/#{bname}.txt")
+    preparsed = preparsed[3..-1] if preparsed[0..2] == '<p>'
+    preparsed = preparsed[0..-5] if preparsed[-4..-1] == '</p>'
+    preparsed.gsub!("&#8211;","-")
+    preparsed.gsub!("&#8212;","--")
+    preparsed.gsub!("&#8216;","'")
+    preparsed.gsub!("&#8217;","'")
+    preparsed.gsub!("&#8230;","...")
+    preparsed.gsub!("&#215;","x")
+    preparsed.gsub!("&#169;","(c)")
+    preparsed.gsub!("<br />\n","<br />")
+    preparsed.gsub!(/[ \t]+<br \/>/,"<br />")
+    preparsed.gsub!("\t"," ")
+    if preparsed['<hr />']
+      # find longest dash-line in source
+      dashline = File.read(fname).scan(/-+/).sort_by{ |x| -x.length }.first
+      preparsed.gsub!("</p>\n<hr />\n<p>","<br /><br />#{dashline}<br /><br />");
+    end
+
+#        preparsed.gsub!(/^<p>/,"");
+#        preparsed.gsub!(/<\/p>$/,"");
+    preparsed.gsub!("</pre>\n<ol>","</pre><br /><br /><ol>")
+    preparsed.gsub!(/<\/p>\s+<p>/,"<br /><br />")
+    preparsed.gsub!("</p>\n","<br /><br />")
+    preparsed.gsub!("<p>","<br /><br />")
+    preparsed.gsub!(/[\r\n]+ */," ")
+    preparsed.gsub!(/[ \t]{2,}/," ")
+
+    preparsed.gsub!("<del>","-")
+    preparsed.gsub!("</del>","-")
+    preparsed.gsub!(/<br \/>[ ]+/,"<br />")
+    preparsed.gsub!(/(<br \/>){2,}/,"<br /><br />")
+#        preparsed.gsub!("<br /><ol>","<ol>")
+#        preparsed.gsub!("<br /><ul>","<ul>")
+#        preparsed.gsub!("<br /><br /><ul>","<br /><ul>")
+    preparsed
+  end
+
+###############################################################################
+###############################################################################
+###############################################################################
+
+  def parse_file(fname)
+    BreakoutParser.parse(File.read(fname), "test_space").strip
+  end
+end

data/spec/parser_spec.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require 'breakout_parser'
+require 'spec_helper'
 require File.dirname(__FILE__) + '/obj_proxy'
 
 describe 'BreakoutParser' do
@@ -18,24 +18,18 @@ describe 'BreakoutParser' do
 
   def get_data fname
     r = File.read(File.dirname(__FILE__) + '/data/' + fname)
-    if self.class.description[' numbered list multilevel']
-      r.gsub!('*','#')
-      r.gsub!('ul>','ol>')
-    end
-    r
   end
 
-  it 'accepts from 2 to 5 arguments' do
-    [0,1,6,7,8,9,10].each do |argc|
-      lambda{
-        BreakoutParser.parse(*(['a']*argc))
-      }.should raise_error(ArgumentError, "wrong number of arguments (#{argc} for 2..5)")
+  it 'accepts from 2 to 7 arguments' do
+    expect { BreakoutParser.parse }.to raise_error(ArgumentError, "wrong number of arguments (0 for 2..7)")
+    expect { BreakoutParser.parse('a') }.to raise_error(ArgumentError, "wrong number of arguments (1 for 2..7)")
+    [9, 10].each do |argc|
+      expect { BreakoutParser.parse(*(['a'] * (argc - 1) + [{}])) }.to raise_error(ArgumentError, "wrong number of arguments (#{argc} for 2..7)")
     end
-    (2..5).each do |argc|
-      lambda{
-        BreakoutParser.parse(*(['a']*argc))
-      }.should_not raise_error
+    (2..6).each do |argc|
+      expect { BreakoutParser.parse(*(['a'] * argc)) }.to_not raise_error(ArgumentError)
     end
+    expect { BreakoutParser.parse(*(['a'] * 6 + [{}])) }.to_not raise_error(ArgumentError)
   end
 
   it 'converts \n to <br />' do
@@ -309,7 +303,7 @@ describe 'BreakoutParser' do
 
 ###############################################################################
 
-  describe "unnumbered list" do
+  describe "unordered list" do
     it "should work" do
       parse("* a\n* b\n* c").should match(
         %r"<ul><li>a</li><li>b</li><li>c</li></ul>"
@@ -333,28 +327,55 @@ describe 'BreakoutParser' do
       parse("hello\n\n * a\n * b\n * c\nworld").should ==
         "hello<br /><br /><ul><li>a</li><li>b</li><li>c</li></ul>world"
     end
+    it "should respect bold text at the beggining of simple item" do
+      parse("* *this is a bold test* and this is not").should == "<ul><li> <strong>this is a bold test</strong> and this is not</li></ul>"
+    end
+    it "should respect italic text at the beggining of simple item" do
+      parse("* _this is a italic test_ and this is not").should == "<ul><li> <em>this is a italic test</em> and this is not</li></ul>"
+    end
+
+    describe "nested list" do
+      it "should respect bold text at the beginning of the second level item" do
+        parse("* item 1\n** *bold* working").should == "<ul><li>item 1<ul><li> <strong>bold</strong> working</li></ul></li></ul>"
+      end
 
-    describe "multilevel" do
-      it "at start" do
-        # NOTE: not sure that list1.html is correct enough, but it should render fine
+      it "should respect bold text at the beginning of the third level item" do
+        parse("* item 1\n** item 2\n*** *bold* working").should ==
+          "<ul><li>item 1<ul><li>item 2<ul><li> <strong>bold</strong> working</li></ul></li></ul></li></ul>"
+      end
+
+      it "should respect italic text at the beginning of the second level item" do
+        parse("* item 1\n** _italic_ working").should == "<ul><li>item 1<ul><li> <em>italic</em> working</li></ul></li></ul>"
+      end
+
+      it "should respect italic text at the beginning of the third level item" do
+        parse("* item 1\n** item 2\n*** _italic_ working").should ==
+          "<ul><li>item 1<ul><li>item 2<ul><li> <em>italic</em> working</li></ul></li></ul></li></ul>"
+      end
+
+      it "considers lists with level 2 or higher as level 1" do
         parse(get_data('list1')).should == unformat(get_data('list1.html'))
       end
 
-      it "in middle" do
+      it "parses normally common nested lists with 2 levels deep" do
         parse(get_data('list2')).should == unformat(get_data('list2.html'))
       end
 
-      it "three levels" do
+      it "parses normally common nested lists with 3 levels deep" do
         parse(get_data('list3')).should == unformat(get_data('list3.html'))
       end
 
-      it "mess - should have matching count of opening and closing tags" do
+      it "parses normally common nested lists with 3 levels deep [2]" do
+        parse(get_data('list7')).should == unformat(get_data('list7.html'))
+      end
+
+      it "doesn't parse correctly messed up nested list" do
         r = parse(get_data('list4'))
         r.scan('<ul>').count.should > 0
         r.scan('<ul>').count.should == r.scan('</ul>').count
       end
 
-      it "at end" do
+      it "parses normally common nested lists with 3 levels deep [3]" do
         parse(get_data('list5')).should == unformat(get_data('list5.html'))
       end
 
@@ -363,6 +384,13 @@ describe 'BreakoutParser' do
         r.scan('<ul>').count.should > 0
         r.scan('<ul>').count.should == r.scan('</ul>').count
       end
+
+      context "when ordered list is nested within the unordered list," do
+        it 'indents the ordered list inside the unordered list' do
+          parse("* item 1\n## item 1.1\n## item 1.2\n* item 2").should ==
+            "<ul><li>item 1<ol><li>item 1.1</li><li>item 1.2</li></ol></li><li>item 2</li></ul>"
+        end
+      end
     end
   end
 
@@ -392,10 +420,34 @@ describe 'BreakoutParser' do
       parse("hello\n\n # a\n # b\n # c\nworld").should ==
         "hello<br /><br /><ol><li>a</li><li>b</li><li>c</li></ol>world"
     end
+    it "should respect bold text at the beggining of simple item" do
+      parse("# *this is a bold test* and this is not").should == "<ol><li> <strong>this is a bold test</strong> and this is not</li></ol>"
+    end
+    it "should respect italic text at the beggining of simple item" do
+      parse("# _this is a italic test_ and this is not").should == "<ol><li> <em>this is a italic test</em> and this is not</li></ol>"
+    end
+
+    describe "numbered lists multilevel" do
+      it "should respect bold text at the beginning of the second level item" do
+        parse("# item 1\n## *bold* working").should == "<ol><li>item 1<ol><li> <strong>bold</strong> working</li></ol></li></ol>"
+      end
+
+      it "should respect bold text at the beginning of the third level item" do
+        parse("# item 1\n## item 2\n### *bold* working").should ==
+          "<ol><li>item 1<ol><li>item 2<ol><li> <strong>bold</strong> working</li></ol></li></ol></li></ol>"
+      end
+
+      it "should respect italic text at the beginning of the second level item" do
+        parse("# item 1\n## _italic_ working").should == "<ol><li>item 1<ol><li> <em>italic</em> working</li></ol></li></ol>"
+      end
 
-    describe "multilevel" do
-      it "at start" do
-        # NOTE: not sure that list1.html is correct enough, but it should render fine
+      it "should respect italic text at the beginning of the third level item" do
+        parse("# item 1\n## item 2\n### _italic_ working").should ==
+          "<ol><li>item 1<ol><li>item 2<ol><li> <em>italic</em> working</li></ol></li></ol></li></ol>"
+      end
+
+      it "converts starting level 2 list as starting level 1 list" do
+        File.open("./teste.txt", "a") { |fp| fp.puts("opa") }
         parse(get_data('list1')).should == unformat(get_data('list1.html'))
       end
 
@@ -409,8 +461,8 @@ describe 'BreakoutParser' do
 
       it "mess - should have matching count of opening and closing tags" do
         r = parse(unformat(get_data('list4')))
-        r.scan('<ol>').count.should > 0
-        r.scan('<ol>').count.should <= r.scan('</ol>').count
+        r.scan('<ul>').count.should > 0
+        r.scan('<ul>').count.should <= r.scan('</ul>').count
       end
 
       it "at end" do
@@ -419,6 +471,28 @@ describe 'BreakoutParser' do
     end
   end
 
+  describe "ordered list (with letters)" do
+    context "for one level deep lists," do
+      it "parses it correctly" do
+        expect(parse("% a\n% b\n% c")).to eq("<ol class='letters'><li>a</li><li>b</li><li>c</li></ol>")
+      end
+
+      it "parses it correctly when among a text" do
+        expect(parse("aaa\n% a\n% b\n% c\nbbb")).to include("<ol class='letters'><li>a</li><li>b</li><li>c</li></ol>")
+      end
+    end
+
+    context "when the list is a nested list," do
+      context "and it's mixed within other list types," do
+        it 'nests the lists correctly' do
+          parse("* a\n## a.1\n%%% a.1.1\n## a.2\n* b").should ==
+            "<ul><li>a<ol><li>a.1<ol class='letters'><li>a.1.1</li></ol></li><li>a.2</li></ol></li><li>b</li></ul>"
+        end
+      end
+    end
+
+  end
+
 ###############################################################################
 # headers
 
@@ -841,7 +915,7 @@ describe 'BreakoutParser' do
     a["url:http://www.ru"]   = '<a rel="nofollow" href="http://www.ru">http://www.ru</a>'
     a["url:https://www.ru"]  = '<a rel="nofollow" href="https://www.ru">https://www.ru</a>'
     a["url:www.ru"]          = '<a rel="nofollow" href="http://www.ru">http://www.ru</a>'
-    a["url:www.ru/?a=1&b=2"] = '<a rel="nofollow" href="http://www.ru/?a=1&b=2">http://www.ru/?a=1&amp;b=2</a>'
+    a["url:www.ru/?a=1&b=2"] = '<a rel="nofollow" href="http://www.ru/?a=1&amp;b=2">http://www.ru/?a=1&amp;b=2</a>'
     a["url:ftp://www.ru"]    = '<a rel="nofollow" href="ftp://www.ru">ftp://www.ru</a>'
     a["url:/spaces/x2"]      = '<a rel="nofollow" href="/spaces/x2">/spaces/x2</a>'
 
@@ -992,6 +1066,33 @@ describe 'BreakoutParser' do
       end
     end
 
+    describe 'large_files_url' do
+      let(:large_files_url) { "https://bigfiles.assembla.com" }
+
+      it 'should use the url' do
+        parse("[[file:MyFile.png]]", :large_files_url => large_files_url).should ==
+          "<a href=\"https://bigfiles.assembla.com/spaces/test_space/documents/download/MyFile.png\">file:MyFile.png</a>"
+      end
+
+      it 'should not use the url' do
+        parse("[[file:MyFile.png]]").should ==
+          "<a href=\"/spaces/test_space/documents/download/MyFile.png\">file:MyFile.png</a>"
+      end
+    end
+
+    describe 'data attributes' do
+      let(:meta_attrs) { {"15000" => {"space" => "breakout", "number" => "15000"}} }
+
+      subject { parse("Comment to ticket #15000", :meta_attributes => meta_attrs) }
+
+      # We cannot test the exact match because Hash returns its elements in random order
+      it 'adds data attributes to URL' do
+        expect(subject).to include(%Q{data-space="breakout"})
+        expect(subject).to include(%Q{data-number="15000"})
+        expect(subject).to include(%Q{Comment to ticket <a href="/spaces/test_space/tickets/15000"})
+      end
+    end
+
     a = {}
     a["image:ExistingImage.png"] =
       '<img src="/spaces/test_space/documents/download/ExistingImage.png" alt="ALT" />'
@@ -1034,27 +1135,38 @@ describe 'BreakoutParser' do
       s = "[[image:aaa bbb]]"
       parse(s).should == s
     end
+
+    it 'escapes characters in urls' do
+      expect(parse(%Q{[[url:http://;"onmouseover="alert(0000000000000000)"s"|Ae]]})).to eq(%Q{<a rel="nofollow" href="http://;&quot;onmouseover=&quot;alert(0000000000000000)&quot;s&quot;">Ae</a>})
+    end
+
+    it 'parses snippets' do
+      result = parse("[[snippet:breakout:123]]")
+      expect(result).to match(/<script async="true" id="snippet-123" src="\/spaces\/breakout\/snippets\/123.js\?_=\d+"><\/script>/)
+    end
   end
 
 ###############################################################################
 ###############################################################################
 ###############################################################################
 
-  unless defined?HTML_ESCAPE
-    HTML_ESCAPE   =   { '&' => '&amp;', '>' => '&gt;', '<' => '&lt;', '"' => '&quot;' }
+  unless defined?(HTML_ESCAPE)
+    HTML_ESCAPE = { '&' => '&amp;', '>' => '&gt;', '<' => '&lt;', '"' => '&quot;' }
   end
 
-  def h s
+  def h(s)
     s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
   end
 
-  def parse s, h = {}
+  def parse(s, h = {})
     h[:space_name] = "test_space" unless h.key?(:space_name)
     BreakoutParser.parse(s,
       h[:space_name],
       h[:site_url],
       h[:vcs_url],
-      h[:absolute_urls]
+      h[:absolute_urls],
+      h[:large_files_url],
+      h[:meta_attributes]
     ).strip
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'breakout_parser/breakout_parser'

metadata

@@ -1,99 +1,126 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: breakout_parser
-version: !ruby/object:Gem::Version 
-  hash: 49
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 23
-  version: 0.0.23
+version: !ruby/object:Gem::Version
+  version: 0.0.31
 platform: ruby
-authors: 
+authors:
 - Andrey "Zed" Zaikin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-20 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
+date: 2014-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 2
-        - 9
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.2.9
   type: :development
-  version_requirements: *id001
-description: BreakoutParser
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.9
+description: BreakoutParser is a library that parses Breakout custom Textile input
 email: zed.0xff@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/breakout_parser/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - ChangeLog
 - LICENSE
 - README
-files: 
+files:
 - ChangeLog
 - LICENSE
 - README
 - ext/breakout_parser/depend
 - ext/breakout_parser/extconf.rb
-- ext/breakout_parser/lex.yy.c
 - ext/breakout_parser/main.c
 - ext/breakout_parser/make_win32.bat
+- ext/breakout_parser/parser.h
 - ext/breakout_parser/parser.l
-- ext/breakout_parser/parser.tab.c
-- ext/breakout_parser/parser.tab.h
 - ext/breakout_parser/parser.y
 - ext/breakout_parser/ruby_ext.c
+- ext/breakout_parser/ruby_ext.h
 - ext/breakout_parser/yywrap.c
 - lib/breakout_parser.rb
+- spec/links_only_parser_spec.rb
+- spec/obj_proxy.rb
+- spec/parser_examples_spec.rb
 - spec/parser_spec.rb
-has_rdoc: true
-homepage: http://assembla.com
+- spec/spec_helper.rb
+homepage: https://www.assembla.com
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: BreakoutParser
-test_files: 
+test_files:
+- spec/links_only_parser_spec.rb
+- spec/obj_proxy.rb
+- spec/parser_examples_spec.rb
 - spec/parser_spec.rb
+- spec/spec_helper.rb