publish_my_data 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Swirrl IT Limited
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# PublishMyData Community Edition.
+
+## Overview
+
+PublishMyData is a Rails Engine that adds Linked Data functionality to your Rails app including:
+
+- URI dereferencing and displaying resources outside your site domain
+- A SPARQL Endpoint
+- Filterable lists of datasets and resources
+
+## How to use
+
+1. Add it to your Gemfile
+
+        gem tripod
+
+2. Configure it (in application.rb, or development.rb/production.rb/test.rb)
+
+        PublishMyData.configure do |config|
+          config.sparql_endpoint = 'http://localhost:3030/pmd/sparql'
+          config.local_domain = 'pmd.dev'
+          config.sparql_timeout_seconds = 30
+          config.tripod_cache_store = Tripod::CacheStores::MemcachedCacheStore.new('localhost:11211')
+        end
+
+
+## Notes
+
+- PublishMyData uses [Tripod](http://github.com/Swirrl/tripod) for database access.
+- See the Rails guides for [more details on Rails Engines](http://guides.rubyonrails.org/engines.html).
+- PublishMyData doesn't supply a database. You need to install one. I recommend [Fuseki](http://jena.apache.org/documentation/serving_data/index.html), which runs on port 3030 by default.
+- The views currently supplied by this Rails engine are very rudimentary. Some nicer default views coming soon, but for now you'll probably just want to override them all in your app.
+- Warning: This gem is usable now, but the API is under constant development and flux at the moment
+
+## Licence
+
+Uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,41 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PublishMyData'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec
+
+

data/app/assets/javascripts/publish_my_data/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/app/assets/javascripts/publish_my_data/resources.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/publish_my_data/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/publish_my_data/resources.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/publish_my_data/application_controller.rb

@@ -0,0 +1,49 @@
+module PublishMyData
+  class ApplicationController < ActionController::Base
+
+    rescue_from Tripod::Errors::ResourceNotFound, :with => :resource_not_found
+
+    # TODO: handle:
+    # 500s, timeouts (503) etc.
+
+    private
+
+    def resource_not_found(e)
+      respond_to do |format|
+        format.html { render(:template => "publish_my_data/errors/not_found", :layout => 'publish_my_data/error', :status => 404) and return false }
+        #TODO: ? format.js { render(:template => "publish_my_data/errors/not_found", :status => 200) and return false } # need to return success or the ajax request fails
+        format.any { head(:status => 404, :content_type => 'text/plain') and return false }
+      end
+    end
+
+    # from the criteria passed in, sets an instance var for @count and return
+    # a Kaminari::PaginatableArray, or Array (as appropriate to the format)
+    def paginate_resources(criteria)
+
+      get_pagination_params unless @got_pagination_params
+
+      @count = criteria.count #this has to happen first, before we modify the criteria with limit/offset
+      resources = criteria.limit(@limit).offset(@offset).resources
+
+      if request.format.html?
+        Kaminari.paginate_array(resources.to_a, total_count: @count).page(@page).per(@limit)
+      else
+        resources # non html versions just need the raw array
+      end
+    end
+
+    def get_pagination_params
+      default_page_size = 20
+
+      @per_page = (params[:per_page] || default_page_size).to_i
+      @per_page = 10000 if @per_page > 10000
+      @page = (params[:page] || 1).to_i
+
+      @limit = @per_page
+      @offset = @limit.to_i * (@page.to_i-1)
+
+      @got_pagination_params = true
+    end
+
+  end
+end

data/app/controllers/publish_my_data/datasets_controller.rb

@@ -0,0 +1,48 @@
+require_dependency "publish_my_data/application_controller"
+
+module PublishMyData
+  class DatasetsController < ApplicationController
+
+    respond_to :html, :ttl, :rdf, :nt, :json
+
+    # /datasets/:id (where :id is the dataset 'slug')
+    def show
+      @dataset = Dataset.find_by_slug(params[:id])
+      @types = RdfType.where('?s a ?uri').graph(@dataset.data_graph_uri).resources
+
+      if request.format.html?
+        @type_resource_counts = {}
+        @types.each do |t|
+          @type_resource_counts[t.uri.to_s] = Resource.where("?uri a <#{t.uri.to_s}>").count
+        end
+      end
+
+      respond_with(@dataset)
+    end
+
+    # /datasets?page=2&per_page=10
+    # /datasets?theme=foo
+    def index
+      dataset_criteria = Dataset.all
+      dataset_criteria = add_theme_filter(dataset_criteria)
+      @datasets = paginate_resources(dataset_criteria)
+      respond_with(@datasets)
+    end
+
+    def themes
+      # TODO: decide on how the themes will be represented in the metadata.
+      # Get a list of themes.
+      @themes = ['theme1', 'theme2']
+    end
+
+    private
+
+    def add_theme_filter(criteria)
+      unless params[:theme].blank?
+        @theme = params[:theme]
+        criteria.where("?uri <#{PMD_DS.theme}> '#{@theme}'")
+      end
+      criteria
+    end
+  end
+end

data/app/controllers/publish_my_data/errors_controller.rb

@@ -0,0 +1,9 @@
+#http://accuser.cc/posts/1-rails-3-0-exception-handling
+module PublishMyData
+  class ErrorsController < ApplicationController
+    def routing
+      # just re-raise a tripod not found error. Handled in Application Controller
+      raise Tripod::Errors::ResourceNotFound
+    end
+  end
+end

data/app/controllers/publish_my_data/home_controller.rb

@@ -0,0 +1,4 @@
+module PublishMyData
+  class HomeController < ApplicationController
+  end
+end

data/app/controllers/publish_my_data/resources_controller.rb

@@ -0,0 +1,103 @@
+require_dependency "publish_my_data/application_controller"
+
+module PublishMyData
+  class ResourcesController < ApplicationController
+
+    respond_to :html, :ttl, :rdf, :nt, :json
+
+    # /resources
+    # /resources?type=[http://type-uri]&dataset=[dataset-slug]
+    def index
+      resource_criteria = Resource.all
+
+      # TODO: when we get more complicated fitlers, move this out somewhere else.
+      resource_criteria = add_type_filter(resource_criteria)
+      resource_criteria = add_dataset_filter(resource_criteria)
+
+      @resources = paginate_resources(resource_criteria)
+      respond_with(@resources)
+    end
+
+    # /resource?uri=http://foo.bar
+    def show
+      uri = params[:uri]
+      begin
+        # try to look it up
+        @resource = Resource.find(uri)
+        eager_load_labels()
+        respond_with(@resource)
+      rescue Tripod::Errors::ResourceNotFound
+        # if it's not there
+        respond_to do |format|
+          format.html { redirect_to uri }
+          # This is meant for UI browsing only, really. Just 404 for other mimes.
+          format.any { render :nothing => true, :status => 404, :content_type => 'text/plain' }
+        end
+      end
+    end
+
+    # linked data dereferencing:
+    # for id's just redirect to the doc.
+    # http://example.com/id/blah
+    def id
+      respond_to do |format|
+        format.any(:html, :rdf, :ttl, :nt, :json) do |format|
+          redirect_to "/doc/#{params[:path]}", :status=> 303
+        end
+      end
+    end
+
+    # http://example.com/doc/blah
+    def doc
+      uri = Resource.uri_from_host_and_doc_path(request.host, params[:path], params[:format])
+      @resource = Resource.find(uri)
+      eager_load_labels() if request.format.html?
+
+      # TODO: special views like ontology, dataset, etc?
+      respond_with(@resource) do |format|
+        format.html { render :template => 'publish_my_data/resources/show' }
+      end
+    end
+
+    # http://example.com/def/blah
+    def definition
+      uri = 'http://' + request.host + '/def/' + params[:path]
+      @resource = Resource.find(uri)
+      eager_load_labels() if request.format.html?
+
+      # TODO: special views like ontology, dataset, etc?
+      respond_with(@resource) do |format|
+        format.html { render :template => 'publish_my_data/resources/show' }
+      end
+    end
+
+    private
+
+    # TODO: move the filter management into an object
+    def add_type_filter(criteria)
+      unless params[:type_uri].blank?
+        @type_filter = params[:type_uri]
+        @type = RdfType.find(@type_filter) rescue nil
+        criteria.where("?uri a <#{@type_filter}>")
+      end
+      criteria
+    end
+
+    def add_dataset_filter(criteria)
+      unless params[:dataset].blank?
+        @dataset_filter = params[:dataset]
+        @dataset = Dataset.find_by_slug(@dataset_filter) rescue nil
+        criteria.graph(Dataset.data_graph_uri(@dataset_filter))
+      end
+      criteria
+    end
+
+    def eager_load_labels
+      @resource.eager_load_predicate_triples!
+      @resource.eager_load_object_triples!
+    end
+
+  end
+
+
+end

data/app/controllers/publish_my_data/sparql_controller.rb

@@ -0,0 +1,50 @@
+require_dependency "publish_my_data/application_controller"
+
+module PublishMyData
+  class SparqlController < ApplicationController
+
+    rescue_from PublishMyData::SparqlQueryResultTooLargeException, :with => :show_response_too_large_message
+    rescue_from PublishMyData::SparqlQueryExecutionException, :with => :show_sparql_execution_message
+
+    respond_to :html, :csv, :text, :nt, :ttl, :xml, :rdf, :json
+
+    def endpoint
+      @query_text = params[:query]
+
+      unless @query_text.blank?
+        @sparql_query = PublishMyData::SparqlQuery.new(@query_text, request.format.to_sym)
+
+        if @sparql_query.allow_pagination?
+          get_pagination_params
+          @sparql_query_result = @sparql_query.paginate(@page, @per_page)
+          @more_pages = @sparql_query.as_pagination_query(@page, @per_page, 1).count > @per_page if request.format.html?
+        else
+          @sparql_query_result = @sparql_query.execute
+        end
+
+        respond_with(@sparql_query_result)
+      end
+
+    end
+
+    private
+
+    def respond_with_error
+      respond_to do |format|
+        format.html { render 'endpoint' }
+        format.any { head :status => 400 }
+      end
+    end
+
+    def show_response_too_large_message(e)
+      @error_message = "The results for this query are too large to return."
+      respond_with_error
+    end
+
+    def show_sparql_execution_message(e)
+      @error_message = "There was a syntax error in your query: #{e.message}"
+      respond_with_error
+    end
+
+  end
+end

data/app/helpers/publish_my_data/application_helper.rb

@@ -0,0 +1,4 @@
+module PublishMyData
+  module ApplicationHelper
+  end
+end

data/app/helpers/publish_my_data/resources_helper.rb

@@ -0,0 +1,28 @@
+module PublishMyData
+  module ResourcesHelper
+
+    # uses eager loaded data to get the uri or label for a term
+    def resource_uri_or_label(term)
+
+      if term.uri?
+        res = @resource.get_related_resource(term, PublishMyData::Resource)
+        if res
+          link_to((res.label || res.uri.to_s), resource_path_from_uri(res.uri))
+        else
+          link_to term.to_s, resource_path_from_uri(term)
+        end
+      else
+        term.to_s
+      end
+    end
+
+    def resource_path_from_uri(uri)
+      resource = Resource.new(uri)
+      if resource.local?
+        uri.to_s
+      else
+        show_resource_path(:uri => uri.to_s)
+      end
+    end
+  end
+end