geoblacklight 2.3.0

data/lib/geoblacklight/engine.rb

@@ -0,0 +1,27 @@
+require 'blacklight'
+require 'font-awesome-rails'
+require 'coderay'
+require 'config'
+require 'faraday'
+require 'faraday_middleware'
+require 'nokogiri'
+require 'geoblacklight-icons'
+require 'mime/types'
+require 'handlebars_assets'
+
+module Geoblacklight
+  class Engine < ::Rails::Engine
+    Blacklight::Configuration.default_values[:view].split.partials = ['index']
+    Blacklight::Configuration.default_values[:view].delete_field('list')
+    # GeoblacklightHelper is needed by all helpers, so we inject it
+    # into action view base here.
+    initializer 'geoblacklight.helpers' do
+      ActionView::Base.send :include, GeoblacklightHelper
+      ActionView::Base.send :include, CartoHelper
+    end
+
+    config.to_prepare do
+      Geoblacklight.inject!
+    end
+  end
+end

data/lib/geoblacklight/exceptions.rb

@@ -0,0 +1,27 @@
+module Geoblacklight
+  module Exceptions
+    class ExternalDownloadFailed < StandardError
+      def initialize(options = {})
+        @options = options
+      end
+
+      ##
+      # URL tried from failed download
+      # @return [String]
+      def url
+        @options[:url].to_s
+      end
+
+      ##
+      # Message passed from a failed download
+      # @return [String]
+      def message
+        @options[:message].to_s
+      end
+    end
+    class WrongDownloadFormat < StandardError
+    end
+    class WrongBoundingBoxFormat < StandardError
+    end
+  end
+end

data/lib/geoblacklight/geoblacklight_helper_behavior.rb

@@ -0,0 +1,14 @@
+module Geoblacklight
+  ##
+  # Adds helper behavior logic for GeoBlacklight, to used alongside
+  # BlacklightHelperBehavior
+  module GeoblacklightHelperBehavior
+    ##
+    # Calls the presenter on the requested method
+    # @param [Symbol, String] presenting_method
+    # @return [String]
+    def geoblacklight_present(presenting_method, document = @document)
+      presenter(document).try(presenting_method.to_sym) || ''
+    end
+  end
+end

data/lib/geoblacklight/item_viewer.rb

@@ -0,0 +1,54 @@
+module Geoblacklight
+  class ItemViewer
+    def initialize(references)
+      @references = references
+    end
+
+    def viewer_protocol
+      return 'map' if viewer_preference.nil?
+      viewer_preference.keys.first.to_s
+    end
+
+    def viewer_endpoint
+      return '' if viewer_preference.nil?
+      viewer_preference.values.first.to_s
+    end
+
+    def wms
+      @references.wms
+    end
+
+    def iiif
+      @references.iiif
+    end
+
+    def tiled_map_layer
+      @references.tiled_map_layer
+    end
+
+    def dynamic_map_layer
+      @references.dynamic_map_layer
+    end
+
+    def feature_layer
+      @references.feature_layer
+    end
+
+    def image_map_layer
+      @references.image_map_layer
+    end
+
+    def index_map
+      @references.index_map
+    end
+
+    def oembed
+      @references.oembed
+    end
+
+    def viewer_preference
+      [oembed, index_map, wms, iiif, tiled_map_layer, dynamic_map_layer,
+       image_map_layer, feature_layer].compact.map(&:to_hash).first
+    end
+  end
+end

data/lib/geoblacklight/metadata.rb

@@ -0,0 +1,18 @@
+module Geoblacklight
+  module Metadata
+    ##
+    # Initialize a new Metadata instance
+    # @param [Geoblacklight::Reference] reference the reference for the metadata resource
+    # @return [Geoblacklight::Metadata::Base]
+    def self.instance(reference)
+      begin
+        klass = "Geoblacklight::Metadata::#{reference.type.capitalize}".constantize
+      rescue
+        Geoblacklight.logger.warn "Metadata type #{reference.type} is not supported"
+        klass = Geoblacklight::Metadata::Base
+      end
+
+      klass.new(reference)
+    end
+  end
+end

data/lib/geoblacklight/metadata/base.rb

@@ -0,0 +1,93 @@
+module Geoblacklight
+  module Metadata
+    ##
+    # Abstract Class for metadata
+    class Base
+      attr_reader :reference
+      delegate :type, to: :reference
+      delegate :to_html, to: :metadata
+      delegate :transform, to: :transformer
+      delegate :to_xml, to: :document
+
+      ##
+      # Instantiates a Geoblacklight::Metadata object used for retrieving and
+      # formatting metadata
+      # @param reference [Geoblacklight::Reference] the reference object
+      def initialize(reference)
+        @reference = reference
+      end
+
+      ##
+      # Retrieves the XML Document for the metadata
+      # @return [Nokogiri::XML::Document]
+      def document
+        @document ||= metadata.metadata
+      end
+
+      ##
+      # Determines whether or not a metadata resources is empty
+      # @return [Boolean]
+      def blank?
+        document.nil? || document.children.empty?
+      end
+
+      ##
+      # Retrieves the URI for the reference resource (e. g. a service endpoint)
+      # @return [String, nil]
+      def endpoint
+        blank? ? nil : @reference.endpoint
+      end
+
+      private
+
+      ##
+      # Retrieves metadata from a url source
+      # @return [String, nil] metadata string or nil if there is a
+      # connection error
+      def retrieve_metadata
+        connection = Faraday.new(url: @reference.endpoint) do |conn|
+          conn.use FaradayMiddleware::FollowRedirects
+          conn.adapter Faraday.default_adapter
+        end
+        begin
+          response = connection.get
+          return response.body unless response.nil? || response.status == 404
+          Geoblacklight.logger.error "Could not reach #{@reference.endpoint}"
+          ''
+        rescue Faraday::ConnectionFailed => error
+          Geoblacklight.logger.error error.inspect
+          ''
+        rescue Faraday::TimeoutError => error
+          Geoblacklight.logger.error error.inspect
+          ''
+        rescue OpenSSL::SSL::SSLError => error
+          Geoblacklight.logger.error error.inspect
+          ''
+        end
+      end
+
+      ##
+      # Retrieve the Class for the GeoCombine data model
+      # @return [GeoCombine::Metadata]
+      def metadata_class
+        GeoCombine::Metadata
+      end
+
+      ##
+      # Handles metadata and returns the retrieved metadata or an error message if
+      # something went wrong
+      # @return [String] returned metadata string
+      def metadata
+        response_body = retrieve_metadata
+        metadata_class.new(response_body)
+      end
+
+      ##
+      # Initialize the MetadataTransformer Object for the metadata
+      # @return [GeoBlacklight::MetadataTransformer] MetadataTransformer instance
+      def transformer
+        MetadataTransformer.instance(self)
+      end
+    end
+  end
+end

data/lib/geoblacklight/metadata/fgdc.rb

@@ -0,0 +1,14 @@
+module Geoblacklight
+  module Metadata
+    class Fgdc < Base
+      private
+
+      ##
+      # Retrieve the Class for the GeoCombine data model
+      # @return [GeoCombine::Fgdc]
+      def metadata_class
+        GeoCombine::Fgdc
+      end
+    end
+  end
+end

data/lib/geoblacklight/metadata/html.rb

@@ -0,0 +1,13 @@
+module Geoblacklight
+  module Metadata
+    class Html < Base
+      def transform
+        ActionController::Base.helpers.content_tag(:iframe,
+                                                   '',
+                                                   src: @reference.endpoint,
+                                                   scrolling: 'yes',
+                                                   frameborder: 0)
+      end
+    end
+  end
+end

data/lib/geoblacklight/metadata/iso19139.rb

@@ -0,0 +1,14 @@
+module Geoblacklight
+  module Metadata
+    class Iso19139 < Base
+      private
+
+      ##
+      # Retrieve the Class for the GeoCombine data model
+      # @return [GeoCombine::Iso19139]
+      def metadata_class
+        GeoCombine::Iso19139
+      end
+    end
+  end
+end

data/lib/geoblacklight/metadata_transformer.rb

@@ -0,0 +1,33 @@
+require 'geo_combine'
+
+module Geoblacklight
+  module MetadataTransformer
+    ##
+    # Exceptions raised for the types of geospatial metadata
+    class TypeError < EncodingError; end
+    ##
+    # Exceptions raised when parsing geospatial metadata in the XML
+    class ParseError < EncodingError; end
+    ##
+    # Exception raised when the geospatial metadata content is empty
+    class EmptyMetadataError < ParseError; end
+    ##
+    # Exceptions raised when transforming the metadata into the HTML
+    class TransformError < EncodingError; end
+
+    ##
+    # Initialize a new MetadataTransformer instance
+    # @param [Geoblacklight::Metadata::Base] metadata string or File path to the raw metadata
+    # @return [Geoblacklight::MetadataTransformer::BaseTransformer]
+    def self.instance(metadata)
+      type = metadata.class.name.split('::').last
+      begin
+        klass = "Geoblacklight::MetadataTransformer::#{type.capitalize}".constantize
+      rescue
+        raise TypeError, "Metadata type #{type} is not supported"
+      end
+
+      klass.new(metadata)
+    end
+  end
+end

data/lib/geoblacklight/metadata_transformer/base.rb

@@ -0,0 +1,42 @@
+module Geoblacklight
+  module MetadataTransformer
+    ##
+    # Abstract class for transforming geospatial metadata
+    class Base
+      ##
+      # @param [GeoCombine::Metadata] metadata metadata Object
+      # @see GeoCombine::Metadata
+      def initialize(metadata)
+        @metadata = metadata
+        # Access the Nokogiri::XML Document from the metadata Object
+        fail EmptyMetadataError, 'Failed to retrieve the metadata' if @metadata.blank?
+      end
+
+      ##
+      # Returns HTML for the metadata transformed into HTML using GeoCombine
+      # @see GeoCombine::Metadata#to_html
+      # @return [String] the transformed metadata in the HTML
+      def transform
+        cleaned_metadata.to_html
+      rescue => e
+        raise TransformError, e.message
+      end
+
+      private
+
+      ##
+      # Clean top-level HTML elements from GeoCombine HTML Documents (e. g. <html> and <body>)
+      # @return [Nokogiri::XML::Document] the Nokogiri XML Document for the cleaned HTML
+      def cleaned_metadata
+        transformed_doc = Nokogiri::XML(@metadata.to_html)
+        if transformed_doc.xpath('//body').children.empty?
+          fail TransformError,\
+               'Failed to extract the <body> child elements from the transformed metadata'
+        end
+        transformed_doc.xpath('//body').children
+      rescue => e
+        raise TransformError, e.message
+      end
+    end
+  end
+end

data/lib/geoblacklight/metadata_transformer/fgdc.rb

@@ -0,0 +1,8 @@
+module Geoblacklight
+  module MetadataTransformer
+    ##
+    # Class for transforming FGDC XML Documents
+    class Fgdc < Base
+    end
+  end
+end

data/lib/geoblacklight/metadata_transformer/iso19139.rb

@@ -0,0 +1,8 @@
+module Geoblacklight
+  module MetadataTransformer
+    ##
+    # Class for transforming ISO19139 XML Documents
+    class Iso19139 < Base
+    end
+  end
+end

data/lib/geoblacklight/reference.rb

@@ -0,0 +1,45 @@
+module Geoblacklight
+  ##
+  # Parses an array of dct_references to create useful reference information
+  class Reference
+    attr_reader :reference
+
+    ##
+    # Initializes a Reference object using an Array
+    # @param [Array] reference
+    def initialize(reference)
+      @reference = reference
+    end
+
+    ##
+    # The endpoint URL for a Geoblacklight::Reference
+    # @return [String]
+    def endpoint
+      @reference[1]
+    end
+
+    ##
+    # Lookups the type from the Constants::URI using the reference's URI
+    # @return [Symbol]
+    def type
+      Geoblacklight::Constants::URI.key(uri)
+    end
+
+    ##
+    # Creates a hash, using its type as key and endpoint as value
+    # @return [Hash]
+    def to_hash
+      { type => endpoint }
+    end
+
+    private
+
+    ##
+    # The URI used for this instance's creation
+    # Remove any trailing slashes
+    # @return [String]
+    def uri
+      @reference[0].sub(/(\/)+$/, '') if @reference[0].present?
+    end
+  end
+end

data/lib/geoblacklight/references.rb

@@ -0,0 +1,132 @@
+module Geoblacklight
+  # References is a geoblacklight-schema dct:references parser
+  class References
+    attr_reader :refs, :reference_field
+    def initialize(document, reference_field = Settings.FIELDS.REFERENCES)
+      @document = document
+      @reference_field = reference_field
+      @refs = parse_references.map { |ref| Reference.new(ref) }
+    end
+
+    ##
+    # Return only those metadata references which are exposed within the configuration
+    # @return [Geoblacklight::Reference]
+    def shown_metadata_refs
+      metadata = @refs.select { |ref| Settings.METADATA_SHOWN.include?(ref.type.to_s) }
+      metadata.sort do |u, v|
+        Settings.METADATA_SHOWN.index(u.type.to_s) <=> Settings.METADATA_SHOWN.index(v.type.to_s)
+      end
+    end
+
+    ##
+    # Return only metadata for shown metadata
+    # @return [Geoblacklight::Metadata::Base]
+    def shown_metadata
+      @shown_metadata ||= shown_metadata_refs.map { |ref| Geoblacklight::Metadata.instance(ref) }
+    end
+
+    ##
+    # Accessor for a document's file format
+    # @return [String] file format for the document
+    def format
+      @document[Settings.FIELDS.FILE_FORMAT]
+    end
+
+    ##
+    # @param [String, Symbol] ref_type
+    # @return [Geoblacklight::Reference]
+    def references(ref_type)
+      @refs.find { |reference| reference.type == ref_type }
+    end
+
+    ##
+    # Preferred download (should be a file download)
+    # @return [Hash, nil]
+    def preferred_download
+      return file_download unless download.blank?
+    end
+
+    ##
+    # Download hash based off of format type
+    # @return [Hash, nil]
+    def downloads_by_format
+      case format
+      when 'Shapefile'
+        vector_download_formats
+      when 'GeoTIFF'
+        geotiff_download_formats
+      when 'ArcGRID'
+        arcgrid_download_formats
+      end
+    end
+
+    ##
+    # Generated download types from wxs services
+    # @return (see #downloads_by_format)
+    def download_types
+      downloads_by_format
+    end
+
+    ##
+    # Returns all of the Esri webservices for given set of references
+    def esri_webservices
+      %w[tiled_map_layer dynamic_map_layer feature_layer image_map_layer].map do |layer_type|
+        send(layer_type)
+      end.compact
+    end
+
+    private
+
+    ##
+    # Parses the references field of a document
+    # @return [Hash]
+    def parse_references
+      if @document[reference_field].nil?
+        {}
+      else
+        JSON.parse(@document[reference_field])
+      end
+    end
+
+    ##
+    # Download hash for a static file download
+    # @return (see #downloads_by_format)
+    def file_download
+      { file_download: download.to_hash }
+    end
+
+    ##
+    # Download hash for a Shapefile file (currently only vector) with a wms and wfs reference
+    # present
+    # @return (see #downloads_by_format)
+    def vector_download_formats
+      { shapefile: wfs.to_hash,
+        kmz: wms.to_hash,
+        geojson: wfs.to_hash } if wms.present? && wfs.present?
+    end
+
+    ##
+    # Download hash for a GeoTiff file with a WMS reference present
+    # @return (see #downloads_by_format)
+    def geotiff_download_formats
+      { geotiff: wms.to_hash } if wms.present?
+    end
+
+    ##
+    # Download hash for an ArcGRID file with a WMS reference present
+    # @return (see #downloads_by_format)
+    def arcgrid_download_formats
+      { geotiff: wms.to_hash } if wms.present?
+    end
+
+    ##
+    # Adds a call to references for defined URI keys
+    def method_missing(m, *args, &b)
+      if Geoblacklight::Constants::URI.key?(m)
+        references m
+      else
+        super
+      end
+    end
+  end
+end