berkeley_library-tind 0.4.0

data/spec/berkeley_library/util/ods/xml/content_doc_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+require 'rexml/document'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        describe ContentDoc do
+          let(:content) { ContentDoc.new }
+
+          describe :document_content do
+            it 'returns a DocumentContent' do
+              expect(content.document_content).to be_a(Office::DocumentContent)
+            end
+          end
+
+          describe :to_xml do
+            attr_reader :doc, :root
+
+            before(:each) do
+              xml_str = content.to_xml
+              @doc = REXML::Document.new(xml_str)
+              @root = doc.root
+            end
+
+            describe :root do
+
+              it 'is a <document-content/> element' do
+                expect(root).to be_a(REXML::Element)
+                expect(root.prefix).to eq('office')
+                expect(root.name).to eq('document-content')
+                expect(root.namespace).to eq('urn:oasis:names:tc:opendocument:xmlns:office:1.0')
+              end
+
+              it 'includes all namespaces' do
+                aggregate_failures('namespaces') do
+                  Office::DocumentContent::REQUIRED_NAMESPACES.each do |ns|
+                    expect(root["xmlns:#{ns.prefix}"]).to eq(ns.uri)
+                  end
+                end
+              end
+
+              describe '<scripts/>' do
+                it 'includes a <scripts/> element' do
+                  elem = root.elements[1]
+                  expect(elem).to be_a(REXML::Element)
+                  expect(elem.prefix).to eq('office')
+                  expect(elem.name).to eq('scripts')
+                end
+              end
+
+              describe '<font-face-decls/>' do
+                attr_reader :decls
+
+                before(:each) do
+                  @decls = root.elements[2]
+                end
+
+                it 'includes a <font-face-decls/> element' do
+                  expect(decls).to be_a(REXML::Element)
+                  expect(decls.prefix).to eq('office')
+                  expect(decls.name).to eq('font-face-decls')
+                end
+
+                it 'includes the default font face' do
+                  face = decls.elements[1]
+                  expect(face).to be_a(REXML::Element)
+                  expect(face.prefix).to eq('style')
+                  expect(face.name).to eq('font-face')
+
+                  expected_face = Style::FontFace::DEFAULT_FONT_FACE
+
+                  expect(face['style:name']).to eq(expected_face)
+                  expect(face['svg:font-family']).to eq("'#{expected_face}'")
+                  expect(face['style:font-family-generic']).to eq('swiss')
+                end
+              end
+
+              describe '<automatic-styles/>' do
+                attr_reader :styles
+
+                before(:each) do
+                  @styles = root.elements[3]
+                end
+
+                it 'includes an <automatic-styles/> element' do
+                  expect(styles).to be_a(REXML::Element)
+                  expect(styles.prefix).to eq('office')
+                  expect(styles.name).to eq('automatic-styles')
+                end
+              end
+
+              describe '<body/>' do
+                attr_reader :body
+
+                before(:each) do
+                  @body = root.elements[4]
+                end
+
+                it 'includes a <body/> element' do
+                  expect(body).to be_a(REXML::Element)
+                  expect(body.prefix).to eq('office')
+                  expect(body.name).to eq('body')
+                end
+
+                it 'includes a <spreadsheet/> element' do
+                  spreadsheet = body.elements[1]
+                  expect(spreadsheet).to be_a(REXML::Element)
+                  expect(spreadsheet.prefix).to eq('office')
+                  expect(spreadsheet.name).to eq('spreadsheet')
+                end
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/manifest/file_entry_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Manifest
+          describe FileEntry do
+            let(:doc) { Nokogiri::XML::Document.new }
+            let(:manifest) { Manifest.new(doc: doc) }
+
+            describe :new do
+              it 'guesses the media type' do
+                entry = FileEntry.new('foo.xml', manifest: manifest)
+                expect(entry.media_type).to eq('text/xml')
+              end
+
+              it 'rejects unknown types' do
+                expect { FileEntry.new('foo.bar', manifest: manifest) }.to raise_error(ArgumentError)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/manifest/manifest_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Manifest
+          describe Manifest do
+            let(:doc) { Nokogiri::XML::Document.new }
+
+            attr_reader :manifest
+
+            before(:each) do
+              @manifest = Manifest.new(doc: doc)
+            end
+
+            describe :add_child do
+              it 'adds a FileEntry' do
+                entry = FileEntry.new('foo.bar', 'foo/bar', manifest: manifest)
+                manifest.add_child(entry)
+              end
+
+              it 'adds a non-FileEntry' do
+                child = ElementNode.new(:office, 'test', doc: doc)
+                manifest.add_child(child)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/office/document_content_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Office
+          describe DocumentContent do
+            let(:content) { ContentDoc.new }
+            let(:doc_content) { content.document_content }
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def doc_content_xml
+              xml_str = content.to_xml
+              # File.open("tmp/content-#{Time.now.to_i}.xml", 'wb') { |f| f.write(xml_str) }
+              rexml_doc = REXML::Document.new(xml_str)
+              rexml_doc.root
+            end
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def find_table_xml(dc_xml = doc_content_xml, table_index = 1)
+              body = dc_xml.elements[4]
+              expect(body).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet = body.elements[1]
+              expect(spreadsheet).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet.elements[table_index]
+            end
+
+            describe :add_table do
+
+              let(:table_name) { "Table for #{File.basename(__FILE__, '.rb')}" }
+
+              attr_reader :table
+
+              before(:each) do
+                @table = doc_content.add_table(table_name)
+              end
+
+              it 'creates a table' do
+                expect(table).to be_a(XML::Table::Table)
+              end
+
+              it 'adds the table to the XML' do
+                table_xml = find_table_xml
+                expect(table_xml).to be_a(REXML::Element)
+                expect(table_xml.prefix).to eq('table')
+                expect(table_xml.name).to eq('table')
+
+                expect(table_xml['table:name']).to eq(table_name)
+                expect(table_xml['table:protected']).to eq('true')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/style/automatic_styles_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Office
+          describe AutomaticStyles do
+            let(:doc) { Nokogiri::XML::Document.new }
+
+            attr_reader :styles
+
+            before(:each) do
+              @styles = AutomaticStyles.new(doc: doc)
+            end
+
+            describe :add_child do
+              it 'adds a style' do
+                protected = false
+                color = '#abcdef'
+
+                style = Style::CellStyle.new('my-style', protected, color, styles: styles)
+                styles.add_child(style)
+                expect(styles.find_cell_style(protected, color: color)).to be(style)
+              end
+
+              it 'adds a non-style' do
+                non_style = XML::Text::P.new('abcdef', doc: doc)
+                styles.add_child(non_style)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/style/family_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Style
+          describe Family do
+            describe :ensure_family do
+              it "returns a #{Family} as itself" do
+                Family.each do |f|
+                  expect(Family.ensure_family(f)).to be(f)
+                end
+              end
+
+              it 'finds a family by key' do
+                Family.each do |f|
+                  variants = [
+                    f.key.to_s,
+                    f.key.to_sym,
+                    f.key.to_s.upcase,
+                    f.key.to_s.upcase.to_sym,
+                    f.key.to_s.downcase,
+                    f.key.to_s.downcase.to_sym
+                  ]
+                  variants.each do |k|
+                    expect(Family.ensure_family(k)).to be(f)
+                  end
+                end
+              end
+
+              it 'finds a family by value' do
+                Family.each do |f|
+                  variants = [
+                    f.value.to_s,
+                    f.value.to_sym,
+                    f.value.to_s.upcase,
+                    f.value.to_s.upcase.to_sym,
+                    f.value.to_s.downcase,
+                    f.value.to_s.downcase.to_sym
+                  ]
+                  variants.each do |v|
+                    expect(Family.ensure_family(v)).to be(f)
+                  end
+                end
+              end
+
+              it 'rejects invalid families' do
+                expect { Family.ensure_family(:not_a_family) }.to raise_error(ArgumentError)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/berkeley_library/util/ods/xml/table/table_row_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          describe TableRow do
+            let(:content) { ContentDoc.new }
+            let(:doc_content) { content.document_content }
+            let(:table_name) { "Table for #{File.basename(__FILE__, '.rb')}" }
+
+            attr_reader :table, :row
+
+            before(:each) do
+              @table = doc_content.add_table(table_name)
+              table.add_column('Column 1')
+              @row = table.add_row
+            end
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def doc_content_xml
+              xml_str = content.to_xml
+              # File.open("tmp/content-#{Time.now.to_i}.xml", 'wb') { |f| f.write(xml_str) }
+              rexml_doc = REXML::Document.new(xml_str)
+              rexml_doc.root
+            end
+
+            # TODO: move to some kind of helper & share w/table_spec
+            def find_table_xml(dc_xml = doc_content_xml, table_index = 1)
+              body = dc_xml.elements[4]
+              expect(body).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet = body.elements[1]
+              expect(spreadsheet).to be_a(REXML::Element) # just to be sure
+
+              spreadsheet.elements[table_index]
+            end
+
+            def find_row_xml(table_xml = find_table_xml, row_index = 2)
+              table_xml.elements[row_index, 'table-row']
+            end
+
+            def find_cell_xml(table_xml = find_table_xml, row_index = 2, col_index = 0)
+              row_xml = table_xml.elements[row_index, 'table-row']
+              cells_xml = row_xml.elements.select { |e| e.name == 'table-cell' }
+              cells_xml[col_index]
+            end
+
+            describe :set_value_at do
+              it 'sets a value' do
+                value = 'Value 0'
+                row.set_value_at(0, value)
+                expect(table.get_value_at(1, 0)).to eq(value)
+
+                row_xml = find_row_xml
+                cells_xml = row_xml.elements.select { |e| e.name == 'table-cell' }
+                expect(cells_xml.size).to eq(2)
+
+                cell_xml = cells_xml[0]
+                p = cell_xml.elements[1, 'p'] # row 1 is header
+                expect(p).to be_a(REXML::Element)
+                expect(p.prefix).to eq('text')
+
+                texts = p.texts
+                expect(texts.size).to eq(1)
+                expect(texts[0].value).to eq(value)
+
+                dummy_cell_xml = cells_xml[1]
+                expected_dummy_cols = Table::MIN_COLUMNS - 1
+                expect(dummy_cell_xml['table:number-columns-repeated']).to eq(expected_dummy_cols.to_s)
+              end
+
+              it 'escapes tabs, newlines, and runs of spaces' do
+                value_fragments = [
+                  ' test test ', "\t", 'test ', ' ', ' ', 'test test', "\n", 'test test ', ' '
+                ]
+                value = value_fragments.join
+                row.set_value_at(0, value)
+                expect(table.get_value_at(1, 0)).to eq(value)
+
+                row_xml = find_row_xml
+                cells_xml = row_xml.elements.select { |e| e.name == 'table-cell' }
+                expect(cells_xml.size).to eq(2)
+
+                escape_elements = { ' ' => 's', "\t" => 'tab', "\n" => 'line-break' }
+
+                cell_xml = cells_xml[0]
+                p_xml = cell_xml.elements[1, 'p']
+
+                p_children = p_xml.to_a
+                expect(p_children.size).to eq(value_fragments.size)
+
+                value_fragments.each_with_index do |vf, i|
+                  expected_element = escape_elements[vf]
+                  if expected_element
+                    element = p_children[i]
+                    expect(element).to be_a(REXML::Element)
+                    expect(element.name).to eq(expected_element)
+                    expect(element.prefix).to eq('text')
+                  else
+                    text = p_children[i]
+                    expect(text).to be_a(REXML::Text)
+                    expect(text.value).to eq(vf)
+                  end
+                end
+              end
+            end
+
+            describe :to_xml do
+              it 'collapses consecutive nils' do
+                (2..7).each { |col| table.add_column("Column #{col}") }
+
+                row.set_value_at(0, 'Value 0')
+                row.set_value_at(2, 'Value 2')
+                row.set_value_at(6, 'Value 6')
+
+                row_xml = find_row_xml
+                cells_xml = row_xml.elements.select { |e| e.name == 'table-cell' }
+                expect(cells_xml.size).to eq(6)
+
+                expected_values = ['Value 0', nil, 'Value 2', nil, 'Value 6', nil]
+                expected_repeats = [nil, nil, nil, 3, nil, Table::MIN_COLUMNS - 7]
+                cells_xml.each_with_index do |cell_xml, i|
+                  p = cell_xml.elements[1, 'p']
+                  if (expected_value = expected_values[i])
+                    expect(p).to be_a(REXML::Element)
+                    texts = p.texts
+                    expect(texts.size).to eq(1)
+                    expect(texts[0].value).to eq(expected_value)
+                  else
+                    expect(p).to be_nil
+                  end
+
+                  num_cols_repeated = cell_xml['table:number-columns-repeated']
+                  expected_repeat = expected_repeats[i]
+                  if expected_repeat
+                    expect(num_cols_repeated).to eq(expected_repeat.to_s)
+                  else
+                    expect(num_cols_repeated).to be_nil
+                  end
+                end
+              end
+            end
+
+            describe :add_child do
+              it 'adds a cell' do
+                value = 'Value 0'
+                cell = TableCell.new(value, table: table)
+                row.add_child(cell)
+                expect(table.get_value_at(1, 0)).to eq(value)
+              end
+
+              it 'adds a non-cell child' do
+                child = ElementNode.new(:office, 'test', doc: table.doc)
+                row.add_child(child)
+              end
+
+              it "fails if there aren't enough columns" do
+                column_count = table.column_count
+                (0..column_count).each do |col_index|
+                  value = "Value #{col_index}"
+                  cell = TableCell.new(value, table: table)
+                  if col_index < column_count
+                    expect { row.add_child(cell) }.not_to raise_error
+                    expect(table.get_value_at(1, col_index)).to eq(value)
+                  else
+                    expect { row.add_child(cell) }.to raise_error(ArgumentError)
+                    expect(table.get_value_at(1, col_index)).to be_nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end