iqvoc 4.2.0 → 4.3.0

data/app/helpers/application_helper.rb

@@ -97,11 +97,13 @@ module ApplicationHelper
     end
   end
 
-  def icon(name, white = nil)
-    css_class = "icon-#{name}"
-    css_class << " icon-white" if white
+  def icon(name, additional_css = "")
+    css_classes = %W(fa fa-#{name})
+    if additional_css.respond_to?(:split)
+      css_classes << additional_css.split(" ")
+    end
 
-    content_tag :i, "", :class => css_class
+    content_tag :i, "", :class => css_classes.join(" ")
   end
 
   def glyph(name)

data/app/helpers/dashboard_helper.rb

@@ -17,10 +17,10 @@
 module DashboardHelper
 
   def sorting_controls_for(name)
-    content_tag :span, :class => "sorting-controls" do
-      link_to(image_tag("arrow_up.gif", :class => "arrow_up"),
+    content_tag :div, :class => "sorting-controls" do
+      link_to(icon("arrow-circle-o-up", "sorting-arrow"),
         dashboard_path(:order => "asc", :by => name.to_s)) +
-        link_to(image_tag("arrow_down.gif", :class => "arrow_down"),
+        link_to(icon("arrow-circle-o-down", "sorting-arrow"),
         dashboard_path(:order => "desc", :by => name.to_s))
     end
   end

data/app/helpers/link_helper.rb

@@ -0,0 +1,14 @@
+module LinkHelper
+  def link_to_object(object, name, html_options = nil, &block)
+    path = case object
+    when Iqvoc::Concept.base_class
+      concept_path(:id => object)
+    when Iqvoc::Collection.base_class
+      collection_path(:id => object)
+    when Label::Base
+      label_path(:id => object)
+    end
+
+    link_to name, path, html_options, &block
+  end
+end

data/app/helpers/search_results_helper.rb

@@ -16,11 +16,15 @@
 
 module SearchResultsHelper
 
-  def select_search_checkbox?(lang)
+  def search_language_selected?(lang)
     (params[:languages] && params[:languages].include?(lang.to_s)) ||
       (!params[:query] && I18n.locale.to_s == lang.to_s)
   end
 
+  def search_dataset_selected?(adaptor)
+    params[:datasets] && params[:datasets].include?(adaptor.to_s)
+  end
+
   def highlight_query(text, query)
     query.split(/\n/).each do |q|
       # call to ActiveSupport's highlight

data/app/jobs/import_job.rb

@@ -0,0 +1,19 @@
+require 'iqvoc/skos_importer'
+
+class ImportJob < Struct.new(:import, :content, :user, :namespace, :publish)
+  def perform
+    strio = StringIO.new
+
+    importer = Iqvoc::SkosImporter.new(content.to_s.split("\n"), namespace, Logger.new(strio), publish)
+    importer.run
+    @messages = strio.string
+  end
+
+  def success(job)
+    import.finish!(@messages)
+  end
+
+  def error(job, exception)
+    import.fail!(exception)
+  end
+end

data/app/models/concept/base.rb

@@ -206,11 +206,11 @@ class Concept::Base < ActiveRecord::Base
 
     # Serialized setters and getters (\r\n or , separated) -- TODO: use Iqvoc::InlineDataHelper?
     define_method("inline_#{match_class_name.to_relation_name}".to_sym) do
-      self.send(match_class_name.to_relation_name).map(&:value).join("\r\n")
+      self.send(match_class_name.to_relation_name).map(&:value).join(Iqvoc::InlineDataHelper::JOINER)
     end
 
     define_method("inline_#{match_class_name.to_relation_name}=".to_sym) do |value|
-      urls = value.split(/\r\n|,/).map(&:strip).reject(&:blank?)
+      urls = value.split(Iqvoc::InlineDataHelper::SPLITTER).map(&:strip).reject(&:blank?)
       self.send(match_class_name.to_relation_name).each do |match|
         if (urls.include?(match.value))
           urls.delete(match.value) # We're done with that one

data/app/models/dataset/adaptors/iqvoc/alphabetical_search_adaptor.rb

@@ -0,0 +1,38 @@
+class Dataset::Adaptors::Iqvoc::AlphabeticalSearchAdaptor < Dataset::Adaptors::Iqvoc::SearchAdaptor
+  def search(prefix, locale)
+    fetch_results("/#{locale}/alphabetical_concepts/#{prefix}.html")
+    @results
+  end
+
+  def fetch_results(url, params = {})
+    begin
+      response = @conn.get(url, params)
+      @results ||= []
+      @results += extract_results(response.body)
+      while more = @doc.at_css('a[rel=next]')
+        fetch_results(more[:href], {})
+      end
+    rescue Faraday::Error::ConnectionFailed,
+      Faraday::Error::ResourceNotFound,
+      Faraday::Error::TimeoutError => e
+        Rails.logger.warn("HTTP error while querying remote source #{url}: #{e.message}")
+        return nil
+    end
+  end
+
+  def extract_results(html)
+    @doc = Nokogiri::HTML(html)
+
+    @doc.css('.concept-item').map do |element|
+      link = element.at_css('.concept-item-link')
+      label, path = link.text, link['data-resource-path'] # href
+
+      options = {
+        :definition => element.at_css('.concept-item-definition').try(:content),
+        :definition_language => element.at_css('.concept-item-definition').try(:[], :lang)
+      }
+
+      result = AlphabeticalSearchResultRemote.new(url, path, label, options)
+    end
+  end
+end

data/app/models/dataset/adaptors/iqvoc/http_adaptor.rb

@@ -0,0 +1,39 @@
+require 'faraday'
+
+class Dataset::Adaptors::Iqvoc::HTTPAdaptor
+  attr_reader :url
+
+  def initialize(url)
+    @url = url
+    @conn = Faraday.new(:url => url) do |conn|
+      #conn.use Faraday::Response::Logger if Rails.env.development?
+      conn.adapter Faraday.default_adapter
+    end
+  end
+
+  def http_get(path, redirect_count = 0)
+    begin
+      response = @conn.get(path)
+    rescue Faraday::Error::ConnectionFailed,
+        Faraday::Error::ResourceNotFound,
+        Faraday::Error::TimeoutError => e
+      return failed_request(path)
+    end
+
+    if response.status == 404
+      return failed_request(path)
+    end
+
+    if response.status == 302 && redirect_count < 3
+      response = http_get(response.headers["location"], redirect_count + 1)
+    end
+
+    response
+  end
+
+  private
+  def failed_request(path)
+    Rails.logger.warn "HTTP error while querying remote source #{path}"
+    return nil
+  end
+end

data/app/models/dataset/adaptors/iqvoc/label_adaptor.rb

@@ -0,0 +1,15 @@
+class Dataset::Adaptors::Iqvoc::LabelAdaptor < Dataset::Adaptors::Iqvoc::HTTPAdaptor
+  def find(concept_url)
+    path = URI.parse(concept_url).path
+    if response = http_get(path)
+      extract_label(response.body)
+    end
+  end
+
+  def extract_label(html)
+    doc = Nokogiri::HTML(html)
+    node = doc.at_css('h1')
+    node.at_css('small').remove
+    node.text.try(:strip)
+  end
+end

data/app/models/dataset/adaptors/iqvoc/search_adaptor.rb

@@ -0,0 +1,60 @@
+class Dataset::Adaptors::Iqvoc::SearchAdaptor < Dataset::Adaptors::Iqvoc::HTTPAdaptor
+  def search(raw_params = {})
+    languages = raw_params.fetch(:languages, I18n.locale)
+    languages = Array.wrap(languages).flatten.join(",")
+
+    params = {
+      :q => raw_params[:q],
+      :t => raw_params[:t],
+      :l => languages,
+      :c => raw_params[:c],
+      :qt => raw_params[:qt],
+      :page => 1 # hard code the first page as we need to follow pagination links
+    }
+
+    fetch_results('/search.html', params)
+    @results
+  end
+
+  def fetch_results(path, params = {})
+    begin
+      response = @conn.get(path, params)
+      @results ||= []
+      @results += extract_results(response.body)
+      while more = @doc.at_css('a[rel=next]')
+        fetch_results(more[:href], {})
+      end
+    rescue Faraday::Error::ConnectionFailed,
+      Faraday::Error::ResourceNotFound,
+      Faraday::Error::TimeoutError => e
+        Rails.logger.warn("HTTP error while querying remote source #{path}: #{e.message}")
+        return nil
+    end
+  end
+
+  def extract_results(html)
+    @doc = Nokogiri::HTML(html)
+
+    @doc.css('.search-result').map do |element|
+      link = element.at_css('.search-result-link')
+      label, path = link.text, link['data-resource-path']
+      result = SearchResultRemote.new(url, path, label)
+
+      if (meta = element.css('.search-result-meta > .search-result-value')) && meta.any?
+        meta.each do |element|
+          result.add_meta_information(element['data-key'], element.text)
+        end
+      end
+
+      if body = element.at_css('.search-result-body')
+        result.body = body.text
+      end
+
+      result.rdf_namespace = element['data-rdf-namespace']
+      result.rdf_predicate = element['data-rdf-predicate']
+      result.language = element['data-rdf-language']
+
+      result
+    end
+  end
+end

data/app/models/dataset/iqvoc_dataset.rb

@@ -0,0 +1,39 @@
+require 'linkeddata'
+
+class Dataset::IqvocDataset
+  attr_reader :name, :url
+
+  def initialize(url)
+    @url = URI.parse(url)
+    @repository = RDF::Repository.load(URI.join(url, 'dataset.rdf')) rescue nil
+    @name = fetch_name
+  end
+
+  def to_s
+    "#{name} (#{url})"
+  end
+
+  def search(params)
+    Dataset::Adaptors::Iqvoc::SearchAdaptor.new(url).search(params)
+  end
+
+  def alphabetical_search(prefix, locale)
+    Dataset::Adaptors::Iqvoc::AlphabeticalSearchAdaptor.new(url).search(prefix, locale)
+  end
+
+  def find_label(concept_url)
+    Dataset::Adaptors::Iqvoc::LabelAdaptor.new(url).find(concept_url)
+  end
+
+  private
+  def fetch_name
+    return 'unknown' if @repository.nil?
+
+    void = RDF::Vocabulary.new('http://rdfs.org/ns/void#')
+    query = RDF::Query.new({:dataset => {RDF.type => void.Dataset, RDF::DC.title => :title}})
+    results = query.execute(@repository)
+
+    return 'unknown' if results.empty?
+    results.map { |solution| solution.title.to_s }.first
+  end
+end

data/app/models/import.rb

@@ -0,0 +1,16 @@
+class Import < ActiveRecord::Base
+  belongs_to :user
+
+  def finish!(messages)
+    self.output = messages
+    self.success = true
+    self.finished_at = Time.now
+    save!
+  end
+
+  def fail!(exception)
+    self.output = exception.to_s + "\n\n" + exception.backtrace.join("\n")
+    self.finished_at = Time.now
+    save!
+  end
+end

data/app/models/labeling/skos/base.rb

@@ -81,7 +81,8 @@ class Labeling::SKOS::Base < Labeling::Base
       scope
     end
 
-    scope.merge(Concept::Base.published)
+    scope = scope.merge(Concept::Base.published)
+    scope.map { |result| SearchResult.new(result) }
   end
 
   def self.search_result_partial_name

data/app/models/note/base.rb

@@ -109,8 +109,8 @@ class Note::Base < ActiveRecord::Base
   def self.single_query(params = {})
     query_str = build_query_string(params)
 
-    by_query_value(query_str).
-      by_language(params[:languages].to_a)
+    scope = by_query_value(query_str).by_language(params[:languages].to_a)
+    scope.map { |result| SearchResult.new(result) }
   end
 
   def self.search_result_partial_name

data/app/models/note/skos/change_note.rb

@@ -29,8 +29,9 @@ class Note::SKOS::ChangeNote < Note::SKOS::Base
   def self.single_query(params = {})
     query_str = build_query_string(params)
 
-    Note::SKOS::ChangeNote.includes(:annotations).
-      merge(Note::Annotated::Base.where(Note::Annotated::Base.arel_table[:value].matches(query_str)))
+    scope = includes(:annotations)
+    scope = merge(Note::Annotated::Base.where(Note::Annotated::Base.arel_table[:value].matches(query_str)))
+    scope.map { |result| SearchResult.new(result) }
   end
 
   def build_rdf(document, subject)

data/app/presenters/alphabetical_search_result.rb

@@ -0,0 +1,33 @@
+class AlphabeticalSearchResult
+  delegate :url_helpers, :to => 'Rails.application.routes'
+
+  def initialize(pref_labeling)
+    @labeling = pref_labeling
+  end
+
+  def label
+    @labeling.target
+  end
+
+  def concept
+    @labeling.owner
+  end
+
+  def path
+    url_helpers.rdf_path(@labeling.owner.origin, :lang => nil, :format => nil)
+  end
+
+  def definition?
+    relation_name = Note::SKOS::Definition.name.to_relation_name
+    @labeling.owner.respond_to?(relation_name) && @labeling.owner.send(relation_name).any?
+  end
+
+  def definition
+    relation_name = Note::SKOS::Definition.name.to_relation_name
+    @labeling.owner.send(relation_name).first
+  end
+
+  def partial_name
+    'concepts/alphabetical/search_result'
+  end
+end

data/app/presenters/alphabetical_search_result_remote.rb

@@ -0,0 +1,37 @@
+class AlphabeticalSearchResultRemote < AlphabeticalSearchResult
+  def initialize(host, path, label, options = {})
+    @host = host
+    @path = path
+    @label = label
+    @definition = options[:definition]
+    @definition_language = options[:definition_language]
+  end
+
+  def label
+    @label
+  end
+
+  def path
+    @path
+  end
+
+  def url
+    URI.join(@host, @path).to_s
+  end
+
+  def definition?
+    @definition.present?
+  end
+
+  def definition
+    @definition
+  end
+
+  def definition_language
+    @definition_language
+  end
+
+  def partial_name
+    'concepts/alphabetical/search_result_remote'
+  end
+end

data/app/presenters/search_result.rb

@@ -0,0 +1,33 @@
+class SearchResult
+  extend Forwardable
+  def_delegators :@result_object, :build_search_result_rdf, :owner, :target,
+      :value, :label, :rdf_namespace, :rdf_predicate
+
+  def initialize(result_object)
+    @result_object = result_object
+  end
+
+  def model_name
+    @result_object.class.model_name
+  end
+
+  def search_result_partial_name
+    @result_object.class.search_result_partial_name
+  end
+
+  def language
+    if @result_object.is_a?(Labeling::Base)
+      @result_object.target.try(:language)
+    else
+      @result_object.try(:language)
+    end
+  end
+
+  def to_s
+    if @result_object.is_a?(Labeling::Base)
+      @result_object.target.value
+    else
+      @result_object.try(:owner).try(:pref_label).to_s
+    end
+  end
+end