docx_generator 0.1.0 → 0.1.1

data/spec/docx_generator/dsl/document_spec.rb

@@ -1,89 +1,89 @@
-require 'spec_helper'
-
-describe DocxGenerator::DSL::Document do
-  after do
-    File.delete("word.docx") if File.exists?("word.docx")
-  end
-
-  it "should create a new docx document with the filename specified" do
-    document = DocxGenerator::DSL::Document.new("word")
-    document.filename.should eq("word.docx")
-  end
-  
-  it "should pass itself to a block if a block is given" do
-    inner_doc = nil
-    document = DocxGenerator::DSL::Document.new("word") do |doc|
-      inner_doc = doc
-    end
-    inner_doc.should be(document)
-  end
-
-  describe "#save" do  
-    let(:document) { DocxGenerator::DSL::Document.new("word") }
-
-    it "should save the document" do
-      document.save
-      File.exists?("word.docx").should be_true
-    end
-    
-    describe "required documents" do
-      before { DocxGenerator::DSL::Document.new("word").save }
-    
-      it "should generate a [Content_Types].xml file" do
-        Zip::ZipFile.open("word.docx") do |docx|
-          expect { docx.read("[Content_Types].xml") }.to_not raise_error
-        end
-      end
-      
-      it "should generate a _rels/.rels file" do
-        Zip::ZipFile.open("word.docx") do |docx|
-          expect { docx.read("_rels/.rels") }.to_not raise_error
-        end
-      end
-      
-      it "should generate a word/document.xml" do
-        Zip::ZipFile.open("word.docx") do |docx|
-          expect { docx.read("word/document.xml") }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  describe "#paragraph" do
-    it "should pass a DocxGenerator::DSL::Paragraph object to a block" do
-      document = DocxGenerator::DSL::Document.new("word") do |doc|
-        par_class = nil
-        doc.paragraph { |par| par_class = par.class }
-        par_class.should be(DocxGenerator::DSL::Paragraph)
-      end
-    end
-
-    it "should add a paragraph to the document" do
-      document = DocxGenerator::DSL::Document.new("word") do |doc|
-        doc.paragraph { |par| }
-        doc.save
-      end
-      open_file("word/document.xml").should include("<w:p")
-    end
-
-    it "should allow options as optional arguments" do
-      document = DocxGenerator::DSL::Document.new("word") do |doc|
-        doc.paragraph(alignment: :center) { |par| }
-      end
-    end
-  end
-
-  describe "#add" do
-    it "should add the object(s) to the document" do
-      doc = DocxGenerator::DSL::Document.new("word")
-      doc.add DocxGenerator::DSL::Paragraph.new
-      doc.save
-      open_file("word/document.xml").should include("<w:p />")
-    end
-
-    it "should return the document object" do
-      document = DocxGenerator::DSL::Document.new("word")
-      document.add(DocxGenerator::DSL::Paragraph.new, DocxGenerator::DSL::Paragraph.new).should be(document)
-    end
-  end
-end
+require 'spec_helper'
+
+describe DocxGenerator::DSL::Document do
+  after do
+    File.delete("word.docx") if File.exists?("word.docx")
+  end
+
+  it "should create a new docx document with the filename specified" do
+    document = DocxGenerator::DSL::Document.new("word")
+    document.filename.should eq("word.docx")
+  end
+  
+  it "should pass itself to a block if a block is given" do
+    inner_doc = nil
+    document = DocxGenerator::DSL::Document.new("word") do |doc|
+      inner_doc = doc
+    end
+    inner_doc.should be(document)
+  end
+
+  describe "#save" do  
+    let(:document) { DocxGenerator::DSL::Document.new("word") }
+
+    it "should save the document" do
+      document.save
+      File.exists?("word.docx").should be_true
+    end
+    
+    describe "required documents" do
+      before { DocxGenerator::DSL::Document.new("word").save }
+    
+      it "should generate a [Content_Types].xml file" do
+        Zip::File.open("word.docx") do |docx|
+          expect { docx.read("[Content_Types].xml") }.to_not raise_error
+        end
+      end
+      
+      it "should generate a _rels/.rels file" do
+        Zip::File.open("word.docx") do |docx|
+          expect { docx.read("_rels/.rels") }.to_not raise_error
+        end
+      end
+      
+      it "should generate a word/document.xml" do
+        Zip::File.open("word.docx") do |docx|
+          expect { docx.read("word/document.xml") }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#paragraph" do
+    it "should pass a DocxGenerator::DSL::Paragraph object to a block" do
+      document = DocxGenerator::DSL::Document.new("word") do |doc|
+        par_class = nil
+        doc.paragraph { |par| par_class = par.class }
+        par_class.should be(DocxGenerator::DSL::Paragraph)
+      end
+    end
+
+    it "should add a paragraph to the document" do
+      document = DocxGenerator::DSL::Document.new("word") do |doc|
+        doc.paragraph { |par| }
+        doc.save
+      end
+      open_file("word/document.xml").should include("<w:p")
+    end
+
+    it "should allow options as optional arguments" do
+      document = DocxGenerator::DSL::Document.new("word") do |doc|
+        doc.paragraph(alignment: :center) { |par| }
+      end
+    end
+  end
+
+  describe "#add" do
+    it "should add the object(s) to the document" do
+      doc = DocxGenerator::DSL::Document.new("word")
+      doc.add DocxGenerator::DSL::Paragraph.new
+      doc.save
+      open_file("word/document.xml").should include("<w:p />")
+    end
+
+    it "should return the document object" do
+      document = DocxGenerator::DSL::Document.new("word")
+      document.add(DocxGenerator::DSL::Paragraph.new, DocxGenerator::DSL::Paragraph.new).should be(document)
+    end
+  end
+end

data/spec/docx_generator/dsl/paragraph_spec.rb

@@ -1,71 +1,107 @@
-require 'spec_helper'
-
-describe DocxGenerator::DSL::Paragraph do
-  describe "#new" do
-    context "with a block" do
-      it "should pass itself to a block" do
-        inner_par = nil
-        paragraph = DocxGenerator::DSL::Paragraph.new do |par|
-          inner_par = par
-        end
-        inner_par.should be(paragraph)
-      end
-    end
-  end
-
-  describe "#text" do
-    context "with a block" do
-      it "should pass a DocxGenerator::DSL::Text object to a block" do
-        paragraph = DocxGenerator::DSL::Paragraph.new do |par|
-          text_class = nil
-          par.text("") { |t| text_class = t.class }
-          text_class.should be(DocxGenerator::DSL::Text)
-        end
-      end
-    end
-
-    it "should allow options as optional arguments" do
-      paragraph = DocxGenerator::DSL::Paragraph.new do |par|
-        par.text "Title", underline: { style: "double" }, size: 20
-      end
-    end
-  end
-
-  describe "#generate" do
-    it "should return a new paragraph with rich text fragments in it separated by a space" do
-      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones."))
-      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
-    end
-
-    it "should not add a space when it encounters a NoSpace object" do
-      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("CO"), DocxGenerator::Word::Extensions::NoSpace.new, DocxGenerator::DSL::Text.new("2"))
-      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:t>2</w:t></w:r></w:p>")
-
-      paragraph = DocxGenerator::DSL::Paragraph.new do |p|
-        p.text "CO"
-        p.no_space
-        p.text "2"
-      end
-      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:t>2</w:t></w:r></w:p>")
-    end
-
-    context "with styles" do
-      it "should align the paragraph" do
-        DocxGenerator::DSL::Paragraph.new(alignment: "center").add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:jc w:val=\"center\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
-        (DocxGenerator::DSL::Paragraph.new { |p| p.alignment "center" }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:jc w:val=\"center\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
-      end
-    end
-  end
-
-  describe "#add" do
-    it "should add the object(s) to the paragraph" do
-      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones."))
-      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
-    end
-
-    it "should return the paragraph object" do
-      paragraph = DocxGenerator::DSL::Paragraph.new
-      paragraph.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).should be(paragraph)
-    end
-  end
-end
+require 'spec_helper'
+
+describe DocxGenerator::DSL::Paragraph do
+  describe "#new" do
+    context "with a block" do
+      it "should pass itself to a block" do
+        inner_par = nil
+        paragraph = DocxGenerator::DSL::Paragraph.new do |par|
+          inner_par = par
+        end
+        inner_par.should be(paragraph)
+      end
+    end
+  end
+
+  describe "#text" do
+    context "with a block" do
+      it "should pass a DocxGenerator::DSL::Text object to a block" do
+        paragraph = DocxGenerator::DSL::Paragraph.new do |par|
+          text_class = nil
+          par.text("") { |t| text_class = t.class }
+          text_class.should be(DocxGenerator::DSL::Text)
+        end
+      end
+    end
+
+    it "should allow options as optional arguments" do
+      paragraph = DocxGenerator::DSL::Paragraph.new do |par|
+        par.text "Title", underline: { style: "double" }, size: 20
+      end
+    end
+  end
+
+  describe "#generate" do
+    it "should return a new paragraph with rich text fragments in it separated by a space" do
+      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones."))
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+    end
+
+    it "should not add a space when it encounters a NoSpace object" do
+      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("CO"), DocxGenerator::Word::Extensions::NoSpace.new, DocxGenerator::DSL::Text.new("2"))
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:t>2</w:t></w:r></w:p>")
+
+      paragraph = DocxGenerator::DSL::Paragraph.new do |p|
+        p.text "CO"
+        p.no_space
+        p.text "2"
+      end
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:t>2</w:t></w:r></w:p>")
+    end
+
+    it "should add a newline when it encouters a Newline object" do
+      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("CO"), DocxGenerator::Word::Extensions::Newline.new, DocxGenerator::DSL::Text.new("2"))
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>2</w:t></w:r></w:p>")
+
+      paragraph = DocxGenerator::DSL::Paragraph.new do |p|
+        p.text "CO"
+        p.newline
+        p.text "2"
+      end
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>CO</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>2</w:t></w:r></w:p>")
+    end
+
+    it "should add a tab when it encouters a Tab object" do
+      raise
+    end
+
+    context "with styles" do
+      it "should align the paragraph" do
+        DocxGenerator::DSL::Paragraph.new(alignment: "center").add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:jc w:val=\"center\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+        (DocxGenerator::DSL::Paragraph.new { |p| p.alignment "center" }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:jc w:val=\"center\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+      end
+
+      it "should adjust the spacing between lines in the paragraph and between paragraphs" do
+        DocxGenerator::DSL::Paragraph.new(spacing: { before: 12, after: 12, lines: 1.15 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:spacing w:before=\"240\" w:after=\"240\" w:lines=\"276\" w:lineRule=\"auto\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+        (DocxGenerator::DSL::Paragraph.new { |p| p.spacing before: 12, after: 12, lines: 1.15 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:spacing w:before=\"240\" w:after=\"240\" w:lines=\"276\" w:lineRule=\"auto\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+      end
+
+      it "should indent the paragraph" do
+        DocxGenerator::DSL::Paragraph.new(indentation: { start: 20, end: 20, first_line: 20 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:ind w:start=\"400\" w:end=\"400\" w:firstLine=\"400\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+        (DocxGenerator::DSL::Paragraph.new { |p| p.indentation start: 20, end: 20, first_line: 20 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:ind w:start=\"400\" w:end=\"400\" w:firstLine=\"400\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+
+        DocxGenerator::DSL::Paragraph.new(indentation: { start: 20, end: 20, hanging: 20 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:ind w:start=\"400\" w:end=\"400\" w:hanging=\"400\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+        (DocxGenerator::DSL::Paragraph.new { |p| p.indentation start: 20, end: 20, hanging: 20 }).add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).generate.to_s.should eq("<w:p><w:pPr><w:ind w:start=\"400\" w:end=\"400\" w:hanging=\"400\" /></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+      end
+
+      it "should add tabulations" do
+        result = "<w:p><w:pPr><w:tabs><w:tab w:leader=\"dot\" w:pos=\"1440\" w:val=\"end\" /><w:tab w:leader=\"underscore\" w:pos=\"2880\" w:val=\"start\" /></w:tabs></w:pPr><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>"
+        text_fragments = [DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")]
+        DocxGenerator::DSL::Paragraph.new(tabs: [{ leader: "dot", pos: 72, val: "end" }, { leader: "underscore", pos: 144, val: "start" }]).add(*text_fragments).generate.to_s.should eq(result)
+        (DocxGenerator::DSL::Paragraph.new { |p| p.tabs [{ leader: "dot", pos: 72, val: "end" }, { leader: "underscore", pos: 144, val: "start" }] }).add(*text_fragments).generate.to_s.should eq(result)
+      end
+    end
+  end
+
+  describe "#add" do
+    it "should add the object(s) to the paragraph" do
+      paragraph = DocxGenerator::DSL::Paragraph.new.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones."))
+      paragraph.generate.to_s.should eq("<w:p><w:r><w:t>The first characters</w:t></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r><w:r><w:t>and the last ones.</w:t></w:r></w:p>")
+    end
+
+    it "should return the paragraph object" do
+      paragraph = DocxGenerator::DSL::Paragraph.new
+      paragraph.add(DocxGenerator::DSL::Text.new("The first characters"), DocxGenerator::DSL::Text.new("and the last ones.")).should be(paragraph)
+    end
+  end
+end

data/spec/docx_generator/dsl/text_spec.rb

@@ -1,65 +1,91 @@
-require 'spec_helper'
-
-describe DocxGenerator::DSL::Text do
-  describe "#new" do
-    it "should require some text" do
-      expect { DocxGenerator::DSL::Text.new }.to raise_error
-    end
-
-    context "with a block" do
-      it "should pass itself to a block" do
-        inner_text = nil
-        text = DocxGenerator::DSL::Text.new("") do |t|
-          inner_text = t
-        end
-        inner_text.should be(text)
-      end
-    end
-  end
-
-  describe "#generate" do
-    it "should return a new Run with text in it" do
-      text_fragment = DocxGenerator::DSL::Text.new("Title")
-      text_fragment.generate.to_s.should eq("<w:r><w:t>Title</w:t></w:r>")
-    end
-
-    context "with styles" do
-      it "should return a text in bold" do
-        DocxGenerator::DSL::Text.new("Text", bold: true).generate.to_s.should eq("<w:r><w:rPr><w:b w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.bold true }).generate.to_s.should eq("<w:r><w:rPr><w:b w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-      
-      it "should return a text in italics" do
-        DocxGenerator::DSL::Text.new("Text", italics: true).generate.to_s.should eq("<w:r><w:rPr><w:i w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.italics true }).generate.to_s.should eq("<w:r><w:rPr><w:i w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-      
-      it "should return an underlined text" do
-        DocxGenerator::DSL::Text.new("Text", underline: { style: "single" }).generate.to_s.should eq("<w:r><w:rPr><w:u w:val=\"single\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.underline style: "single" }).generate.to_s.should eq("<w:r><w:rPr><w:u w:val=\"single\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-
-      it "should return a text with a font size" do
-        DocxGenerator::DSL::Text.new("Text", size: 20).generate.to_s.should eq("<w:r><w:rPr><w:sz w:val=\"40\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.size 20 }).generate.to_s.should eq("<w:r><w:rPr><w:sz w:val=\"40\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-
-      it "should render a text in superscript" do
-        DocxGenerator::DSL::Text.new("Text", superscript: true).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"superscript\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.superscript true }).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"superscript\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-
-      it "should render a text in subscript" do
-        DocxGenerator::DSL::Text.new("Text", subscript: true).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"subscript\" /></w:rPr><w:t>Text</w:t></w:r>")
-        (DocxGenerator::DSL::Text.new("Text") { |t| t.subscript true }).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"subscript\" /></w:rPr><w:t>Text</w:t></w:r>")
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "should render the XML representation" do
-      text_fragment = DocxGenerator::DSL::Text.new("Title")
-      text_fragment.to_s.should eq("<w:r><w:t>Title</w:t></w:r>")
-    end
-  end
-end
+require 'spec_helper'
+
+describe DocxGenerator::DSL::Text do
+  describe "#new" do
+    it "should require some text" do
+      expect { DocxGenerator::DSL::Text.new }.to raise_error
+    end
+
+    context "with a block" do
+      it "should pass itself to a block" do
+        inner_text = nil
+        text = DocxGenerator::DSL::Text.new("") do |t|
+          inner_text = t
+        end
+        inner_text.should be(text)
+      end
+    end
+  end
+
+  describe "#generate" do
+    it "should return a new Run with text in it" do
+      text_fragment = DocxGenerator::DSL::Text.new("Title")
+      text_fragment.generate.to_s.should eq("<w:r><w:t>Title</w:t></w:r>")
+    end
+
+    context "with styles" do
+      it "should return a text in bold" do
+        DocxGenerator::DSL::Text.new("Text", bold: true).generate.to_s.should eq("<w:r><w:rPr><w:b w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.bold true }).generate.to_s.should eq("<w:r><w:rPr><w:b w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should return a text in italics" do
+        DocxGenerator::DSL::Text.new("Text", italics: true).generate.to_s.should eq("<w:r><w:rPr><w:i w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.italics true }).generate.to_s.should eq("<w:r><w:rPr><w:i w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should return an underlined text" do
+        DocxGenerator::DSL::Text.new("Text", underline: { style: "single" }).generate.to_s.should eq("<w:r><w:rPr><w:u w:val=\"single\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.underline style: "single" }).generate.to_s.should eq("<w:r><w:rPr><w:u w:val=\"single\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should return a text with a font size" do
+        DocxGenerator::DSL::Text.new("Text", size: 20).generate.to_s.should eq("<w:r><w:rPr><w:sz w:val=\"40\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.size 20 }).generate.to_s.should eq("<w:r><w:rPr><w:sz w:val=\"40\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should render a text in superscript" do
+        DocxGenerator::DSL::Text.new("Text", superscript: true).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"superscript\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.superscript true }).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"superscript\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should render a text in subscript" do
+        DocxGenerator::DSL::Text.new("Text", subscript: true).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"subscript\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.subscript true }).generate.to_s.should eq("<w:r><w:rPr><w:vertAlign w:val=\"subscript\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "shoud render a text as capital letters" do
+        DocxGenerator::DSL::Text.new("Text", caps: true).generate.to_s.should eq("<w:r><w:rPr><w:caps w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.caps true }).generate.to_s.should eq("<w:r><w:rPr><w:caps w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "shoud render a text as small capital letters" do
+        DocxGenerator::DSL::Text.new("Text", small_caps: true).generate.to_s.should eq("<w:r><w:rPr><w:smallCaps w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.small_caps true }).generate.to_s.should eq("<w:r><w:rPr><w:smallCaps w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      xit "shoud render a text with a single horizontal line through the center of the line" do
+        DocxGenerator::DSL::Text.new("Text", strike: true).generate.to_s.should eq("<w:r><w:rPr><w:strike w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.strike true }).generate.to_s.should eq("<w:r><w:rPr><w:strike w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      xit "shoud render a text with two horizontal lines through the center of the line" do
+        DocxGenerator::DSL::Text.new("Text", dstrike: true).generate.to_s.should eq("<w:r><w:rPr><w:dstrike w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.dstrike true }).generate.to_s.should eq("<w:r><w:rPr><w:dstrike w:val=\"true\" /></w:rPr><w:t>Text</w:t></w:r>")
+      end
+
+      it "should render the name of the font" do
+        result = "<w:r><w:rPr><w:rFonts w:ascii=\"Arial\" /></w:rPr><w:t>Text</w:t></w:r>"
+        DocxGenerator::DSL::Text.new("Text", font: "Arial").generate.to_s.should eq(result)
+        (DocxGenerator::DSL::Text.new("Text") { |t| t.font "Arial" }).generate.to_s.should eq(result)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it "should render the XML representation" do
+      text_fragment = DocxGenerator::DSL::Text.new("Title")
+      text_fragment.to_s.should eq("<w:r><w:t>Title</w:t></w:r>")
+    end
+  end
+end