iqvoc 4.7.0 → 4.8.0

data/lib/iqvoc/ability.rb

@@ -1,60 +0,0 @@
-module Iqvoc
-  class Ability
-    include CanCan::Ability
-
-    @@if_published = lambda { |o| o.published? }
-
-    def initialize(user = nil)
-      can :read, Iqvoc::Concept.root_class.instance
-      can :read, [::Concept::Base, ::Collection::Base, ::Label::Base], &@@if_published
-
-      # static pages
-      can :read, :help
-
-      if user # Every logged in user ...
-        can :use, :dashboard
-        can :destroy, UserSession
-
-        if user.owns_role?(:editor) || user.owns_role?(:publisher) || user.owns_role?(:administrator) # Editors and above ...
-          can :read, [::Concept::Base, ::Collection::Base, ::Label::Base]
-          can :create, [::Concept::Base, ::Collection::Base, ::Label::Base]
-          can [:update, :destroy, :unlock], [::Concept::Base, ::Collection::Base, ::Label::Base], locked_by: user.id, published_at: nil
-          can :lock, [::Concept::Base, ::Collection::Base, ::Label::Base], locked_by: nil, published_at: nil
-          can [:check_consistency, :send_to_review], [::Concept::Base, ::Collection::Base, ::Label::Base], published_at: nil
-          can :branch, [::Concept::Base, ::Collection::Base, ::Label::Base], &@@if_published
-        end
-
-        if user.owns_role?(:match_editor)
-          can :read, ::Concept::Base
-          can :create, ::Concept::Base
-          can [:update, :lock], ::Concept::Base, locked_by: user.id, published_at: nil
-          can :lock, ::Concept::Base, locked_by: nil, published_at: nil
-          can :branch, ::Concept::Base, &@@if_published
-        end
-
-        if user.owns_role?(:publisher) || user.owns_role?(:administrator) # Publishers and above ...
-          can :merge, [::Concept::Base, ::Collection::Base, ::Label::Base], published_at: nil
-        end
-
-        if user.owns_role?(:administrator)
-          can [:update, :destroy, :unlock], [::Concept::Base, ::Label::Base], published_at: nil # Mustn't be locked by myself
-
-          can :manage, User
-          can :manage, Iqvoc.config
-
-          can :full_export, ::Concept::Base
-          can :import, ::Concept::Base
-          can :export, ::Concept::Base
-
-          can :update, Iqvoc::Concept.root_class.instance
-
-          can :use, :administration
-
-          can :reset, :thesaurus
-        end
-      else # no user
-        can :create, UserSession
-      end
-    end
-  end
-end

data/lib/iqvoc/controller_extensions.rb

@@ -1,111 +0,0 @@
-require 'active_support/concern'
-
-module Iqvoc
-  module ControllerExtensions
-    extend ActiveSupport::Concern
-
-    included do
-      prepend_before_action :set_locale
-      before_action :ensure_extension
-
-      helper :all
-      helper_method :current_user_session, :current_user, :concept_widget_data, :collection_widget_data, :label_widget_data
-
-      rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
-      rescue_from CanCan::AccessDenied, with: :handle_access_denied
-      rescue_from ActionController::ParameterMissing, with: :handle_bad_request
-    end
-
-    protected
-
-    def default_url_options(options = nil)
-      { format: params[:format], lang: I18n.locale }.
-        merge(options || {})
-    end
-
-    # Force an extension to every url. (LOD)
-    def ensure_extension
-      unless params[:format] || !request.get?
-        flash.keep
-        redirect_to url_for(params.merge(format: (request.format && request.format.symbol) || :html))
-      end
-    end
-
-    def handle_access_denied(exception)
-      @exception = exception
-      @status = current_user ? 403 : 401
-      @user_session = UserSession.new if @status == 401
-      @return_url = request.fullpath
-      respond_to do |format|
-        format.html { render template: 'errors/access_denied', status: @status }
-        format.any  { head @status }
-      end
-    end
-
-    def handle_not_found(exception)
-      @exception = exception
-      SearchResultsController.prepare_basic_variables(self)
-
-      respond_to do |format|
-        format.html { render template: 'errors/not_found', status: 404 }
-        format.any  { head 404 }
-      end
-    end
-
-    def handle_bad_request(exception)
-      @exception = exception
-
-      respond_to do |format|
-        format.any  { head 400 }
-      end
-    end
-
-    def set_locale
-      if params[:lang].present? && Iqvoc::Concept.pref_labeling_languages.include?(params[:lang])
-        I18n.locale = params[:lang]
-      else
-        I18n.locale = Iqvoc::Concept.pref_labeling_languages.first
-      end
-    end
-
-    def concept_widget_data(concept, rank = nil)
-      data = {
-        id: concept.origin,
-        name: (concept.pref_label && concept.pref_label.value.presence || ":#{concept.origin}") + (concept.additional_info ? " (#{concept.additional_info })" : '')
-      }
-      data[:rank] = rank if rank
-      data
-    end
-
-    def collection_widget_data(collection)
-      {
-        id: collection.origin,
-        name: collection.pref_label.to_s
-      }
-    end
-
-    def label_widget_data(label)
-      {
-        id: label.origin,
-        name: label.value
-      }
-    end
-
-    # Configurable Ability class
-    def current_ability
-      @current_ability ||= Iqvoc.ability_class.new(current_user)
-    end
-
-    def current_user_session
-      @current_user_session ||= UserSession.find
-    end
-
-    def current_user
-      @current_user ||= current_user_session && current_user_session.user
-    end
-
-    def with_layout?
-      !params[:layout]
-    end
-  end
-end

data/lib/iqvoc/deep_cloning.rb

@@ -1,90 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2011-2013 innoQ Deutschland GmbH
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Iqvoc
-  module DeepCloning
-    def self.included(base) #:nodoc:
-      base.alias_method_chain :dup, :deep_cloning
-    end
-
-    # clones an ActiveRecord model.
-    # if passed the :include option, it will deep clone the given associations
-    # if passed the :except option, it won't clone the given attributes
-    #
-    # === Usage:
-    #
-    # ==== Cloning a model without an attribute
-    # pirate.clone except: :name
-    #
-    # ==== Cloning a model without multiple attributes
-    # pirate.clone except: [:name, :nick_name]
-    # ==== Cloning one single association
-    # pirate.clone include: :mateys
-    #
-    # ==== Cloning multiple associations
-    # pirate.clone include: [:mateys, :treasures]
-    #
-    # ==== Cloning really deep
-    # pirate.clone include: {treasures: :gold_pieces}
-    #
-    # ==== Cloning really deep with multiple associations
-    # pirate.clone include: [:mateys, {treasures: :gold_pieces}]
-    #
-    # ==== Cloning multiple associations - but only the join table entries without cloning the associated objects themselves
-    # pirate.clone include_association: [:matey_ids, :treasure_ids]
-    #
-    def dup_with_deep_cloning(options = {})
-      kopy = dup_without_deep_cloning
-
-      if options[:except]
-        Array(options[:except]).each do |attribute|
-          kopy.write_attribute(attribute, attributes_from_column_definition[attribute.to_s])
-        end
-      end
-
-      if options[:include_association]
-        Array(options[:include_association]).each do |association_attribute|
-          kopy.send("#{association_attribute}=", self.send("#{association_attribute}"))
-        end
-      end
-
-      if options[:include]
-        Array(options[:include]).each do |association, deep_associations|
-          if (association.kind_of? Hash)
-            deep_associations = association[association.keys.first]
-            association = association.keys.first
-          end
-          opts = deep_associations.blank? ? {} : { include: deep_associations }
-          association_reflection = self.class.reflect_on_association(association)
-          cloned_object = case association_reflection.macro
-          when :belongs_to, :has_one
-            self.send(association) && self.send(association).dup(opts)
-          when :has_many, :has_and_belongs_to_many
-            fk = association_reflection.options[:foreign_key]# || self.class.to_s.underscore
-            self.send(association).collect do |obj|
-              cloned_obj = obj.dup(opts)
-              cloned_obj.send("#{fk}=", kopy.id) unless fk.blank?
-              cloned_obj
-            end
-          end
-          kopy.send("#{association}=", cloned_object)
-        end
-      end
-
-      return kopy
-    end
-  end
-end

data/lib/iqvoc/inline_data_helper.rb

@@ -1,45 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2011-2013 innoQ Deutschland GmbH
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'csv'
-
-module Iqvoc
-  module InlineDataHelper
-    # delimiters for strings representing a list of values - XXX: lacks encapsulation
-    JOINER = ', '
-    SPLITTER = /[,\n] */
-
-    CSV_OPTIONS = {
-      col_sep: ', ',
-      quote_char: '"'
-    }
-
-    def self.parse_inline_values(inline_values)
-      options = CSV_OPTIONS.clone
-      options[:col_sep] = options[:col_sep].strip
-      begin
-        values = inline_values.parse_csv(options)
-      rescue CSV::MalformedCSVError => exc
-        values = inline_values.parse_csv(CSV_OPTIONS)
-      end
-      values ? values.map(&:strip) : []
-    end
-
-    def self.generate_inline_values(values)
-      values.to_csv(CSV_OPTIONS).strip
-    end
-  end
-end

data/lib/iqvoc/instance_configuration.rb

@@ -1,123 +0,0 @@
-# encoding: UTF-8
-
-# Copyright 2011-2013 innoQ Deutschland GmbH
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'singleton'
-
-module Iqvoc
-  # provides the interface to configuration settings
-  class InstanceConfiguration
-    include Singleton
-
-    attr_reader :defaults # XXX: dangerous (mutable object)
-
-    class UnregisteredSetting < ArgumentError
-      def to_s
-        'A setting needs to be registered with register_setting before it can be used.'
-      end
-    end
-
-    def initialize
-      @defaults = {} # default settings
-      @records = {} # customized (non-default) settings
-      @settings = {} # current settings, using defaults as fallback
-      # NB: cannot cache immediately because defaults need to be registered first
-    end
-
-    # convenience wrapper for `register_setting` batch operations
-    # accepts a hash of key / default value pairs
-    def register_settings(settings)
-      settings.each do |key, default_value|
-        register_setting(key, default_value)
-      end
-    end
-
-    # create or update a default setting
-    def register_setting(key, default_value)
-      self.class.validate_value(default_value)
-
-      @defaults[key] = default_value
-
-      # update cache
-      @settings[key] = @records[key] || default_value
-    end
-
-    # remove a default setting
-    # returns nil if setting does not exist
-    # NB: does *not* delete configuration settings from the database
-    def deregister_setting(key)
-      res = @defaults.delete(key)
-
-      # update cache
-      @settings.delete(key)
-
-      return res
-    end
-
-    # retrieve individual setting, using default value as fallback
-    def [](key)
-      initialize_cache unless @initialized
-      return @settings[key]
-    end
-
-    # store individual customized setting
-    def []=(key, value)
-      raise UnregisteredSetting unless @defaults.include?(key)
-      self.class.validate_value(value)
-
-      json = JSON.dump([value])[1..-2] # temporary array wrapper ensures valid JSON text
-      if setting = ConfigurationSetting.find_by_key(key)
-        setting.update_attributes(value: json)
-      else
-        ConfigurationSetting.create(key: key, value: json)
-      end
-
-      # update cache
-      @records[key] = value
-      @settings[key] = value
-
-      return value
-    end
-
-    # populate settings caches
-    # (subsequent updates will happen automatically via the respective setters)
-    def initialize_cache
-      return false unless ConfigurationSetting.table_exists? # pre-migration
-
-      # cache customized settings
-      ConfigurationSetting.all.each do |setting|
-        @records[setting.key] = JSON.load("[#{setting.value}]")[0] # temporary array wrapper ensures valid JSON text
-      end
-
-      # cache current settings
-      @defaults.each do |key, default_value|
-        value = @records[key]
-        @settings[key] = value.nil? ? default_value : value
-      end
-
-      @initialized = true
-    end
-
-    # checks whether value type is supported
-    def self.validate_value(value) # TODO: compare type to default's? (cf. controller)
-      if value == nil
-        raise TypeError, 'nil values not supported'
-      end
-      unless [TrueClass, FalseClass, String, Fixnum, Float, Array].include?(value.class)
-        raise TypeError, 'complex values not supported'
-      end
-    end
-  end
-end

data/lib/iqvoc/maker.rb

@@ -1,141 +0,0 @@
-module Iqvoc
-  module Maker
-    # labels:
-    # -
-    #   value: <string>
-    #   <attribute>: <value>
-    #   inflectionals: [<string>, ...]
-    #   components: [<label>, ...]
-    #
-    # concepts:
-    # -
-    #   <attribute>: <value>
-    #   pref_labels: [<label>, ...]
-    #   alt_labels: [<label>, ...]
-    #   broader: <concept>
-    #   narrower: <concept>
-    #   related: [<concept>, ...]
-    #
-    # NB:
-    # * <label> and <concept> can either be strings referencing a previously
-    #   declared entity or objects representing a new entity
-    #   XXX: The latter is not currently supported yet!
-    # * order of concepts matters when referencing relations
-    # * order of labels matters when referencing components
-    def self.from_yaml(yml)
-      data = YAML.load(yml)
-
-      labels = {}
-      data['labels'].each { |label| # XXX: use omap to simplify format (making `value` the key instead of an attribute)?
-        term = label.delete('value')
-
-        components = label.delete('components').map { |term|
-          labels[term]
-        } if label['components']
-
-        options = {
-          inflectionals: label.delete('inflectionals'),
-          components: components,
-          label_attributes: label
-        }
-
-        labels[term] = self.label(term, options)
-      } if data['labels']
-
-      concepts = {}
-      data['concepts'].each { |concept| # XXX: use omap to simplify format (using a single pref_label as key)?
-        relations = {}
-        ['broader', 'narrower'].each { |type| # TODO: missing related, support for poly-hierarchies
-          relations[type] = concepts[concept.delete(type)] if concept[type]
-        }
-
-        lbls = {} # TODO: rename
-        ['pref', 'alt'].each { |type| # TODO: missing hidden
-          key = "#{type}_labels"
-          lbls[type] = concept.delete(key).map { |term|
-            labels[term]
-          } if concept[key]
-        }
-
-        options = {
-          pref_labels: lbls['pref'],
-          alt_labels: lbls['alt'],
-          concept_attributes: concept
-        }
-
-        identifier = options[:pref_labels].first.value
-        concepts[identifier] = self.concept(options)
-        concepts[identifier].send(Iqvoc::Concept.broader_relation_class.name.to_relation_name).
-            create_with_reverse_relation(relations['broader']) if relations['broader']
-        concepts[identifier].send(Iqvoc::Concept.broader_relation_class.narrower_class.name.to_relation_name).
-            create_with_reverse_relation(relations['narrower']) if relations['narrower']
-      } if data['concepts']
-
-      return { concepts: concepts, labels: labels }
-    end
-
-    # optional arguments:
-    # concept_attributes for custom concept attributes
-    # pref_labels is an array of strings or label instances to be used as prefLabels
-    # alt_labels is an array of strings or label instances to be used as altLabels
-    def self.concept(options={})
-      attributes = options[:concept_attributes] || {}
-      pref_labels = options[:pref_labels] || []
-      alt_labels = options[:alt_labels] || []
-
-      defaults = { # NB: must use strings, not symbols as keys due to YAML
-        'published_at' => 3.days.ago
-      }
-      attributes = defaults.merge(attributes)
-
-      concept = Iqvoc::Concept.base_class.create!(attributes)
-
-      pref_labels.each { |term|
-        label = term.is_a?(String) ? self.label(term) : term
-        Iqvoc::Concept.pref_labeling_class.
-            create!(owner: concept, target: label)
-      }
-      alt_labels.each { |term|
-        label = term.is_a?(String) ? self.label(term) : term
-        Iqvoc::Concept.further_labeling_classes.first.first.
-            create!(owner: concept, target: label)
-      }
-
-      return concept
-    end
-
-    # optional arguments:
-    # label_attributes for custom label attributes
-    # inflectionals is an array of strings to be used as inflectionals
-    # components is an array of labels to be used as compound form contents
-    def self.label(value, options={}) # FIXME: move into SKOS-XL extension
-      attributes = options[:label_attributes] || {}
-      inflectionals = options[:inflectionals] || []
-      components = options[:components] || []
-
-      defaults = { # NB: must use strings, not symbols as keys due to YAML
-        value: value, # intentionally not a string; symbol takes precedence
-        'origin' => Iqvoc::Origin.new(value).to_s,
-        'language' => Iqvoc::Concept.pref_labeling_languages.first,
-        'published_at' => 2.days.ago
-      }
-      attributes = defaults.merge(attributes)
-
-      klass = Iqvoc::XLLabel rescue Iqvoc::Label # FIXME: breaks encapsulation (hard-coded iqvoc_skosxl dependency)
-      label = klass.base_class.create!(attributes)
-
-      inflectionals.each { |inf|
-        label.inflectionals.create!(value: inf)
-      }
-
-      if components.length > 0
-        compound_form_contents = components.each_with_index.map { |label, i|
-          CompoundForm::Content::Base.new(label: label, order: i)
-        }
-        label.compound_forms.create!(compound_form_contents: compound_form_contents)
-      end
-
-      return label
-    end
-  end
-end