test_hyrax 0.0.1.alpha

data/lib/hyrax/controlled_vocabulary/importer/downloader.rb

@@ -0,0 +1,17 @@
+require 'ruby-progressbar'
+
+module Hyrax
+  module ControlledVocabulary
+    module Importer
+      class Downloader
+        def self.fetch(url, output)
+          open(url) do |io|
+            IO.copy_stream(io, output)
+          end
+        rescue OpenURI::HTTPError => e
+          raise "Unable to download from #{url}\n#{e.message}: #{e.io.read}"
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/controlled_vocabulary/importer/language.rb

@@ -0,0 +1,62 @@
+require_relative 'downloader'
+require 'rdf/rdfxml'
+module Hyrax
+  module ControlledVocabulary
+    module Importer
+      class Language
+        URL = 'http://www.lexvo.org/resources/lexvo_2013-02-09.rdf.gz'.freeze
+
+        def initialize
+          stdout_logger = Logger.new(STDOUT)
+          stdout_logger.level = Logger::INFO
+          stdout_logger.formatter = proc do |_severity, _datetime, _progname, msg|
+            "#{msg}\n"
+          end
+          Rails.logger.extend(ActiveSupport::Logger.broadcast(stdout_logger))
+        end
+
+        def import
+          download
+          extract
+          logger.info "Importing #{rdf_path}"
+          Qa::Services::RDFAuthorityParser.import_rdf(
+            'languages',
+            [rdf_path],
+            format: 'rdfxml',
+            predicate: RDF::URI('http://www.w3.org/2008/05/skos#prefLabel')
+          )
+          logger.info "Import complete"
+        end
+
+        delegate :logger, to: Rails
+
+        def rdf_path
+          @rdf_path ||= download_path.sub(/\.gz$/, '')
+        end
+
+        def extract
+          return if File.exist?(rdf_path)
+          logger.info "Extracting #{download_path}"
+          system("gunzip #{download_path}")
+          raise "Unable to extract #{download_path}" unless $CHILD_STATUS.success?
+        end
+
+        def download
+          return if File.exist?(rdf_path) || File.exist?(download_path)
+          logger.info "Downloading #{URL}"
+          Downloader.fetch(URL, download_path)
+        end
+
+        def download_path
+          File.join(download_dir, File.basename(URL))
+        end
+
+        def download_dir
+          @download_dir ||= Rails.root.join('tmp')
+          FileUtils.mkdir_p @download_dir
+          @download_dir
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/controller_resource.rb

@@ -0,0 +1,12 @@
+module Hyrax
+  # Overrides CanCan so that attributes are not automatically assigned
+  # to loaded resources
+  class ControllerResource < CanCan::ControllerResource
+    protected
+
+      # Override resource_params to make this a nop. Hyrax uses actors to assign attributes
+      def resource_params
+        {}
+      end
+  end
+end

data/lib/hyrax/engine.rb

@@ -0,0 +1,80 @@
+module Hyrax
+  class Engine < ::Rails::Engine
+    isolate_namespace Hyrax
+
+    # These gems must be required outside of an initializer or they don't get loaded.
+    require 'awesome_nested_set'
+    require 'breadcrumbs_on_rails'
+    require 'jquery-ui-rails'
+    require 'flot-rails'
+    require 'almond-rails'
+    require 'jquery-datatables-rails'
+    require 'flipflop'
+    require 'qa'
+    require 'clipboard/rails'
+    require 'legato'
+
+    # Force these models to be added to Legato's registry in development mode
+    config.eager_load_paths += %W(
+      #{config.root}/app/models/hyrax/download.rb
+      #{config.root}/app/models/hyrax/pageview.rb
+    )
+
+    initializer 'requires' do
+      require 'hydra/derivatives'
+      require 'hyrax/name'
+      require 'hyrax/controller_resource'
+      require 'hyrax/search_state'
+      require 'hyrax/single_use_error'
+      require 'hyrax/workflow_authorization_exception'
+      require 'power_converters'
+      require 'dry/struct'
+      require 'dry/equalizer'
+      require 'dry/validation'
+    end
+
+    initializer 'routing' do
+      require 'hyrax/rails/routes'
+    end
+
+    initializer 'configure' do
+      # Set the path for the flipflop config:
+      Flipflop::Engine.config_file = Hyrax::Engine.root + "config/features.rb"
+
+      Hyrax.config.tap do |c|
+        Hydra::Derivatives.ffmpeg_path    = c.ffmpeg_path
+        Hydra::Derivatives.temp_file_base = c.temp_file_base
+        Hydra::Derivatives.fits_path      = c.fits_path
+        Hydra::Derivatives.enable_ffmpeg  = c.enable_ffmpeg
+        Hydra::Derivatives.libreoffice_path = c.libreoffice_path
+
+        ActiveFedora::Base.translate_uri_to_id = c.translate_uri_to_id
+        ActiveFedora::Base.translate_id_to_uri = c.translate_id_to_uri
+
+        ActiveFedora::Noid.config.template = c.noid_template
+        ActiveFedora::Noid.config.minter_class = c.noid_minter_class
+        ActiveFedora::Noid.config.statefile = c.minter_statefile
+      end
+
+      Hyrax::CurationConcern.actor_factory = Hyrax::ActorFactory
+      Hyrax::Workflow::WorkflowFactory.workflow_strategy = Hyrax::Workflow::WorkflowByAdminSetStrategy
+    end
+
+    initializer 'hyrax.assets.precompile' do |app|
+      app.config.assets.paths << config.root.join('vendor', 'assets', 'fonts')
+      app.config.assets.paths << config.root.join('app', 'assets', 'images')
+      app.config.assets.paths << config.root.join('app', 'assets', 'images', 'blacklight')
+      app.config.assets.paths << config.root.join('app', 'assets', 'images', 'hydra')
+      app.config.assets.paths << config.root.join('app', 'assets', 'images', 'site_images')
+
+      app.config.assets.precompile << /fontawesome-webfont\.(?:svg|ttf|woff)$/
+      app.config.assets.precompile += %w(*.png *.jpg *.ico *.gif *.svg)
+      app.config.assets.precompile += %w(hyrax/admin.css)
+
+      Sprockets::ES6.configuration = { 'modules' => 'amd', 'moduleIds' => true }
+      # When we upgrade to Sprockets 4, we can ditch sprockets-es6 and config AMD
+      # in this way:
+      # https://github.com/rails/sprockets/issues/73#issuecomment-139113466
+    end
+  end
+end

data/lib/hyrax/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym 'API'
+end

data/lib/hyrax/move_all_works_to_admin_set.rb

@@ -0,0 +1,8 @@
+# If you want to move all your works to an admin set run this.
+class MoveAllWorksToAdminSet
+  def self.run(admin_set)
+    Hyrax::WorkRelation.new.find_each do |w|
+      w.update(admin_set: admin_set)
+    end
+  end
+end

data/lib/hyrax/name.rb

@@ -0,0 +1,20 @@
+module Hyrax
+  # A model name that provides routes that are namespaced to Hyrax,
+  # without changing the param key.
+  #
+  # Example:
+  #   name = Hyrax::Name.new(MyWork)
+  #   name.param_key
+  #   # => 'my_work'
+  #   name.route_key
+  #   # => 'hyrax_my_works'
+  #
+  class Name < ActiveModel::Name
+    def initialize(klass, namespace = nil, name = nil)
+      super
+      @route_key          = "hyrax_#{ActiveSupport::Inflector.pluralize(@param_key)}"
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
+      @route_key << "_index" if @plural == @singular
+    end
+  end
+end

data/lib/hyrax/rails/routes.rb

@@ -0,0 +1,99 @@
+module ActionDispatch::Routing
+  class Mapper
+    # @yield If a block is passed it is yielded for each curation_concern
+    # @example
+    #   curation_concerns_basic_routes do
+    #     concerns :exportable
+    #   end
+    def curation_concerns_basic_routes(&block)
+      resources :upload_sets, only: [:edit, :update]
+
+      namespace :hyrax, path: :concern do
+        namespaced_resources 'workflow_actions', only: [:update]
+        concerns_to_route.each do |curation_concern_name|
+          namespaced_resources curation_concern_name, except: [:index], &block
+          namespaced_resources curation_concern_name, only: [] do
+            member do
+              get :file_manager
+              get :inspect_work
+            end
+          end
+        end
+
+        resources :parent, only: [] do
+          concerns_to_route.each do |curation_concern_name|
+            namespaced_resources curation_concern_name, except: [:index], &block
+          end
+        end
+
+        resources :parent, only: [] do
+          resources :file_sets, only: [:show]
+        end
+
+        resources :permissions, only: [] do
+          member do
+            get :confirm
+            post :copy
+          end
+        end
+        resources :file_sets, only: [:new, :create], path: 'container/:parent_id/file_sets'
+        resources :file_sets, only: [:show, :edit, :update, :destroy] do
+          member do
+            get :versions
+            put :rollback
+          end
+        end
+      end
+    end
+
+    # Adds routes for doing paginated searches within a collection's contents
+    # @example in routes.rb:
+    #     curation_concerns_collections
+    def curation_concerns_collections
+      Deprecation.warn(self, "curation_concerns_collections is deprecated and will be removed")
+    end
+
+    # kmr added :show to make tests pass
+    def curation_concerns_embargo_management
+      resources :embargoes, only: [:index, :edit, :destroy] do
+        collection do
+          patch :update
+        end
+      end
+      resources :leases, only: [:index, :edit, :destroy] do
+        collection do
+          patch :update
+        end
+      end
+    end
+
+    private
+
+      # routing namepace arguments, for using a path other than the default
+      ROUTE_OPTIONS = { 'hyrax' => { path: :concern } }.freeze
+
+      # Namespaces routes appropriately
+      # @example namespaced_resources("hyrax/my_work") is equivalent to
+      #   namespace "hyrax", path: :concern do
+      #     resources "my_work", except: [:index]
+      #   end
+      def namespaced_resources(target, opts = {}, &block)
+        if target.include?('/')
+          the_namespace = target[0..target.index('/') - 1]
+          new_target = target[target.index('/') + 1..-1]
+          namespace the_namespace, ROUTE_OPTIONS.fetch(the_namespace, nil) do
+            namespaced_resources(new_target, opts, &block)
+          end
+        else
+          resources target, opts do
+            yield if block_given?
+          end
+        end
+      end
+
+      # @return [Array<String>] the list of works to build routes for
+      def concerns_to_route
+        Hyrax.config.registered_curation_concern_types.map(&:tableize)
+      end
+  end
+end

data/lib/hyrax/redis_event_store.rb

@@ -0,0 +1,58 @@
+module Hyrax
+  class RedisEventStore
+    class << self
+      def for(key)
+        new(key)
+      end
+
+      # @return [Fixnum] the id of the event
+      def create(action, timestamp)
+        event_id = instance.incr("events:latest_id")
+        instance.hmset("events:#{event_id}", "action", action, "timestamp", timestamp)
+        event_id
+      rescue Redis::CommandError => e
+        logger.error("unable to create event: #{e}")
+        nil
+      end
+
+      delegate :logger, to: ActiveFedora::Base
+
+      def instance
+        if Redis.current.is_a? Redis::Namespace
+          Redis.current.namespace = namespace
+        else
+          Redis.current = Redis::Namespace.new(namespace, redis: Redis.current)
+        end
+        Redis.current
+      end
+
+      def namespace
+        Hyrax.config.redis_namespace
+      end
+    end
+
+    def initialize(key)
+      @key = key
+    end
+
+    def fetch(size)
+      RedisEventStore.instance.lrange(@key, 0, size).map do |event_id|
+        {
+          action: RedisEventStore.instance.hget("events:#{event_id}", "action"),
+          timestamp: RedisEventStore.instance.hget("events:#{event_id}", "timestamp")
+        }
+      end
+    rescue Redis::CommandError, Redis::CannotConnectError
+      RedisEventStore.logger.error("unable to fetch event: #{@key}")
+      []
+    end
+
+    # Adds a value to the end of a list identified by key
+    def push(value)
+      RedisEventStore.instance.lpush(@key, value)
+    rescue Redis::CommandError, Redis::CannotConnectError
+      RedisEventStore.logger.error("unable to push event: #{@key}")
+      nil
+    end
+  end
+end

data/lib/hyrax/resource_sync.rb

@@ -0,0 +1,12 @@
+module Hyrax
+  module ResourceSync
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :CapabilityListWriter
+      autoload :ChangeListWriter
+      autoload :ResourceListWriter
+      autoload :SourceDescriptionWriter
+    end
+  end
+end

data/lib/hyrax/resource_sync/capability_list_writer.rb

@@ -0,0 +1,38 @@
+module Hyrax
+  module ResourceSync
+    class CapabilityListWriter
+      attr_reader :resource_list_url, :change_list_url, :description_url
+      def initialize(resource_list_url:, change_list_url:, description_url:)
+        @resource_list_url = resource_list_url
+        @change_list_url = change_list_url
+        @description_url = description_url
+      end
+
+      def write
+        builder.to_xml
+      end
+
+      private
+
+        def builder
+          Nokogiri::XML::Builder.new do |xml|
+            xml.urlset('xmlns' => 'http://www.sitemaps.org/schemas/sitemap/0.9',
+                       'xmlns:rs' => 'http://www.openarchives.org/rs/terms/') do
+              xml['rs'].ln(rel: "up", href: description_url)
+              xml['rs'].md(capability: "capabilitylist")
+
+              xml.url do
+                xml.loc resource_list_url
+                xml['rs'].md(capability: 'resourcelist')
+              end
+
+              xml.url do
+                xml.loc change_list_url
+                xml['rs'].md(capability: 'changelist')
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/hyrax/resource_sync/change_list_writer.rb

@@ -0,0 +1,90 @@
+module Hyrax
+  module ResourceSync
+    # TODO: the big assumption I'm making here is that the repository has fewer
+    # than 50,000 resources to list. The Sitemap protocol is limited at 50,000
+    # items, so if we require more than that, we must have multiple Change
+    # lists and add a Change List Index to point to all of them.
+    class ChangeListWriter
+      attr_reader :resource_host, :capability_list_url
+
+      def initialize(resource_host:, capability_list_url:)
+        @resource_host = resource_host
+        @capability_list_url = capability_list_url
+      end
+
+      def write
+        builder.to_xml
+      end
+
+      private
+
+        def builder
+          Nokogiri::XML::Builder.new do |xml|
+            xml.urlset('xmlns' => 'http://www.sitemaps.org/schemas/sitemap/0.9',
+                       'xmlns:rs' => 'http://www.openarchives.org/rs/terms/') do
+              xml['rs'].ln(rel: "up", href: capability_list_url)
+              xml['rs'].md(capability: "changelist", from: from)
+              build_changes(xml)
+            end
+          end
+        end
+
+        def from
+          @from ||= relation.search_with_conditions(public_access, rows: 1, sort: 'system_modified_dtsi asc').first.fetch('system_modified_dtsi')
+        end
+
+        def sort
+          { sort: 'system_modified_dtsi desc' }
+        end
+
+        def relation
+          @relation ||= Hyrax::ExposedModelsRelation.new
+        end
+
+        def build_changes(xml)
+          relation.search_in_batches(public_access, sort) do |doc_set|
+            build_resources(xml, doc_set)
+          end
+        end
+
+        def build_resources(xml, doc_set)
+          doc_set.each do |doc|
+            model = doc.fetch('has_model_ssim', []).first.constantize
+            if model == Collection
+              build_resource(xml, doc, model, hyrax_routes)
+            else
+              build_resource(xml, doc, model, main_app_routes)
+            end
+          end
+        end
+
+        # @param xml [Nokogiri::XML::Builder]
+        # @param doc [Hash]
+        # @param routes [Module] has the routes for the object
+        def build_resource(xml, doc, model, routes)
+          modified_date = doc.fetch("system_modified_dtsi")
+          created_date = doc.fetch("system_create_dtsi")
+          xml.url do
+            key = model.model_name.singular_route_key
+            xml.loc routes.send(key + "_url", doc['id'], host: resource_host)
+            xml.lastmod modified_date
+            xml['rs'].md(change: modified_date == created_date ? "created" : "updated")
+          end
+        end
+
+        def main_app_routes
+          Rails.application.routes.url_helpers
+        end
+
+        def hyrax_routes
+          Hyrax::Engine.routes.url_helpers
+        end
+
+        delegate :collection_url, to: :routes
+
+        def public_access
+          { Hydra.config.permissions.read.group => 'public' }
+        end
+    end
+  end
+end