thousand_island 0.0.1

data/spec/thousand_island/components/base_spec.rb

@@ -0,0 +1,68 @@
+module ThousandIsland
+  module Components
+    describe Base do
+      let(:prawn_doc) { instance_double('Prawn::Document') }
+      let(:component) { described_class.new(prawn_doc) }
+      let(:test_block) { lambda { |a| a } }
+
+      it 'merges defaults and passed options on new' do
+        options = { op_one: 1, op_two: 2 }
+        component = described_class.new(prawn_doc, options)
+        expected = component.defaults.merge(options)
+        expect(component.options).to eq(expected)
+      end
+
+      context 'interactions with Prawn' do
+
+        before :each do
+          allow(prawn_doc).to receive(:bounding_box).and_yield
+          allow(prawn_doc).to receive(:repeat).and_yield
+        end
+
+        it 'render all repeats the component' do
+          allow(component).to receive(:render)
+          expect(prawn_doc).to receive(:repeat).with(:all)
+          component.render_all
+        end
+
+        context 'the block' do
+          it 'yields when render' do
+            expect{ |doc| component.render(&doc) }.to raise_error(NotImplementedError)
+          end
+
+          it 'is passed to render when render_all' do
+            expect(component).to receive(:render)
+            component.render_all(&test_block)
+          end
+
+          context 'is passed by draw to' do
+            it 'render_all when repeated?' do
+              allow(component).to receive(:repeated?) { true }
+              expect(component).to receive(:render_all)
+              component.draw(&test_block)
+            end
+
+            it 'render when not repeated?' do
+              allow(component).to receive(:repeated?) { false }
+              expect(component).to receive(:render)
+              component.draw(&test_block)
+            end
+          end
+        end
+      end
+
+      it 'raises on render' do
+        expect{ component.render }.to raise_error(NotImplementedError)
+      end
+
+      it 'gets class defaults for instance' do
+        expect(component.defaults).to eq(described_class.defaults)
+      end
+
+      it 'defaults to not repeated?' do
+        expect(component.repeated?).to be false
+      end
+
+    end
+  end
+end

data/spec/thousand_island/components/body_spec.rb

@@ -0,0 +1,37 @@
+module ThousandIsland
+  module Components
+    describe Body do
+      let(:prawn_doc) { instance_double('Prawn::Document') }
+      let(:bounds) { double(:bounds) }
+      let(:body) { described_class.new(prawn_doc) }
+
+      context 'interactions with Prawn' do
+
+        before :each do
+          allow(prawn_doc).to receive(:bounding_box).and_yield
+          allow(bounds).to receive(:height) { std_doc_height }
+          allow(bounds).to receive(:width) { std_doc_width }
+          allow(prawn_doc).to receive(:bounds) { bounds }
+        end
+
+        it 'sizes the box' do
+          h = body.options[:height]
+          t = body.options[:top]
+          expect(prawn_doc).to receive(:bounding_box).with([0, t], width: std_doc_width, height: h)
+          body.render
+        end
+
+      end
+
+    private
+      def std_doc_height
+        840
+      end
+
+      def std_doc_width
+        595
+      end
+
+    end
+  end
+end

data/spec/thousand_island/components/footer_spec.rb

@@ -0,0 +1,57 @@
+module ThousandIsland
+  module Components
+    describe Footer do
+      let(:prawn_doc) { instance_double('Prawn::Document') }
+      let(:bounds) { double(:bounds) }
+      let(:footer) { described_class.new(prawn_doc) }
+
+      it '#repeated? uses the option value' do
+        footer.options[:repeated] = true
+        expect(footer.repeated?).to be true
+      end
+
+      context 'Page Numbering' do
+        context 'uses the correct string when options are' do
+          it 'set' do
+            expected = 'Page <page> of <total>'
+            footer.options[:numbering_string] = expected
+            expect(footer.numbering_string).to eq(expected)
+          end
+
+          it 'not set' do
+            expect(footer.numbering_string).to eq('<page>')
+          end
+        end
+
+      end
+
+      context 'interactions with Prawn' do
+
+        before :each do
+          allow(prawn_doc).to receive(:bounding_box).and_yield
+          allow(bounds).to receive(:width) { std_doc_width }
+          allow(prawn_doc).to receive(:bounds) { bounds }
+          allow(prawn_doc).to receive(:number_pages)
+        end
+
+        it 'sizes the box' do
+          h = footer.options[:height]
+          expect(prawn_doc).to receive(:bounding_box).with([0, h], width: std_doc_width, height: h)
+          footer.render
+        end
+
+        it 'renders the page numbers' do
+          expect(prawn_doc).to receive(:number_pages).with(footer.numbering_string, footer.options[:numbering_options])
+          footer.render
+        end
+
+      end
+
+    private
+      def std_doc_width
+        595
+      end
+
+    end
+  end
+end

data/spec/thousand_island/components/header_spec.rb

@@ -0,0 +1,40 @@
+module ThousandIsland
+  module Components
+    describe Header do
+      let(:prawn_doc) { instance_double('Prawn::Document') }
+      let(:bounds) { double(:bounds) }
+      let(:header) { described_class.new(prawn_doc) }
+
+      it '#repeated? uses the option value' do
+        header.options[:repeated] = true
+        expect(header.repeated?).to be true
+      end
+
+      context 'interactions with Prawn' do
+
+        before :each do
+          allow(prawn_doc).to receive(:bounding_box).and_yield
+          allow(bounds).to receive(:height) { std_doc_height }
+          allow(bounds).to receive(:width) { std_doc_width }
+          allow(prawn_doc).to receive(:bounds) { bounds }
+        end
+
+        it 'sizes the box' do
+          h = header.options[:height]
+          expect(prawn_doc).to receive(:bounding_box).with([0, std_doc_height], width: std_doc_width, height: h)
+          header.render
+        end
+      end
+
+    private
+      def std_doc_height
+        840
+      end
+
+      def std_doc_width
+        595
+      end
+
+    end
+  end
+end

data/spec/thousand_island/style_sheet_spec.rb

@@ -0,0 +1,44 @@
+module ThousandIsland
+  describe StyleSheet do
+    let(:subject) do
+      dummy = Class.new
+      dummy.send(:include, described_class)
+      dummy.new
+    end
+    let(:expected_styles) {  [:h1, :h2, :h3, :h4, :h5, :h6, :body, :footer] }
+
+    it 'builds the available styles array' do
+      expect(subject.available_styles).to match_array(expected_styles)
+    end
+
+    it 'has a style method for every style' do
+      expected_styles.each do |s|
+        expect(subject.send("#{s}_style")).to be_a(StyleHash)
+      end
+    end
+
+    it 'merges body_style with custom for h1' do
+      expected = {
+          size: 10 * 1.8,
+          style: :bold,
+          align: :left,
+          leading: 8,
+          inline_format: true,
+          color: '000000',
+      }
+      expect(subject.h1_style).to eq(expected)
+    end
+
+    context 'extends the Hash with' do
+      it 'font_size' do
+        style = subject.h1_style
+        expect(style[:font_size]).to eq(style[:size])
+      end
+      it 'styles' do
+        style = subject.h3_style
+        expect(style[:styles]).to eq([style[:style]])
+      end
+    end
+
+  end
+end

data/spec/thousand_island/template_spec.rb

@@ -0,0 +1,150 @@
+module ThousandIsland
+  describe Template do
+
+    context 'setup' do
+      it { expect(subject.pdf).to be_a(Prawn::Document) }
+
+      it 'sets the options with merged defaults and passed options' do
+        options = { op_one: 1, op_two: 2 }
+        defaults = subject.send(:defaults)
+        component_defaults = subject.send(:component_defaults)
+        deep_merger = ThousandIsland::Utilities::DeepMerge
+        expect(deep_merger).to receive(:merge_options).with(options, [], defaults, component_defaults)
+        subject.send(:setup_document_options, options)
+      end
+
+      it 'method missing' do
+        expect{ subject.made_up_method }.to raise_error(NoMethodError)
+      end
+
+    end
+
+    context 'Style Sheet' do
+      context 'adds method to template' do
+        it 'h1' do
+          expect(subject.respond_to?(:h1)).to be true
+        end
+
+        it 'h2' do
+          expect(subject.respond_to?(:h2)).to be true
+        end
+
+        it 'h3' do
+          expect(subject.respond_to?(:h3)).to be true
+        end
+
+      end
+
+      it 'adds text to the pdf' do
+        pdf = instance_double('Prawn::Document')
+        allow(subject).to receive(:pdf) { pdf }
+        expected = 'Test Text'
+        style = subject.h1_style
+        expect(pdf).to receive(:text).with(expected, style)
+        subject.h1 expected
+      end
+
+      it 'does not add an h9 method' do
+        expect(subject.respond_to?(:h9)).to be false
+      end
+    end
+
+    context 'Header' do
+      let(:header) { instance_double('ThousandIsland::Components::Header') }
+
+      before :each do
+        allow(header).to receive(:draw)
+        allow(subject).to receive(:header_obj) { header }
+      end
+
+      it 'calls draw on the Header component' do
+        expect(header).to receive(:draw)
+        subject.draw_header
+      end
+
+      it 'does not call header_content if not exists' do
+        expect(subject).to_not receive(:header_content)
+        subject.draw_header
+      end
+
+      it 'calls header_content when it exists' do
+        described_class.send(:define_method, :header_content) {}
+        template = described_class.new
+        expect(template).to receive(:header_content)
+        template.draw_header
+      end
+
+      describe 'calculates space' do
+        it 'on when rendering' do
+          subject.pdf_options[:header][:height] = 30
+          subject.pdf_options[:header][:bottom_padding] = 10
+          expect(subject.send(:header_space)).to eq(40)
+        end
+        it 'on when not rendering' do
+          subject.pdf_options[:header][:render] = false
+          expect(subject.send(:header_space)).to eq(0)
+        end
+      end
+    end
+
+    context 'Footer' do
+      let(:footer) { instance_double('ThousandIsland::Components::Footer') }
+
+      before :each do
+        allow(footer).to receive(:draw)
+        allow(subject).to receive(:footer_obj) { footer }
+      end
+
+      it 'calls draw on the Footer component' do
+        expect(footer).to receive(:draw)
+        subject.draw_footer
+      end
+
+      it 'does not call footer_content if not exists' do
+        expect(subject).to_not receive(:footer_content)
+        subject.draw_footer
+      end
+
+      it 'calls footer_content when it exists' do
+        described_class.send(:define_method, :footer_content) {}
+        template = described_class.new
+        expect(template).to receive(:footer_content)
+        template.draw_footer
+      end
+
+      describe 'calculates space' do
+        it 'on when rendering' do
+          subject.pdf_options[:footer][:height] = 30
+          subject.pdf_options[:footer][:top_padding] = 10
+          expect(subject.send(:footer_space)).to eq(40)
+        end
+        it 'on when not rendering' do
+          subject.pdf_options[:footer][:render] = false
+          expect(subject.send(:footer_space)).to eq(0)
+        end
+      end
+    end
+
+    context 'Body' do
+      let(:body) { instance_double('ThousandIsland::Components::Body') }
+
+      before :each do
+        allow(body).to receive(:draw)
+        allow(subject).to receive(:body_obj) { body }
+      end
+
+      it 'does not call body if not exists' do
+        expect(subject).to_not receive(:body_content)
+        subject.draw_body
+      end
+
+      it 'calls body when it exists' do
+        described_class.send(:define_method, :body_content) {}
+        template = described_class.new
+        expect(template).to receive(:body_content)
+        template.draw_body
+      end
+    end
+
+  end
+end

data/spec/thousand_island/utilities/style_hash_spec.rb

@@ -0,0 +1,29 @@
+module ThousandIsland
+  describe StyleHash do
+    let(:opts) { {size: 1, style: 2, other: 3} }
+    let(:subject) { described_class.new(opts) }
+
+    it 'is a Hash' do
+      expect(subject).to be_a(Hash)
+    end
+
+    it 'returns nil as default key' do
+     expect(subject[:made_up_key]).to be nil
+    end
+
+    it 'sets the passed options' do
+      expect(subject[:size]).to eq(1)
+      expect(subject[:style]).to eq(2)
+      expect(subject[:other]).to eq(3)
+    end
+
+    it 'gets size value for the font_size key' do
+      expect(subject[:font_size]).to eq(1)
+    end
+
+    it 'gets style value for the styles key' do
+      expect(subject[:styles]).to eq([2])
+    end
+
+  end
+end

data/spec/thousand_island/utilities/utilities_spec.rb

@@ -0,0 +1,82 @@
+module ThousandIsland
+  module Utilities
+
+    describe DeepMerge do
+
+      let(:default) {{
+        header:{
+          height: 33,
+          repeated: true,
+        },
+        footer: {
+          height: 33,
+          repeated: true,
+          numbering_options: {
+            align: :right,
+            start_count_at: 1,
+          },
+          number_pages: true,
+          numbering_string: '<page>',
+          style: {
+            font_size: 23
+          },
+        },
+      }}
+      let(:options) {{
+        header: {
+            height: 33,
+            repeated: false,
+        },
+        footer: {
+          height: 40,
+          repeated: true,
+          numbering_options: {
+            align: :right,
+            start_count_at: 2,
+          },
+        },
+      }}
+      let(:over) {{
+        header: {
+          height: 50,
+          repeated: true,
+        },
+        footer: {
+          height: 50,
+          repeated: false,
+          numbering_options: {
+            align: :left,
+          },
+          style: {
+            font_size: 5
+          },
+        },
+      }}
+
+      it 'deep merges the hashes intelligently' do
+        expected = {
+          header: {
+            height: 50,
+            repeated: true,
+          },
+          footer: {
+            height: 50,
+            repeated: false,
+            numbering_options: {
+              align: :left,
+              start_count_at: 2,
+            },
+            number_pages: true,
+            numbering_string: '<page>',
+            style: {
+              font_size: 5
+            },
+          },
+          body: {},
+        }
+        final = described_class.merge_options(over, options, default)
+        expect(final).to eq(expected)
+      end
+    end
+  end
+end