hydramata-works 0.0.1.prerelease

data/spec/parsers/hydramata/works/datastream_parser_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_fast_helper'
+require 'hydramata/works/datastream_parser'
+require 'hydramata/works/linters'
+
+module Hydramata
+  module Works
+    describe DatastreamParser do
+      context '.parser_for' do
+        let(:a_parser) { double('A Parser') }
+        let(:parser_finder) { double('Parser Finder', call: a_parser) }
+        let(:datastream) { double('Datastream') }
+        let(:options) { { parser_finder: parser_finder, datastream: datastream } }
+        it 'should find the appropriate parser based on input options' do
+          expect(described_class.parser_for(options)).to eq(a_parser)
+          expect(parser_finder).to have_received(:call).with(options)
+        end
+      end
+
+      context '.call' do
+        let(:content) { '<fields>\n  <depositor>Username-1</depositor>\n</fields>' }
+        let(:datastream) { double('Datastream', content: content, mimeType: 'text/xml') }
+        let(:options) { { datastream: datastream } }
+        it 'should find the appropriate parser based on input options' do
+          expect { |b| described_class.call(options, &b) }.to yield_with_args(predicate: 'depositor', value: 'Username-1')
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/datastream_parsers/rdf_ntriples_parser_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_fast_helper'
+require 'hydramata/works/datastream_parsers/rdf_ntriples_parser'
+require 'hydramata/works/linters'
+require 'rdf'
+
+module Hydramata
+  module Works
+    module DatastreamParsers
+      describe RdfNtriplesParser do
+        it_behaves_like 'a datastream parser'
+
+        let(:rdf_subject) { 'info:fedora/und:f4752f8687n' }
+        let(:rdf_predicate) { 'http://purl.org/dc/terms/dateSubmitted' }
+        let(:rdf_object) { "\"#{rdf_object_value}\"^^<http://www.w3.org/2001/XMLSchema#date>" }
+        let(:rdf_object_value) { '2014-06-02Z' }
+        let(:data) { "<#{rdf_subject}> <#{rdf_predicate}> #{rdf_object} ." }
+
+        subject { described_class }
+
+        context '.match?' do
+          let(:ntriples_datastream) { double(content: data, mimeType: 'text/plain') }
+          let(:not_ntriples_datastream) { double(content: '', mimeType: 'application/xml') }
+          it 'should not match when no datastream is provided' do
+            expect(described_class.match?).to be_falsey
+          end
+
+          it 'should match when an RDF ntriples datastream is provided' do
+            expect(described_class.match?(datastream: ntriples_datastream)).to eq(described_class)
+          end
+
+          it 'should not match when the data stream does not appear to be RDF ntriples' do
+            expect(described_class.match?(datastream: not_ntriples_datastream)).to be_falsey
+          end
+        end
+
+        context 'with single value encountered' do
+          it 'should yield each encountered property' do
+            expect { |b| subject.call(data, &b) }.to yield_with_args(predicate: rdf_predicate, value: instance_of(RDF::Literal::Date))
+          end
+        end
+
+        context 'with multiple values encountered' do
+          let(:rdf_object_1) { "\"#{rdf_object_value_1}\"^^<http://www.w3.org/2001/XMLSchema#date>" }
+          let(:rdf_object_2) { "\"#{rdf_object_value_2}\"^^<http://www.w3.org/2001/XMLSchema#date>" }
+          let(:rdf_object_value_1) { '2014-06-02Z' }
+          let(:rdf_object_value_2) { '2013-05-03Z' }
+          let(:data) do
+            [
+              "<#{rdf_subject}> <#{rdf_predicate}> #{rdf_object_1} .",
+              "<#{rdf_subject}> <#{rdf_predicate}> #{rdf_object_2} ."
+            ].join("\n")
+          end
+
+          it 'should yield each encountered property' do
+            expect { |b| subject.call(data, &b) }.
+            to yield_successive_args(
+              { predicate: rdf_predicate, value: instance_of(RDF::Literal::Date) },
+              { predicate: rdf_predicate, value: instance_of(RDF::Literal::Date) }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/datastream_parsers/simple_xml_parser_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_fast_helper'
+require 'hydramata/works/datastream_parsers/simple_xml_parser'
+require 'hydramata/works/linters'
+
+module Hydramata
+  module Works
+    module DatastreamParsers
+      describe SimpleXmlParser do
+        it_behaves_like 'a datastream parser'
+
+        context '.call' do
+          let(:content) { '<fields>\n  <depositor>Username-1</depositor>\n</fields>' }
+          it 'should find the appropriate parser based on input options' do
+            expect { |b| described_class.call(content, &b) }.to yield_with_args(predicate: 'depositor', value: 'Username-1')
+          end
+        end
+
+        context '.match?' do
+          let(:xml_datastream) { double(content: '<xml>', mimeType: 'application/xml') }
+          let(:non_xml_datastream) { double(content: '', mimeType: 'text/plain') }
+          it 'should not match when no datastream is provided' do
+            expect(described_class.match?).to be_falsey
+          end
+
+          it 'should match when an RDF ntriples datastream is provided' do
+            expect(described_class.match?(datastream: xml_datastream)).to eq(described_class)
+          end
+
+          it 'should not match when the data stream does not appear to be RDF ntriples' do
+            expect(described_class.match?(datastream: non_xml_datastream)).to be_falsey
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/predicate_parser_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_fast_helper'
+require 'hydramata/works/predicate_parser'
+
+module Hydramata
+  module Works
+    describe PredicateParser do
+
+      let(:predicate) { double('Predicate') }
+      let(:value) { double('Value') }
+
+      context '.parser_for' do
+        let(:a_parser) { double('A Parser', call: true) }
+        let(:parser_finder) { double('Parser Finder', call: a_parser) }
+        let(:options) { { predicate: predicate, work_type: 'article', parser_finder: parser_finder, value: value } }
+        it 'should find the appropriate parser based on the predicate and work_type' do
+          expect(described_class.parser_for(options)).to eq(a_parser)
+          expect(parser_finder).to have_received(:call).with(options)
+        end
+      end
+
+      context '.call' do
+        let(:options) { { predicate: predicate, work_type: 'article', value: value } }
+        it 'coordinates with the parser_finder and calls the found parser' do
+          expect { |b| described_class.call(options, &b) }.to yield_with_args(value: value)
+        end
+      end
+
+    end
+  end
+end

data/spec/parsers/hydramata/works/predicate_parsers/simple_parser_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_fast_helper'
+require 'hydramata/works/predicate_parsers/simple_parser'
+require 'hydramata/works/linters'
+
+module Hydramata
+  module Works
+    module PredicateParsers
+      describe SimpleParser do
+        it_behaves_like 'a predicate parser'
+
+        context '.call' do
+          let(:object) { double('Object') }
+          it 'makes no effort to to convert the object' do
+            expect { |b| described_class.call(object, &b) }.to yield_with_args(value: object)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/validations_parser_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_fast_helper'
+require 'hydramata/works/validations_parser'
+
+module Hydramata
+  module Works
+    describe ValidationsParser do
+      context '.call' do
+        it 'parses simple JSON' do
+          expect(described_class.call('{"presence": true}')).to eq({ 'presence' => true })
+        end
+
+        it 'returns an empty hash when input is nil' do
+          expect(described_class.call(nil)).to eq({})
+        end
+
+        it 'returns an empty hash when input is an empty string' do
+          expect(described_class.call('')).to eq({})
+        end
+
+        it 'returns the same Hash if one is given' do
+          object = {a: 1}
+          expect(described_class.call(object).object_id).to eq(object.object_id)
+        end
+
+        it 'raises an error on unexpected input' do
+          expect{ described_class.call(Object.new) }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/value_parser_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_fast_helper'
+require 'hydramata/works/value_parser'
+
+module Hydramata
+  module Works
+    describe ValueParser do
+      let(:predicate) { double('Predicate') }
+      let(:value) { double('Value') }
+      let(:a_parser) { double('A Parser', call: true) }
+      let(:parser_finder) { double('Parser Finder', call: a_parser) }
+
+      context '.call' do
+        let(:options) { { predicate: predicate, work_type: 'article', parser_finder: parser_finder, value: value } }
+        it 'coordinate with the parser_finder and calls the found parser' do
+          parsed_value = '1234'
+          expect(a_parser).to receive(:call).with(value).and_yield(value: parsed_value)
+          expect { |b| described_class.call(options, &b) }.to yield_with_args(value: parsed_value)
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/value_parsers/simple_parser_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_fast_helper'
+require 'hydramata/works/value_parsers/simple_parser'
+require 'hydramata/works/linters'
+
+module Hydramata
+  module Works
+    module ValueParsers
+      describe SimpleParser do
+        it_behaves_like 'a value parser'
+
+        context '.call' do
+          let(:object) { double('Object') }
+          it 'makes no effort to to convert the object' do
+            expect { |b| described_class.call(object, &b) }.to yield_with_args(value: object, raw_object: object)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/parsers/hydramata/works/value_parsers_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_fast_helper'
+require 'hydramata/works/value_parsers'
+require 'hydramata/works/predicate'
+
+module Hydramata
+  module Works
+    module ValueParsers
+      class MockParser
+      end
+    end
+    describe ValueParsers do
+      let(:predicate) { Predicate.new(value_parser_name: parser_class_name) }
+
+      context 'existing parser in ValueParsers namespace' do
+        let(:parser_class_name) { 'MockParser' }
+        it 'should use that' do
+          expect(described_class.find(predicate: predicate)).to eq ValueParsers::MockParser
+        end
+      end
+
+      context 'an escaped namespace class' do
+        let(:parser_class_name) { '::Object' }
+        it 'will fallback to the simple parser' do
+          expect(described_class.find(predicate: predicate)).to eq ValueParsers::SimpleParser
+        end
+      end
+
+      context 'a constant not in the namespace' do
+        let(:parser_class_name) { 'MissingParser' }
+        it 'will fallback to the simple parser' do
+          expect(described_class.find(predicate: predicate)).to eq ValueParsers::SimpleParser
+        end
+      end
+    end
+  end
+end

data/spec/presenters/hydramata/works/base_presenter_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_fast_helper'
+require 'hydramata/works/base_presenter'
+
+module Hydramata
+  module Works
+    class MockPresentable
+      attr_accessor :name
+      def initialize
+        yield(self) if block_given?
+      end
+    end
+    describe BasePresenter do
+      let(:name) { 'hello world' }
+      let(:object) { MockPresentable.new { |b| b.name = name } }
+      let(:translator) { double('Translator', t: true) }
+      subject { described_class.new(object, translator: translator) }
+
+      it 'should have #presenter_dom_class' do
+        expect(subject.presenter_dom_class).to eq('base')
+      end
+
+      it 'should return self for #to_presenter' do
+        expect(subject.to_presenter.object_id).to eq(subject.object_id)
+      end
+
+      it 'should have a friendly inspect message, because tracking it down could be a pain' do
+        expect(subject.inspect).to include("#{described_class}")
+        expect(subject.inspect).to include(object.inspect)
+      end
+
+      it 'should be an instance of the presented object\'s class' do
+        expect(subject.instance_of?(object.class)).to be_truthy
+      end
+
+      it 'should also be an instance of the presenter class' do
+        expect(subject.instance_of?(described_class)).to be_truthy
+      end
+
+      it 'should translate attribute keys' do
+        subject.translate(:name)
+        expect(translator).to have_received(:t).with(:name, scopes: [], default: instance_of(Proc))
+      end
+
+      context '#dom_class' do
+        it 'extrapolates based on the named object' do
+          expect(subject.dom_class).to eq('hello-world')
+        end
+
+        it 'allows a prefix' do
+          expect(subject.dom_class(prefix: 'edit')).to eq('edit-hello-world')
+        end
+
+        it 'allows a suffix' do
+          expect(subject.dom_class(suffix: '1')).to eq('hello-world-1')
+        end
+
+        it 'allows a prefix and a suffix' do
+          expect(subject.dom_class(prefix: 'edit', suffix: '1')).to eq('edit-hello-world-1')
+        end
+      end
+
+      context '#render' do
+        let(:template) { double('Template', render: true)}
+
+        it 'should delegate render to the template' do
+          subject.render(template: template)
+          expect(template).to have_received(:render).with(partial: 'hydramata/works/base/show', object: subject)
+        end
+
+        it 'should handle a partial_prefixes rendering in less and less specificity' do
+          subject = described_class.new(object, translator: translator, partial_prefixes: ['article/required', 'article'], presentation_context: 'show', template_missing_exception: [RuntimeError, NoMethodError])
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/article/required/show', object: subject).
+            ordered.
+            and_raise(NoMethodError)
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/article/show', object: subject).
+            ordered.
+            and_raise(RuntimeError)
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/show', object: subject).
+            ordered
+          subject.render(template: template)
+        end
+
+        it 'should stop rendering chain once we sucessfully render a template' do
+          subject = described_class.new(object, translator: translator, partial_prefixes: ['article/required', 'article'], presentation_context: 'show', template_missing_exception: [RuntimeError, NoMethodError])
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/article/required/show', object: subject).
+            ordered.
+            and_raise(NoMethodError)
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/article/show', object: subject).
+            ordered
+          expect(template).to_not receive(:render).
+            with(partial: 'hydramata/works/base/show', object: subject)
+          subject.render(template: template)
+        end
+
+        it 'should raise exception if we are rendering as general as possible' do
+          subject = described_class.new(object, translator: translator, presentation_context: 'show')
+          expect(template).to receive(:render).
+            with(partial: 'hydramata/works/base/show', object: subject).
+            and_raise(RuntimeError)
+          expect { subject.render(template: template) }.
+            to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
+end

data/spec/presenters/hydramata/works/dom_attributes_builder_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_fast_helper'
+require 'hydramata/works/dom_attributes_builder'
+
+module Hydramata
+  module Works
+    describe DomAttributesBuilder do
+      let(:context) { double }
+
+      it 'should append attributes' do
+        response = described_class.call(context, { class: ['hello'] }, { class: ['world'] } )
+        expect(response).to eq({ class: ['hello', 'world'] })
+      end
+
+      it 'should handle mixed array and string' do
+        response = described_class.call(context, { class: 'hello' }, { class: ['world'] } )
+        expect(response).to eq({ class: ['hello', 'world'] })
+      end
+
+      it 'should add new keys to returned value' do
+        response = described_class.call(context, { data_attribute: ['hello'] }, { class: ['world'] } )
+        expect(response).to eq({ data_attribute: ['hello'], class: ['world'] })
+      end
+
+    end
+  end
+end

data/spec/presenters/hydramata/works/entity_presenter_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_fast_helper'
+require 'hydramata/works/entity_presenter'
+require 'hydramata/works/entity'
+require 'hydramata/works/linters'
+
+module Hydramata
+  module Works
+    describe EntityPresenter do
+      it_behaves_like 'a presented entity'
+
+      let(:presentation_structure) { double('PresentationStructure') }
+      let(:entity) { Entity.new(work_type: 'My Work Type') }
+      let(:presented_fieldset_builder) { double('Builder', call: true) }
+      let(:template) { double('Template', render: true) }
+      subject do
+        described_class.new(
+          entity: entity,
+          presentation_structure: presentation_structure,
+          presented_fieldset_builder: presented_fieldset_builder,
+          template_missing_exception: [RuntimeError]
+        )
+      end
+
+      it 'should have #container_content_tag_attributes' do
+        expect(subject.container_content_tag_attributes.keys).to eq([:class, :itemscope, :itemtype])
+      end
+
+      it 'should have #fieldsets that are extracted from the #entity and #presentation_structure' do
+        subject.fieldsets
+        expect(presented_fieldset_builder).to have_received(:call).with(entity: subject, presentation_structure: presentation_structure)
+      end
+
+      it 'should have a default partial prefixes' do
+        expect(subject.partial_prefixes).to eq([['my_work_type']])
+      end
+
+      it 'should render as per the template' do
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/works/my_work_type/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/works/show', object: subject).
+          ordered.
+          and_return('YES')
+        expect(subject.render(template: template)).to eq('YES')
+      end
+
+    end
+  end
+end