hydramata-works 0.0.1.prerelease

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

@@ -0,0 +1,45 @@
+require 'active_record'
+require 'hydramata/works/predicate_set'
+require 'hydramata/works/work_types/storage'
+require 'hydramata/works/predicates/storage'
+require 'hydramata/works/predicate_presentation_sequences/storage'
+
+module Hydramata
+  module Works
+    module PredicateSets
+      class Storage < ActiveRecord::Base
+        self.table_name = :hydramata_works_predicate_sets
+        belongs_to(
+          :work_type,
+          class_name: '::Hydramata::Works::WorkTypes::Storage',
+          foreign_key: 'work_type_id'
+        )
+        validates :identity, uniqueness: { scope: :work_type_id }
+        validates :presentation_sequence, uniqueness: { scope: :work_type_id }
+
+        has_many(
+          :predicate_presentation_sequences,
+          class_name: '::Hydramata::Works::PredicatePresentationSequences::Storage',
+          foreign_key: 'predicate_set_id'
+        )
+
+        has_many(
+          :predicates,
+          class_name: '::Hydramata::Works::Predicates::Storage',
+          through: :predicate_presentation_sequences
+        )
+
+        def to_predicate_set
+          PredicateSet.new(predicate_set_attributes)
+        end
+
+        private
+
+        def predicate_set_attributes
+          attributes.with_indifferent_access.merge(predicates: predicates, work_type: work_type)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'hydramata/works/predicate'
+require 'hydramata/works/predicates/storage'
+
+module Hydramata
+  module Works
+    module Predicates
+      module_function
+      def find(identity, attributes = {})
+        predicate_attributes = attributes.merge(Predicates::Storage.existing_attributes_for(identity))
+        Predicate.new(predicate_attributes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'active_record'
+require 'hydramata/works/predicates'
+
+module Hydramata
+  module Works
+    module Predicates
+      # I don't want to conflate the idea with the predicate, with the storage
+      # strategy for predicates.
+      class Storage < ActiveRecord::Base
+        self.table_name = :hydramata_works_predicates
+
+        def self.find_by_identity!(identity)
+          where(identity: identity).first!
+        end
+
+        def self.existing_attributes_for(identity)
+          find_by_identity!(identity).attributes
+        rescue ActiveRecord::RecordNotFound
+          { identity: identity }
+        rescue ActiveRecord::ConnectionNotEstablished
+          # This is a potentially big deal in production.
+          # But for testing, I don't always want to hit the database, so
+          # I'm capturing this exception
+          { identity: identity }
+        end
+
+        def to_predicate
+          Predicate.new(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Hydramata
+  module Works
+    # This is responsible for defining
+    #
+    # Taking a queue from HTML, a fieldset gives meaning to a group of
+    # attributes. Conceptually it is providing the sequence in which to render
+    # attributes.
+    #
+    # @TODO - Does this class even make sense? Given that I am grabbing the
+    # presentation structure from the work type.
+    class PresentationStructure
+      def self.build_from(object)
+        new do |structure|
+          object.predicate_sets.each do |predicate_set|
+            structure.fieldsets << predicate_set
+          end
+        end
+      end
+
+      def initialize
+        yield(self) if block_given?
+      end
+
+      def fieldsets
+        @fieldsets ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/array/wrap'
+require 'hydramata/works/conversions'
+
+module Hydramata
+  module Works
+    # The responsibility of a Property is to be a collection of values for
+    # a given predicate. In other words, this represents the Predicate/Object
+    # components of an RDF Triple.
+    #
+    # Why not use RDF? Because not everything we are working with is in RDF.
+    class Property
+      def self.===(other)
+        super || other.instance_of?(self)
+      end
+
+      include ::Enumerable
+      include Conversions
+
+      attr_reader :predicate, :values, :value_parser
+      def initialize(options = {})
+        self.predicate = options.fetch(:predicate)
+        @value_parser = options.fetch(:value_parser) { default_value_parser }
+        @values = []
+        push(options[:values])
+        push(options[:value])
+      end
+
+      def name
+        predicate
+      end
+
+      # Because who wants to remember which way to access this?
+      alias_method :value, :values
+
+      def to_translation_key_fragment
+        predicate.to_translation_key_fragment
+      end
+
+      def each(&block)
+        values.each(&block)
+      end
+
+      def <<(values)
+        Array.wrap(values).each do |value|
+          value_parser.call(predicate: predicate, value: value) do |response|
+            @values << Value(response)
+          end
+        end
+        self
+      end
+      alias_method :push, :<<
+
+      def ==(other)
+        super ||
+          other.instance_of?(self.class) &&
+          other.predicate == predicate &&
+          other.values == values
+      end
+
+      private
+
+      def predicate=(value)
+        @predicate = Predicate(value)
+      end
+
+      def default_value_parser
+        require 'hydramata/works/value_parser'
+        ValueParser
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'active_support/core_ext/array/wrap'
+require 'hydramata/works/conversions'
+module Hydramata
+  module Works
+    # A container for Property objects. It provides ordered access to
+    # property_store. The corresponding specs go into further details on ordering.
+    class PropertySet
+      include Conversions
+      include ::Enumerable
+
+      def initialize(options = {})
+        @property_store = {}
+        self.predicate_set = options.fetch(:predicate_set) { default_predicate_set }
+      end
+      attr_reader :predicate_set
+
+      def name
+        predicate_set
+      end
+
+      def <<(input)
+        property = Property(input)
+        if property_store[property.predicate.to_s]
+          property_store[property.predicate.to_s] << property.values
+        else
+          property_store[property.predicate.to_s] = property
+        end
+      end
+
+      # If the key is missing, return a quasi-null object.
+      def [](key)
+        property_store[key.to_s] || Property(predicate: key)
+      end
+
+      def predicates
+        property_store.keys
+      end
+
+      def fetch(key)
+        property_store.fetch(key.to_s)
+      end
+
+      def key?(key)
+        property_store.key?(key.to_s)
+      end
+
+      def ==(other)
+        # Because property_store is a private method.
+        (other.instance_of?(property_store.class) && property_store == other) ||
+        (other.instance_of?(self.class) && other == property_store)
+      end
+
+      def each
+        property_store.each do |_key, property|
+          yield(property)
+        end
+      end
+
+      def properties
+        property_store.collect {|_, property| property }
+      end
+
+      # Conversion::PresentedFieldsets interacts with this.
+      # Consider extracting the shared behavior into that function. Perhaps
+      # making a proper class.
+      def subset(keys, receiver = self.class.new, property_builder = nil)
+        property_builder ||= ->(builder) { builder }
+        Array.wrap(keys).each_with_object(receiver).each do |key, collector|
+          # A concession regarding null property; If you ask for the keys, I'll
+          # give them to you; it just may be an empty value.
+          collector << property_builder.call(self[key])
+          collector
+        end
+      end
+
+      private
+
+      attr_reader :property_store
+
+      def default_predicate_set
+        { identity: 'identity' }
+      end
+
+      def predicate_set=(value)
+        @predicate_set = PredicateSet(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Hydramata
+  module Works
+    class Validations
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'delegate'
+
+module Hydramata
+  module Works
+    # Because it may be helpful to see the raw object
+    class Value < SimpleDelegator
+      attr_reader :raw_object
+      def initialize(options = {})
+        value = options.fetch(:value)
+        __setobj__(value)
+        @raw_object = options.fetch(:raw_object) { default_raw_object }
+        yield(self) if block_given?
+      end
+
+      def inspect
+        format('#<%s:%#0x value=%s raw_object=%s>', self.class, __id__, __getobj__.inspect, raw_object.inspect)
+      end
+
+      def instance_of?(klass)
+        super || __getobj__.instance_of?(klass)
+      end
+
+      def ==(other)
+        super || other == __getobj__
+      end
+
+      private
+
+      def default_raw_object
+        __getobj__
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'hydramata/works/data_definition'
+require 'hydramata/works/conversions/predicate_set'
+require 'active_support/core_ext/array/wrap'
+
+module Hydramata
+  module Works
+    class WorkType < DataDefinition
+      include Conversions
+
+      def initialize(*args, &block)
+        @predicate_sets = []
+        super(*args, &block)
+      end
+
+      attr_reader :predicate_sets
+      def predicate_sets=(things)
+        @predicate_sets = []
+        Array.wrap(things).each do |thing|
+          @predicate_sets << PredicateSet(thing)
+        end
+      end
+      alias_method :fieldsets, :predicate_sets
+      alias_method :fieldsets=, :predicate_sets=
+
+      def itemtype_schema_dot_org
+        @itemtype_schema_dot_org || default_itemtype_schema_dot_org
+      end
+
+      def itemtype_schema_dot_org=(value)
+        string = value.to_s.strip
+        if string.size == 0
+          @itemtype_schema_dot_org = nil
+        else
+          if string =~ /\Ahttp/
+            @itemtype_schema_dot_org = string
+          else
+            @itemtype_schema_dot_org = File.join('http://schema.org', string)
+          end
+        end
+      end
+
+      private
+
+      def default_itemtype_schema_dot_org
+        'http://schema.org/Thing'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'hydramata/works/work_type'
+require 'hydramata/works/work_types/storage'
+
+module Hydramata
+  module Works
+    module WorkTypes
+      module_function
+      def find(identity, attributes = {})
+        work_type_attributes = attributes.merge(WorkTypes::Storage.existing_attributes_for(identity))
+        WorkType.new(work_type_attributes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'active_record'
+require 'hydramata/works/predicate_sets/storage'
+require 'hydramata/works/work_type'
+
+module Hydramata
+  module Works
+    module WorkTypes
+      # I don't want to conflate the idea with the predicate, with the storage
+      # strategy for predicates.
+      class Storage < ActiveRecord::Base
+        self.table_name = :hydramata_works_types
+        has_many :predicate_sets, class_name: '::Hydramata::Works::PredicateSets::Storage', foreign_key: 'work_type_id'
+        validates :identity, uniqueness: true, presence: true
+
+        def self.find_by_identity!(identity)
+          where(identity: identity).first!
+        end
+
+        def self.existing_attributes_for(identity)
+          # @TODO - Is this the pattern I want to pursue? I liked the method
+          # :as_work_type being private
+          find_by_identity!(identity).as_work_type
+        rescue ActiveRecord::RecordNotFound
+          { identity: identity }
+        rescue ActiveRecord::ConnectionNotEstablished
+          # This is a potentially big deal in production.
+          # But for testing, I don't always want to hit the database, so
+          # I'm capturing this exception
+          { identity: identity }
+        end
+
+        def to_work_type
+          WorkType.new(as_work_type)
+        end
+
+        def as_work_type
+          attributes.merge(predicate_sets: predicate_sets)
+        end
+      end
+    end
+  end
+end

data/app/parsers/hydramata/works/datastream_parser.rb

@@ -0,0 +1,36 @@
+require 'hydramata/works/datastream_parsers/simple_xml_parser'
+require 'hydramata/works/datastream_parsers/rdf_ntriples_parser'
+
+module Hydramata
+  module Works
+    # Responsible for finding the appropriate datastream parser based on the
+    # input context, then calling the found parser.
+    #
+    # See lib/hydramata/works/linters.rb for the interface definition of a
+    # datastream parser.
+    module DatastreamParser
+      module_function
+
+      def call(options = {}, &block)
+        parser = parser_for(options)
+        datastream = options.fetch(:datastream)
+        parser.call(datastream.content, &block)
+      end
+
+      def parser_for(options = {})
+        parser_finder = options.fetch(:parser_finder) { default_parser_finder }
+        parser_finder.call(options)
+      end
+
+      def default_parser_finder
+        lambda do |options|
+          null_parser = proc {}
+          DatastreamParsers::RdfNtriplesParser.match?(options) ||
+            DatastreamParsers::SimpleXmlParser.match?(options) ||
+            null_parser
+        end
+      end
+      private_class_method :default_parser_finder
+    end
+  end
+end