hydramata-works 0.0.1.prerelease

data/app/parsers/hydramata/works/datastream_parsers/rdf_ntriples_parser.rb

@@ -0,0 +1,60 @@
+module Hydramata
+  module Works
+    module DatastreamParsers
+      # Responsible for parsing an ntriples encoded datastructure.
+      class RdfNtriplesParser
+        def self.match?(options = {})
+          datastream = options[:datastream]
+          return false unless datastream
+          if datastream.mimeType == 'text/plain' &&
+            datastream.content =~ /\A\<info:fedora/
+            self
+          else
+            false
+          end
+        end
+
+        def self.call(data, collaborators = {}, &block)
+          new(collaborators).call(data, &block)
+        end
+
+        def initialize(collaborators = {})
+          @graph = collaborators.fetch(:graph) { default_graph }
+          @reader = collaborators.fetch(:reader) { default_reader }
+          @pattern = collaborators.fetch(:pattern) { default_pattern }
+        end
+
+        def call(data, &block)
+          query_graph_with(data, &block)
+        end
+
+        private
+
+        def query_graph_with(data)
+          graph << reader.new(data)
+          graph.query(pattern).each_statement do |statement|
+            yield(predicate: statement.predicate.to_s, value: statement.object)
+          end
+        end
+
+        attr_reader :graph, :reader, :pattern
+        private :graph, :reader, :pattern
+
+        def default_graph
+          require 'rdf'
+          RDF::Graph.new
+        end
+
+        def default_reader
+          require 'rdf'
+          RDF::Reader.for(:ntriples)
+        end
+
+        def default_pattern
+          require 'rdf'
+          RDF::Query::Pattern.from([:s, :p, :o])
+        end
+      end
+    end
+  end
+end

data/app/parsers/hydramata/works/datastream_parsers/simple_xml_parser.rb

@@ -0,0 +1,27 @@
+module Hydramata
+  module Works
+    module DatastreamParsers
+      # Responsible for parsing a very simplistic XML document.
+      module SimpleXmlParser
+        module_function
+        def match?(options = {})
+          datastream = options[:datastream]
+          return false unless datastream
+          if datastream.mimeType =~ /\A(application|text)\/xml/
+            self
+          else
+            false
+          end
+        end
+
+        def call(content, &block)
+          require 'nokogiri'
+          doc = Nokogiri::XML.parse(content)
+          doc.xpath('/fields/*').each do |node|
+            block.call(predicate: node.name, value: node.text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Hydramata
+  module Works
+    # Responsible for finding the appropriate predicate 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 PredicateParser
+      module_function
+
+      def call(options = {}, &block)
+        parser = parser_for(options)
+        value = options.fetch(:value)
+        parser.call(value, &block)
+      end
+
+      def parser_for(options = {})
+        parser_finder = options.fetch(:parser_finder) { default_parser_finder }
+        parser_finder.call(options)
+      end
+
+      def default_parser_finder
+        proc do
+          require 'hydramata/works/predicate_parsers/simple_parser'
+          PredicateParsers::SimpleParser
+        end
+      end
+      private_class_method :default_parser_finder
+    end
+  end
+end

data/app/parsers/hydramata/works/predicate_parsers/simple_parser.rb

@@ -0,0 +1,13 @@
+module Hydramata
+  module Works
+    module PredicateParsers
+      # A comically simple parser. You get what you give.
+      module SimpleParser
+        module_function
+        def call(object, &block)
+          block.call(value: object)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'json'
+module Hydramata
+  module Works
+    module ValidationsParser
+      module_function
+      def call(input)
+        case input
+        when NilClass then {}
+        when String then
+          if input.empty?
+            {}
+          else
+            JSON.parse(input)
+          end
+        when Hash then input
+        else
+          raise RuntimeError, "Unable to parse #{input.inspect} for Validations"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Hydramata
+  module Works
+    module ValueParser
+      module_function
+      def call(options = {}, &block)
+        parser = parser_for(options)
+        value = options.fetch(:value)
+        parser.call(value, &block)
+      end
+
+      def parser_for(options = {})
+        parser_finder = options.fetch(:parser_finder) { default_parser_finder }
+        parser_finder.call(options)
+      end
+
+      def default_parser_finder
+        ->(options) do
+          require 'hydramata/works/value_parsers'
+          ValueParsers.find(options)
+        end
+      end
+      private_class_method :default_parser_finder
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'hydramata/works/value_parsers/simple_parser'
+require 'hydramata/works/value_parsers/date_parser'
+require 'hydramata/works/value_parsers/interrogation_parser'
+
+module Hydramata
+  module Works
+    module ValueParsers
+      module_function
+      def find(options = {})
+        predicate = options.fetch(:predicate)
+        parser_class_name = predicate.value_parser_name
+
+        # Catching behavioral difference between const_defined? in Ruby 2.0 and
+        # Ruby 2.1
+        if parser_class_name =~ /\A::/
+          SimpleParser
+        elsif const_defined?(parser_class_name)
+          const_get(parser_class_name)
+        else
+          SimpleParser
+        end
+      rescue NameError, TypeError
+        SimpleParser
+      end
+    end
+  end
+end

data/app/parsers/hydramata/works/value_parsers/date_parser.rb

@@ -0,0 +1,13 @@
+module Hydramata
+  module Works
+    module ValueParsers
+      module DateParser
+        module_function
+        def call(object, &block)
+          date = Date.parse(object.to_s)
+          block.call(value: date, raw_object: object)
+        end
+      end
+    end
+  end
+end

data/app/parsers/hydramata/works/value_parsers/interrogation_parser.rb

@@ -0,0 +1,18 @@
+module Hydramata
+  module Works
+    module ValueParsers
+      module InterrogationParser
+        module_function
+        def call(object, &block)
+          value =
+          case object
+          when RDF::Literal then object.to_s
+          else
+            object
+          end
+          block.call(value: value, raw_object: object)
+        end
+      end
+    end
+  end
+end

data/app/parsers/hydramata/works/value_parsers/simple_parser.rb

@@ -0,0 +1,14 @@
+module Hydramata
+  module Works
+    module ValueParsers
+      # A comically simple parser.
+      # You get what you give.
+      module SimpleParser
+        module_function
+        def call(object, &block)
+          block.call(value: object, raw_object: object)
+        end
+      end
+    end
+  end
+end

data/app/presenters/hydramata/works/base_presenter.rb

@@ -0,0 +1,146 @@
+require 'delegate'
+require 'active_support/core_ext/array/wrap'
+require 'hydramata/works/conversions/translation_key_fragment'
+
+module Hydramata
+  module Works
+    # Responsible for coordinating the rendering of an in-memory data structure
+    # object to an output buffer.
+    class BasePresenter < SimpleDelegator
+      include Conversions
+      attr_reader :presentation_context, :translator, :partial_prefixes, :template_missing_error, :translation_scopes
+      def initialize(object, collaborators = {})
+        __setobj__(object)
+        @presentation_context = collaborators.fetch(:presentation_context) { default_presentation_context }
+        @translator = collaborators.fetch(:translator) { default_translator }
+        @partial_prefixes = collaborators.fetch(:partial_prefixes) { default_partial_prefixes }
+        @translation_scopes = collaborators.fetch(:translation_scopes) { default_translation_scopes }
+        @template_missing_error = collaborators.fetch(:template_missing_exception) { default_template_missing_exception }
+        @dom_attributes_builder = collaborators.fetch(:dom_attributes_builder) { default_dom_attributes_builder }
+      end
+
+      def render(options = {})
+        template = options.fetch(:template)
+        rendering_options = rendering_options_for(options)
+        render_with_diminishing_specificity(template, rendering_options)
+      end
+
+      def inspect
+        format('#<%s:%#0x presenting=%s>', self.class, __id__, __getobj__.inspect)
+      end
+
+      def instance_of?(klass)
+        super || __getobj__.instance_of?(klass)
+      end
+
+      def dom_class(options = {})
+        prefix = options.fetch(:prefix, nil)
+        suffix = options.fetch(:suffix, nil)
+        [prefix, base_dom_class, suffix].compact.join('-')
+      end
+
+      def translate(key)
+        translator.t(key, scopes: translation_scopes, default: default_translation_for(key))
+      end
+      alias_method :t, :translate
+
+      def name
+        __getobj__.respond_to?(:name) ? __getobj__.name : __getobj__.name_for_application_usage
+      end
+
+      def to_presenter
+        self
+      end
+
+      def container_content_tag_attributes(options = {})
+        dom_attributes_builder.call(self, options, default_dom_attributes)
+      end
+
+      def presenter_dom_class
+        self.class.to_s.split('::').last.sub(/presenter\Z/i,'').downcase
+      end
+
+      private
+
+      attr_reader :dom_attributes_builder
+      def default_dom_attributes_builder
+        require 'hydramata/works/dom_attributes_builder'
+        DomAttributesBuilder
+      end
+
+      def default_dom_attributes
+        {}
+      end
+
+      def base_dom_class
+        name.to_s.downcase.gsub(/[\W_]+/, '-')
+      end
+
+      def render_with_diminishing_specificity(template, rendering_options)
+        render_with_prefixes(template, rendering_options) || render_without_prefixes(template, rendering_options)
+      end
+
+      def render_with_prefixes(template, rendering_options)
+        rendered = nil
+        partial_prefixes.each do |partial_prefix|
+          begin
+            rendered = template.render(rendering_options.merge(partial: partial_name(partial_prefix)))
+            break
+            # By using the splat operator I am allowing multiple exceptions to
+            # be caught and pass to the next rendering context.
+          rescue *template_missing_error
+            next
+          end
+        end
+        rendered
+      end
+
+      def render_without_prefixes(template, rendering_options)
+        template.render(rendering_options.merge(partial: partial_name))
+      end
+
+      def default_partial_prefixes
+        []
+      end
+
+      def default_translation_scopes
+        []
+      end
+
+      def rendering_options_for(options = {})
+        returning_options = { object: self }
+        returning_options[:locals] = options[:locals] if options.key?(:locals)
+        returning_options
+      end
+
+      def partial_name(*current_partial_prefixes)
+        partial_prefix = Array.wrap(current_partial_prefixes).join("/")
+        File.join('hydramata/works', view_path_slug_for_object, partial_prefix , presentation_context.to_s)
+      end
+
+      def default_presentation_context
+        'show'
+      end
+
+      def view_path_slug_for_object
+        'base'
+      end
+
+      def default_translation_for(key)
+        proc { send(key).to_s }
+      end
+
+      def default_translator
+        require 'hydramata/works/translator'
+        Translator
+      end
+
+      # Because actually testing this is somewhat of a nightmare given the
+      # 5+ parameters that are required when instantiating this exception.
+      def default_template_missing_exception
+        require 'action_view/template/error'
+        ActionView::MissingTemplate
+      end
+    end
+  end
+end

data/app/presenters/hydramata/works/dom_attributes_builder.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/array/wrap'
+
+module Hydramata
+  module Works
+    # Responsible for coordinating the potentially complicated dom attributes
+    # for a given context.
+    module DomAttributesBuilder
+      module_function
+      # context - a data structure; provided as a placeholder; Maybe we could
+      # supply additional attributes based on the context
+      def call(context, attributes = {}, defaults = {})
+        returning_value = attributes.dup
+        defaults.each_pair do |key, value|
+          if returning_value.key?(key)
+            returning_value[key] = Array.wrap(returning_value[key]) + Array.wrap(value)
+          else
+            returning_value[key] = Array.wrap(value)
+          end
+        end
+        returning_value
+      end
+    end
+  end
+end

data/app/presenters/hydramata/works/entity_presenter.rb

@@ -0,0 +1,67 @@
+require 'hydramata/works/conversions/presented_fieldsets'
+require 'hydramata/works/base_presenter'
+
+module Hydramata
+  module Works
+    # Responsible for coordinating the rendering of an in-memory Entity-like
+    # object to an output buffer.
+    class EntityPresenter < BasePresenter
+      include Conversions
+
+      attr_reader :presentation_structure, :presented_fieldset_builder
+      def initialize(collaborators = {})
+        entity = collaborators.fetch(:entity)
+        super(entity, collaborators)
+        @presentation_structure = collaborators.fetch(:presentation_structure) { default_presentation_structure }
+        @presented_fieldset_builder = collaborators.fetch(:presented_fieldset_builder) { default_presented_fieldset_builder }
+      end
+
+      def fieldsets
+        @fieldsets ||= presented_fieldset_builder.call(entity: self, presentation_structure: presentation_structure)
+      end
+
+      private
+
+      def default_dom_attributes
+        {
+          :class => [dom_class, presenter_dom_class],
+          :itemscope => true,
+          :itemtype => itemtype_schema_dot_org
+        }
+      end
+
+      def presenter_dom_class
+        'work'
+      end
+
+      def view_path_slug_for_object
+        'works'
+      end
+
+      def base_dom_class
+        work_type.to_s.downcase.gsub(/[\W_]+/, '-')
+      end
+
+      def default_presented_fieldset_builder
+        ->(collaborators) { PresentedFieldsets(collaborators) }
+      end
+
+      def default_partial_prefixes
+        [
+          [TranslationKeyFragment(self)]
+        ]
+      end
+
+      def default_translation_scopes
+        [
+          ['works', TranslationKeyFragment(self)]
+        ]
+      end
+
+      def default_presentation_structure
+        work_type
+      end
+
+    end
+  end
+end