html2bbcode 1.0.0

data/spec/lib/bbcode/closing_tags_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Bbcode::ClosingTags do
+  let(:bbcode_element) { double 'bbcode element'}
+  subject{ described_class.new bbcode_element }
+
+  describe '#tags' do
+    context 'the names contain the * (li html) tag' do
+      before { subject.stub names: %w(*) }
+
+      its(:tags) { should eq '' }
+    end
+
+    context 'the names contain any other tag' do
+      before { subject.stub names: %w(b) }
+
+      its(:tags) { should eq '[/b]' }
+    end
+  end
+end

data/spec/lib/bbcode/element_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Bbcode::Element do
+  let(:html_element) { double 'html element' }
+  subject { described_class.new html_element }
+
+  describe '#opening_tags' do
+    let(:opening_tags) { double 'opening tags', tags: %w(b) }
+    before { subject.stub get_opening_tags: opening_tags }
+
+    it 'delegates method to the opening tags object' do
+      subject.opening_tags
+      expect(opening_tags).to have_received :tags
+    end
+  end
+
+  describe '#closing_tags' do
+    let(:closing_tags) { double 'closing tags', tags: %w(b) }
+    before { subject.stub get_closing_tags: closing_tags }
+
+    it 'delegates method to the closing tags object' do
+      subject.closing_tags
+      expect(closing_tags).to have_received :tags
+    end
+  end
+
+  describe '#names' do
+    before { subject.stub name: 'a' }
+
+    its(:names) { should match_array ['a'] }
+  end
+
+  describe '#name' do
+    let(:rules) { double 'rules', bbcode_name: 'b' }
+    before { subject.stub rules: rules }
+
+    it 'delegates method to the rules object' do
+      subject.name
+      expect(rules).to have_received :bbcode_name
+    end
+  end
+end

data/spec/lib/bbcode/opening_tags_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Bbcode::OpeningTags do
+  let(:bbcode_element) { double 'bbcode element'}
+  subject{ described_class.new bbcode_element }
+
+  describe '#tags' do
+    before { subject.stub names: %w(b u) }
+
+    its(:tags) { should eq '[b][u]' }
+
+    context 'the names contain the url tag' do
+      let(:href) { 'www.example.com' }
+      before { subject.stub names: %w(url), href: href, text: text }
+
+      context 'the text is the same like the href attribute' do
+        let(:text) { href }
+
+        its(:tags) { should eq '[url]' }
+      end
+
+      context 'the text is different than the href attribute' do
+        let(:text) { 'A title for the link' }
+
+        its(:tags) { should eq "[url=#{href}]" }
+      end
+    end
+
+    context 'the names contain the size tag' do
+      before { subject.stub names: %w(size), font_size: 15 }
+
+      its(:tags) { should eq "[size=15]" }
+    end
+
+    context 'the names contain the color tag' do
+      before { subject.stub names: %w(color), font_color: 'blue' }
+
+      its(:tags) { should eq "[color=blue]" }
+    end
+
+    context 'the names contain the * (li html) tag' do
+      before { subject.stub names: %w(*) }
+
+      its(:tags) { should eq '[*]' }
+    end
+
+    context 'the names contain the list tag' do
+      before { subject.stub names: %w(list) }
+
+      context 'the html tag is ul' do
+        before { subject.stub html_name: 'ul' }
+
+        its(:tags) { should eq '[list]'}
+      end
+
+      context 'the html tag is ol' do
+        before { subject.stub html_name: 'ol' }
+
+        its(:tags) { should eq '[list=1]'}
+      end
+    end
+  end
+end

data/spec/lib/bbcode/rules_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Bbcode::Rules do
+  let(:bbcode_element) { double 'bbcode elemenet' }
+  subject { described_class.new bbcode_element }
+  before { subject.stub html_name: html_name }
+
+  %w(b i u s img table tr td).each do |tag_name|
+    context "html element name is: #{tag_name}" do
+      let(:html_name) { tag_name }
+
+      its(:bbcode_name) { should eq tag_name }
+    end
+  end
+
+  context 'html element name is: a' do
+    let(:html_name) { 'a' }
+    before { subject.stub html_href: href }
+
+    context 'html element contains a href attribute' do
+      let(:href) { 'www.example.com' }
+
+      its(:bbcode_name) { should eq 'url' }
+    end
+
+    context 'html element does not contain a href attribute' do
+      let(:href) { nil }
+
+      its(:bbcode_name) { should be_nil }
+    end
+  end
+
+  context 'html element name is: blockquote' do
+    let(:html_name) { 'blockquote' }
+
+    its(:bbcode_name) { should eq 'quote' }
+  end
+
+  context 'html element name is: pre' do
+    let(:html_name) { 'pre' }
+
+    its(:bbcode_name) { should eq 'code' }
+  end
+
+  context 'html element name is: strong' do
+    let(:html_name) { 'strong' }
+
+    its(:bbcode_name) { should eq 'b' }
+  end
+
+  context 'html element name is: em' do
+    let(:html_name) { 'em' }
+
+    its(:bbcode_name) { should eq 'i' }
+  end
+
+  context 'html element name is: ins' do
+    let(:html_name) { 'ins' }
+
+    its(:bbcode_name) { should eq 'u' }
+  end
+
+  context 'html element name is: del' do
+    let(:html_name) { 'del' }
+
+    its(:bbcode_name) { should eq 's' }
+  end
+
+  context 'html element name is: font' do
+    let(:html_name) { 'font' }
+
+    before { subject.stub html_font_size: nil, html_color: nil }
+
+    its(:bbcode_name) { should be_nil }
+
+    context 'attributes contain the size' do
+      before { subject.stub html_font_size: '15' }
+
+      its(:bbcode_name) { should eq 'size' }
+    end
+
+    context 'attributes contain the color' do
+      before { subject.stub html_color: 'red' }
+
+      its(:bbcode_name) { should eq 'color' }
+    end
+  end
+
+  context 'html element name is ul' do
+    let(:html_name) { 'ul' }
+
+    its(:bbcode_name) { should eq 'list' }
+  end
+
+  context 'html element name is ol' do
+    let(:html_name) { 'ol' }
+
+    its(:bbcode_name) { should eq 'list' }
+  end
+
+  context 'html element name is li' do
+    let(:html_name) { 'li' }
+
+    its(:bbcode_name) { should eq '*' }
+  end
+
+  context 'html element name is: span' do
+    let(:html_name) { 'span' }
+    before { subject.stub(html_styles: style) }
+
+    context 'html element does not contain a style' do
+      let(:style) { {} }
+
+      its(:bbcode_name) { should be_empty }
+    end
+
+    context 'html element contains a style' do
+      context 'the style is font-weight: bold' do
+        let(:style) { {'font-weight' => 'bold'} }
+
+        its(:bbcode_name) { should match_array %w(b) }
+      end
+
+      context 'the style is text-decoration: underline' do
+        let(:style) { {'text-decoration' => 'underline'} }
+
+        its(:bbcode_name) { should match_array %w(u) }
+      end
+
+      context 'the style is text-decoration: line-through' do
+        let(:style) { {'text-decoration' => 'line-through'} }
+
+        its(:bbcode_name) { should match_array %w(s) }
+      end
+
+      context 'the style is text-decoration: line-through' do
+        let(:style) { {'font-style' => 'italic'} }
+
+        its(:bbcode_name) { should match_array %w(i) }
+      end
+
+      context 'the style is font-size: 15px' do
+        let(:style) { {'font-size' => '15px'} }
+
+        its(:bbcode_name) { should match_array %w(size) }
+      end
+
+      context 'the style is color: red' do
+        let(:style) { {'color' => 'red'} }
+
+        its(:bbcode_name) { should match_array %w(color) }
+      end
+
+      context 'the style are font-style: italic and font-weight: bold' do
+        let(:style) { {'font-style' => 'italic', 'font-weight' => 'bold'} }
+
+        its(:bbcode_name) { should match_array %w(b i) }
+      end
+
+      context 'the style are font-weight: bold and margin-left: 20px' do
+        let(:style) { {'font-weight' => 'bold', 'margin-left' => '20px'} }
+
+        its(:bbcode_name) { should match_array %w(b) }
+      end
+    end
+  end
+end

data/spec/lib/html/attributes_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Html::Attributes do
+  describe '#has_html_attribtues' do
+    class Element
+      extend Html2Bbcode::Html::Attributes
+      has_html_attributes :style
+    end
+
+    let(:html_element) { double 'html element' }
+
+    subject { Element.new }
+
+    before { subject.stub element: html_element }
+
+    context 'attributes does not contain given attribute' do
+      before { html_element.stub :[] }
+
+      its(:style) { should be_nil }
+    end
+
+    context 'attributes contains given attribute' do
+      before { html_element.stub(:[]).with('style').and_return 'color: red;' }
+
+      its(:style) { should eq 'color: red;' }
+    end
+
+    context 'given attribute is not defined in the html attributes' do
+      it 'raises an error about missing method' do
+        expect { subject.src }.to raise_error
+      end
+    end
+  end
+end

data/spec/lib/html/color_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Html::Color do
+  let(:color) { nil }
+  subject { described_class.new color }
+
+  its(:get) { should be_nil }
+
+  context 'an element has a color attribute' do
+    context 'the color is a name of the color' do
+      let(:color) { 'blue' }
+
+      its(:get) { should eq color }
+    end
+
+    context 'the color is a hex value' do
+      let(:color) { '#003322' }
+
+      its(:get) { should eq color }
+    end
+
+    context 'the color is a rgb value' do
+      let(:color) { 'rgb(0, 64, 255)' }
+
+      its(:get) { should eq '#0040ff' }
+    end
+  end
+end

data/spec/lib/html/element_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Html2Bbcode::Html::Element do
+  let(:nokogiri_html_element) { Nokogiri::HTML::Document.parse input_html }
+  let(:input_html) { 'Sample text' }
+
+  subject { described_class.new nokogiri_html_element }
+
+  it 'has the html attributes interface' do
+    expect(described_class).to respond_to :has_html_attributes
+  end
+
+  it 'has html attributes' do
+    expect(subject).to respond_to :href, :src, :size, :styles, :color
+  end
+
+  describe '#process' do
+    its(:process) { should eq input_html }
+
+    context 'contains nested html tags' do
+      let(:input_html) { 'normal <b> bolded words <i> italic and bolded </i> bolded </b> normal' }
+
+      its(:process) { should eq 'normal [b] bolded words [i] italic and bolded [/i] bolded [/b] normal'}
+    end
+
+    context 'contains the img tag' do
+      let(:input_html) { 'normal <img src="secret.png"></img>' }
+
+      its(:process) { should eq 'normal [img]secret.png[/img]'}
+    end
+
+    context 'contains the span tag with the font size & text decoration styles' do
+      let(:input_html) { '<span style="font-size: 15cm; text-decoration: underline;">text 15 cm and underline</span>' }
+
+      context 'the size unit is not set' do
+        subject { described_class.new nokogiri_html_element }
+
+        its(:process) { should eq '[u][size=15]text 15 cm and underline[/size][/u]'}
+      end
+
+      context 'the size unit is set' do
+        subject { described_class.new nokogiri_html_element, size_unit: 'mm' }
+
+        its(:process) { should eq '[u][size=150]text 15 cm and underline[/size][/u]'}
+      end
+    end
+
+    context 'contains the font tag with the color attribute & span tag with font-color style' do
+      let(:input_html) { '<font color="blue">blue text</font><span style="color: red;">red text</span>' }
+
+      its(:process) { should eq '[color=blue]blue text[/color][color=red]red text[/color]'}
+    end
+
+    context 'contains the ordered list' do
+      let(:input_html) { '<ol><li>first</li> <li>second</li></ol>'}
+
+      its(:process) { should eq '[list=1][*]first [*]second[/list]'}
+    end
+
+    context 'contains the unordered list' do
+      let(:input_html) { '<ul><li>first</li> <li>second</li></ul>'}
+
+      its(:process) { should eq '[list][*]first [*]second[/list]'}
+    end
+
+    context 'contains the table' do
+      let(:input_html) { '<table><tr><td>date</td></tr><tr><td>second date</td></tr></table>' }
+
+      its(:process) { should eq '[table][tr][td]date[/td][/tr][tr][td]second date[/td][/tr][/table]' }
+    end
+
+    context 'contains the pre tag with a content' do
+      let(:input_html) { '<pre><b>bolded</b></pre>' }
+
+      its(:process) { should eq '[code]<b>bolded</b>[/code]' }
+    end
+
+    context 'contains the br tag' do
+      let(:input_html) { '<br><br/>' }
+
+      its(:process) { should eq "\n\n" }
+    end
+  end
+
+  describe '#build_bbcode_element' do
+    before { subject.stub bbcode_opening_tags: '[a]', process: 'sample text', bbcode_closing_tags: '[/a]' }
+
+    its(:build_bbcode_element) { should eq '[a]sample text[/a]' }
+  end
+
+  describe '#to_bbcode_element' do
+    before { subject.stub(element?: false, text?: false) }
+
+    its(:to_bbcode_element) { should be_nil }
+
+    context 'the element name is br' do
+      before { subject.stub(name: 'br') }
+
+      its(:to_bbcode_element) { should eq "\n" }
+    end
+
+    context 'the element is an element in the nokogiri structure' do
+      let(:bbcode_element) { '[b]bolded[/b]' }
+      before { subject.stub(element?: true, build_bbcode_element: bbcode_element) }
+
+      its(:to_bbcode_element) { should eq bbcode_element }
+    end
+
+    context 'the element is a text in the nokogiri structure' do
+      let(:text) { 'Sample text' }
+      before { subject.stub(text?: true, text: text) }
+
+      its(:to_bbcode_element) { should eq text }
+    end
+  end
+
+  describe '#font_color' do
+    let(:element_color) { double 'element color', get: 'red' }
+    before { subject.stub element_color: element_color }
+
+    it 'delegates the method to the color object' do
+      subject.font_color
+      expect(element_color).to have_received :get
+    end
+  end
+
+  describe '#font_size' do
+    before do
+      nokogiri_html_element.stub(:[]).with('style').and_return nil
+      nokogiri_html_element.stub(:[]).with('size').and_return nil
+    end
+
+    its(:font_size) { should be_nil }
+
+    shared_examples_for 'a size unit converter' do
+      context 'size unit is the same like the unit of the size attribute' do
+        subject { described_class.new nokogiri_html_element, size_unit: 'cm' }
+
+        its(:font_size) { should eq 15 }
+      end
+
+      context 'size unit is different than the unit of the size attribute' do
+        subject { described_class.new nokogiri_html_element, size_unit: 'mm' }
+
+        its(:font_size) { should eq 150 }
+      end
+
+      context 'size unit is not set' do
+        subject { described_class.new nokogiri_html_element }
+
+        its(:font_size) { should eq 15 }
+      end
+    end
+
+    context 'element has a size attribute' do
+      before { nokogiri_html_element.stub(:[]).with('size').and_return '15cm' }
+
+      it_behaves_like 'a size unit converter'
+    end
+
+    context 'element has a style about the font size' do
+      before { nokogiri_html_element.stub(:[]).with('style').and_return 'font-size: 15cm;' }
+
+      it_behaves_like 'a size unit converter'
+    end
+  end
+end

data/spec/lib/html2bbcode_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Html2Bbcode do
+  let(:input_html) { 'Sample text' }
+
+  subject { Html2Bbcode.new input_html  }
+
+  describe '#convert' do
+    let(:html_element) { double 'html element', process: true }
+
+    before { subject.stub html_element: html_element }
+
+    it 'calls process on the html element' do
+      subject.convert
+      expect(html_element).to have_received :process
+    end
+  end
+end

data/spec/lib/ruby_units/definitions_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'custom unit definitions' do
+  describe 'pixels' do
+    subject { Unit.new('1 px') }
+
+    it 'has the unit' do
+      expect { subject }.to_not raise_error
+    end
+
+    it 'converts properly to the other unit' do
+      expect(subject.to('in')).to eq(Unit.new('1/72 in'))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'html2bbcode'
+require 'pry'
+
+RSpec.configure do |config|
+  config.order = 'random'
+end