hydramata-works 0.0.1.prerelease

data/spec/fixtures/translations.yml

@@ -0,0 +1,20 @@
+en:
+  hydramata:
+    work:
+      works:
+        work_type_with_translated_name:
+          name: I Am Translating the Name for Application Usage!
+        work_type_translated:
+          fieldsets:
+            property_set_translated:
+              name: I Am a Translated Property Set for a Translated Work Type!
+          properties:
+            property_translated:
+              name: I Am a Translated Property for a Translated Work Type!
+          name: I Am a Translated Work Type!
+      fieldsets:
+        property_set_translated:
+          name: I Am a Translated Property Set with a non-Translated Work Type!
+      properties:
+        property_translated:
+          name: I Am a Translated Property with a non-Translated Work Type!

data/spec/forms/hydramata/works/entity_form_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_fast_helper'
+require 'hydramata/works/entity_form'
+require 'hydramata/works/linters'
+require 'hydramata/works/entity'
+
+module Hydramata
+  module Works
+    describe EntityForm do
+      let(:identity) { nil }
+      let(:validation_service) { double(call: true) }
+      let(:entity) do
+        Entity.new(identity: identity) do |entity|
+          entity.properties << { predicate: :first_name, value: 'Jeremy' }
+        end
+      end
+      subject { described_class.new(entity, validation_service: validation_service) }
+
+      it_behaves_like 'ActiveModel'
+
+      context 'valid?' do
+        context 'when errors are not set' do
+          let(:validation_service) { double(call: true) }
+          it 'should be true (eg valid)' do
+            expect(subject.valid?).to be_truthy
+            expect(validation_service).to have_received(:call)
+          end
+        end
+        context 'when errors are encountered' do
+          let(:validation_service) { ->(entity) { entity.errors.add(:base, 'Found some errors!') } }
+          it 'should be false (eg not valid)' do
+            expect(subject.valid?).to be_falsey
+          end
+        end
+      end
+
+      it 'has a meaningful inspect' do
+        expect(subject.inspect).to include("EntityForm")
+        expect(subject.inspect).to include(entity.inspect)
+      end
+
+      context 'entity\'s properties' do
+        it 'should respond to a given predicate' do
+          expect(subject).to respond_to(:first_name)
+        end
+
+        it 'should expose the predicate name as a method' do
+          expect(subject.first_name).to eq(['Jeremy'])
+        end
+      end
+
+      context 'with collaborating entity without an identity' do
+        let(:identity) { '' }
+        it 'is not #persisted?' do
+          expect(subject.persisted?).to be_falsey
+        end
+
+        it 'has a nil #to_param' do
+          expect(subject.to_param).to be_nil
+        end
+
+        it 'has a nil #to_key' do
+          expect(subject.to_key).to be_nil
+        end
+      end
+
+      context 'with collaborating entity with an identity' do
+        let(:identity) { '1234' }
+        it 'is #persisted?' do
+          expect(subject.persisted?).to be_truthy
+        end
+
+        it 'uses the entity#identity to derive #to_param' do
+          expect(subject.to_param).to eq(identity)
+        end
+
+        it 'uses the entity#identity to derive #to_key' do
+          expect(subject.to_key).to eq([identity])
+        end
+
+      end
+    end
+  end
+end

data/spec/forms/hydramata/works/validation_service_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_fast_helper'
+require 'hydramata/works/validation_service'
+require 'hydramata/works/entity_form'
+require 'hydramata/works/predicate'
+require 'hydramata/works/entity'
+require 'active_model/validations/presence'
+
+module Hydramata
+  module Works
+    describe ValidationService do
+      let(:title) { nil }
+      let(:title_predicate) { Predicate.new(identity: 'title', validations: { presence: true }) }
+      let(:entity) do
+        Entity.new(work_type: 'article') do |entity|
+          entity.properties << { predicate: title_predicate }
+        end
+      end
+      let(:entity_form) { EntityForm.new(entity) }
+      subject { described_class }
+
+      context '#call' do
+        it 'runs validations attached to each predicate' do
+          expect { subject.call(entity_form) }.
+            to change { entity_form.errors.full_messages }.
+            from([]).
+            to(['title can\'t be blank'])
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/hydramata-work_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_fast_helper'
+require 'hydramata-works'
+
+module Hydramata
+  describe Works do
+    it 'has a .table_name_prefix to conform to Rails::Engine' do
+      expect(described_class.table_name_prefix).to eq('hydramata_works_')
+    end
+
+    it 'has a .use_relative_model_naming? to conform to Rails::Engine' do
+      expect(described_class.use_relative_model_naming?).to eq(true)
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/predicate_set_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/predicate_set'
+require 'hydramata/works/linters/implement_predicate_set_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#PredicateSet' do
+        it 'should convert a "well-formed" Hash to a PredicateSet object' do
+          expect(PredicateSet(identity: 'hello', work_type: 'Work Type')).to implement_predicate_set_interface
+        end
+
+        it 'should raise an error if the Hash is not "well-formed"' do
+          expect { PredicateSet(other: 'hello') }.to raise_error
+        end
+
+        it 'should raise an error when input is unexpected' do
+          expect { PredicateSet(double) }.to raise_error
+        end
+
+        it 'should raise an error when Array is empty' do
+          expect { PredicateSet([]) }.to raise_error
+        end
+
+        it 'should handle an Array of 2 elements' do
+          expect(PredicateSet([:fieldset, [:predicate1, :predicate2]])).to implement_predicate_set_interface
+        end
+
+        it 'should handle an Array of 3 elements' do
+          expect(PredicateSet([:fieldset, :predicate1, :predicate2])).to implement_predicate_set_interface
+        end
+
+        it 'should handle an Array of 1 element' do
+          expect(PredicateSet([:fieldset])).to implement_predicate_set_interface
+        end
+
+        it 'should handle a String' do
+          expect(PredicateSet('An Identity')).to implement_predicate_set_interface
+        end
+
+        it 'should use #to_predicate_set for conversion if input responds to #to_predicate_set' do
+          object = double(to_predicate_set: PredicateSet.new(identity: 'hello'))
+          expect(PredicateSet(object)).to implement_predicate_set_interface
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/predicate_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/predicate'
+require 'hydramata/works/linters/implement_predicate_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#Predicate' do
+        it 'should convert a String to a Predicate object' do
+          expect(Predicate('hello')).to implement_predicate_interface
+        end
+
+        it 'should convert a Symbol to a Predicate object' do
+          expect(Predicate(:hello)).to implement_predicate_interface
+        end
+
+        it 'should return the same predicate if a Predicate is given' do
+          predicate = Predicate(:hello)
+          expect(Predicate(predicate).object_id).to eq(predicate.object_id)
+        end
+
+        it 'should convert a "well-formed" Hash to a Predicate object' do
+          expect(Predicate(identity: 'hello')).to implement_predicate_interface
+        end
+
+        it 'should raise an error if the Hash is not "well-formed"' do
+          expect { Predicate(other: 'hello') }.to raise_error
+        end
+
+        it 'should raise an error object is unexpected' do
+          expect { Predicate([]) }.to raise_error
+        end
+
+        it 'should converate an object that responds to #to_predicate to a predicate' do
+          object = double(to_predicate: Predicate.new)
+          expect(Predicate(object)).to implement_predicate_interface
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/presented_fieldsets_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_fast_helper'
+require 'hydramata/works/entity'
+require 'hydramata/works/presentation_structure'
+require 'hydramata/works/conversions/presented_fieldsets'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#PresentedFieldsets' do
+        let(:entity) do
+          Entity.new.tap do |entity|
+            entity.work_type = 'Hello'
+            entity.properties << { predicate: :title, value: 'Hello' }
+            entity.properties << { predicate: :title, value: 'World' }
+            entity.properties << { predicate: :title, value: 'Bang!' }
+            entity.properties << { predicate: :abstract, value: 'Long Text' }
+            entity.properties << { predicate: :abstract, value: 'Longer Text' }
+            entity.properties << { predicate: :keyword, value: 'Programming' }
+          end
+        end
+
+        let(:presentation_structure) do
+          PresentationStructure.new.tap do |struct|
+            struct.fieldsets << [:required, [:title]]
+            struct.fieldsets << [:optional, [:abstract, :keyword]]
+          end
+        end
+
+        it 'should munge together the presentation structure and entity' do
+          presented_fieldsets = PresentedFieldsets(entity: entity, presentation_structure: presentation_structure)
+
+          expect(presented_fieldsets.count).to eq(2)
+
+          required_fieldset = presented_fieldsets[0]
+          expect(required_fieldset.entity).to eq(entity)
+          expect(required_fieldset.count).to eq(1)
+          expect(required_fieldset.name.to_s).to eq('required')
+          expect(required_fieldset[:title].values).to eq(['Hello', 'World', 'Bang!'])
+
+          optional_fieldset = presented_fieldsets[1]
+          expect(optional_fieldset.entity).to eq(entity)
+          expect(optional_fieldset.count).to eq(2)
+          expect(optional_fieldset.name.to_s).to eq('optional')
+          expect(optional_fieldset[:abstract].values).to eq(['Long Text', 'Longer Text'])
+          expect(optional_fieldset[:keyword].values).to eq(['Programming'])
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/presenter_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/presenter'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#Presenter' do
+        it 'converts an object that implements #to_presenter' do
+          object = double(to_presenter: :presenter)
+          expect(Presenter(object)).to eq(:presenter)
+        end
+
+        it 'does not convert an object that does not implement a #to_presenter' do
+          object = double
+          expect(Presenter(object)).to eq(object)
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/property_set_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/property_set'
+require 'hydramata/works/conversions/predicate_set'
+require 'hydramata/works/linters/implement_property_set_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#PropertySet' do
+        it 'should convert an object that implements #to_property_set' do
+          object = double('Object', to_property_set: PropertySet.new )
+          expect(PropertySet(object)).to implement_property_set_interface
+        end
+
+        it 'should raise an error object is unexpected' do
+          expect { PropertySet([]) }.to raise_error
+        end
+
+        it 'should convert a PredicateSet to a PropertySet' do
+          object = PredicateSet.new(identity: 'hello')
+          expect(PropertySet(object)).to implement_property_set_interface
+        end
+
+        it 'should preserive a PropertySet as that PropertySet' do
+          object = PropertySet.new(identity: 'hello')
+          expect(PropertySet(object).object_id).to eq(object.object_id)
+        end
+
+        it 'should attempt to convert the input to a PredicateSet then a PropertySet' do
+          object_to_convert = { identity: 'hello' }
+          expect(self).
+            to receive(:PredicateSet).
+            with(object_to_convert).
+            and_call_original
+          expect(PropertySet(object_to_convert)).to implement_property_set_interface
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/property_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/property'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#Property' do
+
+        context 'with 0 args' do
+          it 'should raise an error' do
+            expect { Property() }.to raise_error
+          end
+        end
+
+        context 'with 1 arg' do
+          it 'should convert a Predicate to a Property' do
+            predicate = Predicate.new(identity: 'id')
+            expect(Property(predicate)).to be_an_instance_of(Property)
+          end
+
+          it 'should attempt to convert something odd to a Property via a Predicate conversion' do
+            object_to_convert = double
+            expect(self).
+              to receive(:Predicate).
+              with(object_to_convert).
+              and_return(Predicate.new)
+            expect(Property(object_to_convert)).to be_an_instance_of(Property)
+          end
+
+          it 'should preserve a Property' do
+            property = Property.new(predicate: 'a predicate')
+            expect(Property(property).object_id).to eq(property.object_id)
+          end
+
+          it 'should convert a Hash to a property' do
+            expect(Property(predicate: 'a predicate')).to be_an_instance_of(Property)
+          end
+
+          it 'should convert a Hash with values' do
+            expect(Property(predicate: 'a predicate', values: [1,2,3]).values).to eq([1,2,3])
+          end
+        end
+
+        context 'with 2 args' do
+          it 'should convert two arguements to a Property' do
+            expect(Property('a predicate', 'a value')).to be_an_instance_of(Property)
+          end
+
+          it 'should gracefully handle two arguements where last arguement is an array' do
+            expect(Property('a predicate', ['a value']).values).to eq([['a value']])
+          end
+
+          it 'should preserve the property but append the values' do
+            property = Property.new(predicate: 'a predicate')
+            expect {
+              Property(property, 'hello')
+            }.
+              to change { property.values }.
+              from([]).
+              to(['hello'])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/translation_key_fragment_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/translation_key_fragment'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+      context 'TranslationKeyFragment' do
+        context 'successfully converts' do
+          it 'a String' do
+            expect(TranslationKeyFragment('hello')).to eq('hello')
+          end
+
+          it 'to a normalized format' do
+            expect(TranslationKeyFragment('Hello World: Welcome')).to eq('hello_world_welcome')
+          end
+
+          it 'a Symbol' do
+            expect(TranslationKeyFragment(:hello)).to eq('hello')
+          end
+
+          it 'a Hash with :to_translation_key_fragment key' do
+            object = { to_translation_key_fragment: 'fragment' }
+            expect(TranslationKeyFragment(object)).to eq('fragment')
+          end
+
+          it 'an object that implements #to_translation_key_fragment' do
+            object = double(to_translation_key_fragment: 'fragment')
+            expect(TranslationKeyFragment(object)).to eq('fragment')
+          end
+        end
+
+        context 'will not convert' do
+          it 'an unexpected object' do
+            expect { TranslationKeyFragment(double) }.to raise_error
+          end
+
+          it 'nil' do
+            expect { TranslationKeyFragment(nil) }.to raise_error
+          end
+        end
+      end
+    end
+  end
+end