hydramata-works 0.0.1.prerelease

data/VISION.md

@@ -0,0 +1,19 @@
+## Hydramata::Works's Vision
+
+[CurateND](http://curate.nd.edu) allows for the uploading five Work types: Article, Dataset, Document, Image, and Senior Thesis.
+Four of the five Work Types (not including Senior Thesis) have their metadata attributes defined in an [application profile](http://ndlib.github.io/metadata_application_profile/templates/). There is a lot of overlap regarding the metadata elements that are rendered.
+
+One of the goals of the Hydramata::Works project is to allow institutions to create arbitrary Work types that are somewhat arbitrarily comprised of well-defined metadata element predicates.
+These predicates can be defined in [various ontologies](http://en.wikipedia.org/wiki/Ontology_(information_science)). Examples include [Dublin Core](http://dublincore.org/documents/dcmi-terms/), [Friend of a Friend](http://www.foaf-project.org/), [schema.org](http://schema.org/docs/schemas.html), etc.
+
+Predicates can be complex in nature. Consider a "name" predicate. It could be comprised of "given_name", "surname", and several other elements [see Personal Names Around the World](http://www.w3.org/International/questions/qa-personal-names).
+
+The Hydramata::Works project is positioning to allow for:
+
+* The dynamic creation of different work types
+* Assigning suggested predicates to the work types
+* And declaring a recommended presentation structure for the work types
+* Expose defaults for predicate values within a work type context
+* Expose validation for predicate values
+
+At present, the core functionality is being built out.

data/app/forms/hydramata/works/entity_form.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+require 'active_model/naming'
+require 'hydramata/works/conversions/translation_key_fragment'
+
+module Hydramata
+  module Works
+    class EntityForm < SimpleDelegator
+      include Conversions
+      def initialize(entity, collaborators = {})
+        __setobj__(entity)
+        @errors = collaborators.fetch(:error_container) { default_error_container }
+        @validation_service = collaborators.fetch(:validation_service) { default_validation_service }
+      end
+
+      attr_reader :errors, :validation_service
+
+      def valid?
+        validate
+        errors.size == 0
+      end
+
+      def to_key
+        persisted? ? [identity] : nil
+      end
+
+      def to_param
+        persisted? ? identity : nil
+      end
+
+      def to_partial_path
+        # @TODO - need to figure out what this should be
+        ''
+      end
+
+      def persisted?
+        identity.present?
+      end
+
+      # Needed for Validator interaction
+      def self.human_attribute_name(attr, options = {})
+        attr
+      end
+
+      def self.model_name
+        # @TODO - allow overwrite of the ActiveModel::Name, which may require
+        # overwriting #class to be something else.
+        @_model_name ||= ActiveModel::Name.new(self, Hydramata::Works)
+      end
+
+      # Needed for Validator interaction
+      def read_attribute_for_validation(attribute_name)
+        send(TranslationKeyFragment(attribute_name))
+      end
+
+      def inspect
+        format('#<%s:%#0x entity=%s>', EntityForm, __id__, __getobj__.inspect)
+      end
+
+      private
+
+      def respond_to_missing?(method_name, include_all = false)
+        super || __getobj__.has_property?(method_name)
+      end
+
+      def method_missing(method_name, *args, &block)
+        if __getobj__.has_property?(method_name)
+          # @TODO - The Law of Demeter is being violated.
+          __getobj__.properties.fetch(method_name).values
+        else
+          super
+        end
+      end
+
+      def default_error_container
+        require 'active_model/errors'
+        ActiveModel::Errors.new(self)
+      end
+
+      def default_validation_service
+        require 'hydramata/works/validation_service'
+        ValidationService
+      end
+
+      def validate
+        validation_service.call(self)
+      end
+
+    end
+  end
+end

data/app/forms/hydramata/works/validation_service.rb

@@ -0,0 +1,78 @@
+require 'active_support/core_ext/array/wrap'
+
+module Hydramata
+  module Works
+    class ValidationService
+      def self.call(entity)
+        new(entity).call
+      end
+
+      attr_reader :entity, :validator_namespaces
+      def initialize(entity, collaborators = {})
+        @entity = entity
+        self.validator_namespaces = collaborators.fetch(:validator_namespaces) { default_validator_namespaces }
+      end
+
+      def call
+        # @TODO - This is an awful lot of information about the validation
+        # structure.
+        entity.properties.each do |property|
+          predicate = property.predicate
+          predicate.validations.each do |validator_name, options|
+            validate(predicate, validator_name, options)
+          end
+        end
+        nil
+      end
+
+      private
+
+      def validate(predicate, validator_name, options)
+        return unless options
+        validator = validator_for(validator_name)
+        validation_options = parse_validates_options(options)
+        validation_options[:attributes] = predicate
+        validator.new(validation_options).validate(entity)
+      end
+
+      def validator_for(validator_name)
+        validator_class_name = "#{validator_name.to_s.camelize}Validator"
+        validator = nil
+        validator_namespaces.each do |namespace|
+          begin
+            validator = "#{namespace}::#{validator_class_name}".constantize
+            break
+          rescue NameError
+            next
+          end
+        end
+        validator || validator_class_name.constantize
+      end
+
+      # Cribbed from ActiveModel::Validations#_parse_validates_options
+      # in Rails 4.0.x and 4.1.x
+      def parse_validates_options(options)
+        case options
+        when TrueClass
+          {}
+        when Hash
+          options
+        when Range, Array
+          { :in => options }
+        else
+          { :with => options }
+        end
+      end
+
+      def default_validator_namespaces
+        require 'active_model/validations'
+        ActiveModel::Validations
+      end
+
+      def validator_namespaces=(names)
+        @validator_namespaces = Array.wrap(names)
+      end
+
+    end
+  end
+end

data/app/models/hydramata/works/data_definition.rb

@@ -0,0 +1,57 @@
+module Hydramata
+  module Works
+
+    # DataDefinition is an abstract class for the Plain Old Ruby Objects (PORO)
+    # that are loaded from the database storage. The irony that I am using
+    # inheritance for these POROs is not lost on me.
+    class DataDefinition
+      include Comparable
+
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          self.send("#{key}=", value.freeze) if respond_to?("#{key}=")
+        end
+        yield self if block_given?
+        validate!
+        self.freeze
+      end
+
+      attr_writer :name_for_application_usage
+      def name_for_application_usage
+        @name_for_application_usage || identity
+      end
+
+      def to_translation_key_fragment
+        name_for_application_usage
+      end
+
+      attr_reader :identity
+      def identity=(value)
+        @identity = value.to_s
+      end
+
+      def to_s
+        identity
+      end
+
+      def to_sym
+        to_translation_key_fragment.to_sym
+      end
+
+      def <=>(other)
+        if other.instance_of?(self.class)
+          identity <=> other.identity
+        else
+          nil
+        end
+      end
+
+      private
+
+      def validate!
+        true
+      end
+    end
+  end
+end

data/app/models/hydramata/works/entities.rb

@@ -0,0 +1,11 @@
+require 'hydramata/works/entity'
+module Hydramata
+  module Works
+    module Entities
+      module_function
+      def find(identifier)
+        Entity.new(identifier: identifier)
+      end
+    end
+  end
+end

data/app/models/hydramata/works/entity.rb

@@ -0,0 +1,75 @@
+require 'hydramata/works/conversions'
+module Hydramata
+  module Works
+    # Responsible for being the in ruby representation of a set of Properties.
+    #
+    # Unlike the [ActiveRecord pattern](http://www.martinfowler.com/eaaCatalog/activeRecord.html),
+    # there is no direct connection to a data storage. This is instead analogous
+    # to the Entity of the [DataMapper pattern](http://www.martinfowler.com/eaaCatalog/dataMapper.html)
+    # as implemented in [Lotus::Models](https://github.com/lotus/model#entities).
+    #
+    # Unlike a Lotus::Model, the Work is an arbitrary collection of Property
+    # objects, as defined in the PropertySet.
+    class Entity
+      include Conversions
+
+      def initialize(collaborators = {}, &block)
+        self.work_type = collaborators[:work_type] if collaborators.key?(:work_type)
+        self.identity = collaborators[:identity] if collaborators.key?(:identity)
+        @properties = collaborators.fetch(:properties_container) { default_properties_container }
+        @presenter_builder = collaborators.fetch(:presenter_builder) { default_presenter_builder }
+        block.call(self) if block_given?
+      end
+
+      def work_type=(value)
+        @work_type = WorkType(value)
+      end
+
+      def work_type
+        @work_type ||= WorkType()
+      end
+
+      def identity=(value)
+        @identity = value
+      end
+
+      def has_property?(predicate)
+        properties.key?(predicate)
+      end
+
+      attr_reader :properties, :identity
+
+      def to_translation_key_fragment
+        work_type.to_translation_key_fragment
+      end
+
+      def name_for_application_usage
+        work_type.name_for_application_usage
+      end
+
+      def itemtype_schema_dot_org
+        work_type.itemtype_schema_dot_org
+      end
+
+      attr_reader :presenter_builder
+      private :presenter_builder
+
+      def to_presenter
+        presenter_builder.call(self)
+      end
+
+      private
+
+
+      def default_properties_container
+        require 'hydramata/works/property_set'
+        PropertySet.new(entity: self)
+      end
+
+      def default_presenter_builder
+        require 'hydramata/works/entity_presenter'
+        ->(entity) { EntityPresenter.new(entity: entity) }
+      end
+    end
+  end
+end

data/app/models/hydramata/works/predicate.rb

@@ -0,0 +1,35 @@
+require 'hydramata/works/data_definition'
+require 'hydramata/works/validations_parser'
+require 'active_support/core_ext/array/wrap'
+
+module Hydramata
+  module Works
+    class Predicate < DataDefinition
+
+      def initialize(*args, &block)
+        @validations = []
+        super(*args, &block)
+      end
+
+      attr_accessor :datastream_name
+      attr_accessor :value_coercer_name
+      attr_accessor :value_parser_name
+      attr_accessor :indexing_strategy
+      attr_reader :validations
+
+      def validations=(value)
+        @validations = ValidationsParser.call(value)
+      end
+
+      attr_reader :itemprop_schema_dot_org
+      def itemprop_schema_dot_org=(value)
+        string = value.to_s.strip
+        if string.size == 0
+          @itemprop_schema_dot_org = nil
+        else
+          @itemprop_schema_dot_org = string
+        end
+      end
+    end
+  end
+end

data/app/models/hydramata/works/predicate_presentation_sequences/storage.rb

@@ -0,0 +1,29 @@
+require 'active_record'
+require 'hydramata/works/predicates/storage'
+require 'hydramata/works/predicate_sets/storage'
+
+module Hydramata
+  module Works
+    # Defines the order in which predicates are presented.
+    module PredicatePresentationSequences
+      class Storage < ActiveRecord::Base
+        self.table_name = :hydramata_works_predicate_presentation_sequences
+
+        validates :predicate_set_id, { presence: true }
+        validates :predicate_id, { presence: true, uniqueness: { scope: :predicate_set_id } }
+        validates :presentation_sequence, { presence: true, uniqueness: { scope: :predicate_set_id } }
+
+        belongs_to(
+          :predicate_set,
+          class_name: 'Hydramata::Works::PredicateSets::Storage',
+          foreign_key: 'predicate_set_id'
+        )
+        belongs_to(
+          :predicate,
+          class_name: 'Hydramata::Works::Predicates::Storage',
+          foreign_key: 'predicate_id'
+        )
+      end
+    end
+  end
+end

data/app/models/hydramata/works/predicate_set.rb

@@ -0,0 +1,44 @@
+require 'active_support/core_ext/array/wrap'
+require 'hydramata/works/conversions/predicate'
+require 'hydramata/works/data_definition'
+
+module Hydramata
+  module Works
+
+    # A PredicateSet is analogous to a PropertySet, except it does not include
+    # values.
+    class PredicateSet < DataDefinition
+      include Conversions
+
+      attr_accessor :work_type
+      attr_accessor :presentation_sequence
+      attr_reader :predicates
+
+      def <=>(other)
+        if other.instance_of?(self.class)
+          [work_type, identity, presentation_sequence] <=>
+            [other.work_type, other.identity, other.presentation_sequence]
+        else
+          nil
+        end
+      end
+
+      def predicates=(items)
+        @predicates = []
+        Array.wrap(items).each do |item|
+          @predicates << Predicate(item)
+        end
+      end
+
+      protected
+
+      def validate!
+        if identity.nil?
+          raise RuntimeError, "#{self.class}(#{inspect}) is invalid"
+        else
+          true
+        end
+      end
+    end
+  end
+end