hydramata-works 0.0.1.prerelease

data/lib/hydramata/works/conversions/predicate_set.rb

@@ -0,0 +1,28 @@
+require 'hydramata/works/conversions/exceptions'
+require 'hydramata/works/predicate_set'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def PredicateSet(input)
+        return input.to_predicate_set if input.respond_to?(:to_predicate_set)
+        case input
+        when PredicateSet then input
+        when Hash then PredicateSet.new(input)
+        when String then PredicateSet.new(identity: input)
+        when Array then
+          case input.size
+          when 0 then raise ConversionError.new(:PredicateSet, input)
+          when 1 then PredicateSet.new(identity: input[0])
+          when 2 then PredicateSet.new(identity: input[0], predicates: input[1])
+          else
+            PredicateSet.new(identity: input[0], predicates: input[1..-1])
+          end
+        else
+          raise ConversionError.new(:PredicateSet, input)
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/presented_fieldsets.rb

@@ -0,0 +1,28 @@
+require 'hydramata/works/conversions/property_set'
+require 'hydramata/works/conversions/predicate_set'
+require 'hydramata/works/fieldset_presenter'
+module Hydramata
+  module Works
+    module Conversions
+      def PresentedFieldsets(collaborators)
+        # @TODO - This could be packaged up into a tidier location.
+        # The collaboration with an entity's PropertySet#subset is convoluted.
+        # I also don't know if I need.
+        entity = collaborators.fetch(:entity)
+        presentation_structure = collaborators.fetch(:presentation_structure)
+        presentation_structure.fieldsets.each_with_object([]) do |predicate_set, collector|
+          predicate_set = PredicateSet(predicate_set)
+          predicates = predicate_set.predicates
+          property_set = PropertySet(predicate_set)
+          property_builder = ->(property) {
+            require 'hydramata/works/property_presenter'
+            PropertyPresenter.new(property: property, fieldset: property_set, entity: entity)
+          }
+          entity.properties.subset(predicates, property_set, property_builder)
+          presented_fieldset = FieldsetPresenter.new(entity: entity, fieldset: property_set)
+          collector << presented_fieldset
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/presenter.rb

@@ -0,0 +1,13 @@
+require 'hydramata/works/conversions/exceptions'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def Presenter(input)
+        return input.to_presenter if input.respond_to?(:to_presenter)
+        input
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/property.rb

@@ -0,0 +1,31 @@
+require 'hydramata/works/conversions/exceptions'
+require 'hydramata/works/property'
+require 'hydramata/works/conversions/predicate'
+require 'hydramata/works/predicate'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def Property(*args)
+        if args.size == 0
+          raise ConversionError.new(:Property, args)
+        else
+          input = args.first
+          property =
+          case input
+          when Property then input
+          when Predicate then Property.new(predicate: input)
+          when Hash then Property.new(input)
+          else
+            predicate = Predicate(input)
+            Property.new(predicate: predicate)
+          end
+          values = args[1..-1]
+          property << values
+          property
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/property_set.rb

@@ -0,0 +1,23 @@
+require 'hydramata/works/conversions/exceptions'
+require 'hydramata/works/conversions/predicate_set'
+require 'hydramata/works/predicate_set'
+require 'hydramata/works/property_set'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def PropertySet(input)
+        return input.to_property_set if input.respond_to?(:to_property_set)
+
+        case input
+        when PropertySet then input
+        when PredicateSet then PropertySet.new(predicate_set: input)
+        else
+          predicate_set = PredicateSet(input)
+          PropertySet(predicate_set)
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/translation_key_fragment.rb

@@ -0,0 +1,20 @@
+require 'hydramata/works/conversions/exceptions'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def TranslationKeyFragment(input)
+        return input.to_translation_key_fragment.to_s.downcase.gsub(/\W+/, '_') if input.respond_to?(:to_translation_key_fragment)
+        case input
+        when String, Symbol then input.to_s.downcase.gsub(/\W+/, '_')
+        when Hash then
+          value = input[:to_translation_key_fragment] || input['to_translation_key_fragment']
+          TranslationKeyFragment(value)
+        else
+          raise ConversionError.new(:TranslationKeyFragment, input)
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/value.rb

@@ -0,0 +1,20 @@
+require 'hydramata/works/conversions/exceptions'
+require 'hydramata/works/value'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def Value(input)
+        return input.to_value if input.respond_to?(:to_value)
+        case input
+        when Value then input
+        when Hash then Value.new(input)
+        when String, Symbol then Value.new(value: input)
+        else
+          raise ConversionError.new(:Value, input)
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/conversions/work_type.rb

@@ -0,0 +1,26 @@
+require 'hydramata/works/conversions/exceptions'
+require 'hydramata/works/work_type'
+require 'hydramata/works/work_types'
+
+module Hydramata
+  module Works
+    module Conversions
+      private
+      def WorkType(input = nil)
+        return input.to_work_type if input.respond_to?(:to_work_type)
+        case input
+        when WorkType then input
+        when String, Symbol then WorkTypes.find(input)
+        when Hash then WorkTypes.find(input.fetch(:identity), input)
+        when NilClass then WorkType.new(identity: 'unknown')
+        else
+          if input.respond_to?(:empty?) && input.empty?
+            WorkType.new(identity: 'unknown')
+          else
+            raise ConversionError.new(:WorkType, input)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hydramata/works/engine.rb

@@ -0,0 +1,31 @@
+module Hydramata
+  module Works
+    # Hydramata::Works is a [Rails::Engine](http://guides.rubyonrails.org/engines.html)
+    #
+    # These are the pieces necessary for coordinating the Hydramata::Works with
+    # your instance of a Rails application.
+    class Engine < ::Rails::Engine
+      engine_name 'hydramata_works'
+
+      if config.respond_to?(:eager_load_namespaces)
+        # SimpleForm did this, so I'm thinking that I will do it.
+        config.eager_load_namespaces << Hydramata::Works
+      end
+
+      initializer 'hydramata_works.initializers' do |app|
+        app.config.paths.add 'app/renderers', eager_load: true
+        app.config.paths.add 'app/presenters', eager_load: true
+        app.config.paths.add 'app/forms', eager_load: true
+        app.config.paths.add 'app/parsers', eager_load: true
+        app.config.paths.add 'app/wranglers', eager_load: true
+        app.config.autoload_paths += %W(
+          #{config.root}/app/renderers
+          #{config.root}/app/forms
+          #{config.root}/app/presenters
+          #{config.root}/app/parsers
+          #{config.root}/app/wranglers
+        )
+      end
+    end
+  end
+end

data/lib/hydramata/works/linters.rb

@@ -0,0 +1,99 @@
+shared_examples 'a presented entity' do |default_presented_entity_class|
+  let(:presented_entity_class) { (default_presented_entity_class || described_class) }
+  it 'responds to #fieldsets' do
+    expect { presented_entity_class.instance_method(:fieldsets) }.
+      to_not raise_error
+  end
+end
+
+shared_examples 'a datastream parser' do |default_parser|
+  let(:parser) { default_parser || described_class }
+  it 'responds to .call' do
+    expect(parser).to respond_to(:call)
+  end
+
+  it 'responds to .match?' do
+    expect(parser).to respond_to(:match?)
+  end
+
+  context 'its .call method' do
+    it 'has a required first parameter' do
+      expect(parser.method(:call).parameters.first[0]).to eq(:req)
+    end
+    it 'takes a block' do
+      expect(parser.method(:call).parameters.last[1]).to eq(:block)
+    end
+  end
+end
+
+shared_examples 'a predicate parser' do |default_parser|
+  let(:parser) { default_parser || described_class }
+  it 'responds to #call' do
+    expect(parser).to respond_to(:call)
+  end
+
+  context 'its #call method' do
+    it 'has a required first parameter' do
+      expect(parser.method(:call).parameters.first[0]).to eq(:req)
+    end
+    it 'takes a block' do
+      expect(parser.method(:call).parameters.last[1]).to eq(:block)
+    end
+  end
+end
+
+shared_examples 'a value parser' do |default_parser|
+  let(:parser) { default_parser || described_class }
+  it 'responds to #call' do
+    expect(parser).to respond_to(:call)
+  end
+
+  context 'its #call method' do
+    it 'has a required first parameter' do
+      expect(parser.method(:call).parameters.first[0]).to eq(:req)
+    end
+    it 'takes a block' do
+      expect(parser.method(:call).parameters.last[1]).to eq(:block)
+    end
+  end
+end
+
+shared_examples_for 'ActiveModel' do
+  # From the ActiveModel::Lint::Test model
+  it 'implements #to_key' do
+    expect(subject).to respond_to(:to_key)
+    def subject.persisted?() false end
+    expect(subject.to_key).to be_nil
+  end
+
+  it 'implements #to_param' do
+    expect(subject).to respond_to(:to_param)
+    def subject.to_key() [1] end
+    def subject.persisted?() false end
+    expect(subject.to_param).to be_nil
+  end
+
+  it 'implements #to_partial_path' do
+    expect(subject).to respond_to(:to_partial_path)
+    expect(subject.to_partial_path).to be_a_kind_of(String)
+  end
+
+  it 'implements #persisted?' do
+    expect(subject).to respond_to(:persisted?)
+    expect([true, false]).to include(subject.persisted?)
+  end
+
+  it 'implements .model_naming' do
+    expect(subject.class).to respond_to(:model_name)
+    model_name = subject.class.model_name
+    expect(model_name).to respond_to(:to_str)
+    expect(model_name.human).to respond_to(:to_str)
+    expect(model_name.singular).to respond_to(:to_str)
+    expect(model_name.plural).to respond_to(:to_str)
+  end
+
+  it 'implements #errors' do
+    expect(subject).to respond_to(:errors)
+    expect(subject.errors[:hello]).to be_an_instance_of(Array)
+  end
+end

data/lib/hydramata/works/linters/implement_data_definition_interface_matcher.rb

@@ -0,0 +1,17 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_data_definition_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self,
+    'DataDefinition',
+    [
+      :identity,
+      :identity=,
+      :name_for_application_usage,
+      '<=>',
+      :to_sym,
+      :name_for_application_usage=
+    ]
+  )
+end

data/lib/hydramata/works/linters/implement_entity_interface_matcher.rb

@@ -0,0 +1,16 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_entity_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self,
+    'Entity',
+    properties: [:<<, :each, :fetch, :[]],
+    has_property?: [],
+    name_for_application_usage: [],
+    work_type: [],
+    identity: [],
+    to_translation_key_fragment: [],
+    itemtype_schema_dot_org: []
+  )
+end

data/lib/hydramata/works/linters/implement_predicate_interface_matcher.rb

@@ -0,0 +1,17 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_predicate_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self,
+    'Predicate',
+    identity: [],
+    name_for_application_usage: [],
+    datastream_name: [],
+    value_coercer_name: [],
+    value_parser_name: [],
+    validations: [],
+    indexing_strategy: [],
+    itemprop_schema_dot_org: []
+  )
+end

data/lib/hydramata/works/linters/implement_predicate_set_interface_matcher.rb

@@ -0,0 +1,8 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_predicate_set_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self, 'PredicateSet', [:work_type, :identity, :presentation_sequence, :name_for_application_usage, :predicates]
+  )
+end

data/lib/hydramata/works/linters/implement_property_set_interface_matcher.rb

@@ -0,0 +1,8 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_property_set_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self, 'PropertySet', [:<<, :[], :predicates, :fetch, :==, :each, :subset]
+  )
+end

data/lib/hydramata/works/linters/implement_value_interface_matcher.rb

@@ -0,0 +1,8 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_value_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self, 'Value', [:raw_object]
+  )
+end

data/lib/hydramata/works/linters/implement_work_type_interface_matcher.rb

@@ -0,0 +1,13 @@
+require 'rspec/matchers'
+require 'hydramata/works/linters/interface_matcher_builder'
+
+RSpec::Matchers.define :implement_work_type_interface do
+  Hydramata::Works::Linters::InterfaceMatcherBuilder.call(
+    self,
+    'WorkType',
+    identity: [],
+    name_for_application_usage: [],
+    predicate_sets: [:each],
+    itemtype_schema_dot_org: []
+  )
+end

data/lib/hydramata/works/linters/interface_matcher_builder.rb

@@ -0,0 +1,36 @@
+module Hydramata
+  module Works
+    module Linters
+      module InterfaceMatcherBuilder
+        module_function
+        def call(context, input_klass_name, input_method_names)
+          context.instance_exec(input_klass_name, input_method_names) do |klass_name, method_names|
+            match do |subject|
+              returning_value = method_names.all? do |(method_name, second_level_methods)|
+                subject.respond_to?(method_name) &&
+                Array(second_level_methods).all? do |second_level_method|
+                  subject.public_send(method_name).respond_to?(second_level_method)
+                end
+              end && method_expectations.all? do |method_name, value|
+                subject.public_send(method_name) == value
+              end
+              returning_value
+            end
+
+            chain :with do |method_name, value|
+              method_expectations[method_name] = value
+            end
+
+            description { "implemenent the #{input_klass_name} interface" }
+          end
+
+          context.module_exec do
+            def method_expectations
+              @method_expectations ||= {}
+            end
+          end
+        end
+      end
+    end
+  end
+end