publish_my_data 0.0.20 → 0.0.21

data/app/controllers/publish_my_data/datasets_controller.rb

@@ -5,38 +5,6 @@ module PublishMyData
 
     respond_to :html, :ttl, :rdf, :nt, :json, :text
 
-    # /data/:id (where :id is the dataset 'slug')
-    def show
-
-      @dataset = Dataset.find_by_slug(params[:id])
-
-      @dataset.eager_load_object_triples!(:labels_only => true) # for the owner URI label
-
-      @types = RdfType.where('?s a ?uri').graph(@dataset.data_graph_uri).resources
-
-      if is_request_html_format?
-        @type_resource_counts = {}
-        @resources_count = 0
-        @types.each do |t|
-          count_query = "SELECT ?uri WHERE { GRAPH <#{@dataset.data_graph_uri.to_s}> { ?uri a <#{t.uri.to_s}> } }"
-          @type_resource_counts[t.uri.to_s] = SparqlQuery.new(count_query).count
-          @resources_count += @type_resource_counts[t.uri.to_s]
-        end
-
-      end
-
-      respond_with(@dataset)
-    end
-
-    # /data?page=2&per_page=10
-    def index
-      dataset_criteria = Dataset.ordered_datasets_criteria
-      @pagination_params = ResourcePaginationParams.from_request(request)
-      @datasets = Paginator.new(dataset_criteria, @pagination_params).paginate
-      respond_with(@datasets)
-    end
-
-    # /data/:id/dump
     def dump
       s3 = AWS::S3.new
       @dataset = Dataset.find_by_slug(params[:id])
@@ -45,7 +13,7 @@ module PublishMyData
       # Note: filenames on s3 take the format: "dataset_data_<slug>_time.nt.zip"
       # Only look for ones that were made on the same day as the the modified date, to restrict the results
       # (v. small possibility of errors for changes aroung midnight, but unlikely people will be changing datasets then anyway!)
-      prefix = "dataset_data_#{@dataset.slug}_#{@dataset.modified.strftime("%Y%m%d")}"
+      prefix = "dataset_data_#{@dataset.slug.gsub('/', '|')}_#{@dataset.modified.strftime("%Y%m%d")}"
       downloads = s3.buckets[PublishMyData.dataset_downloads_s3_bucket].objects.with_prefix(prefix).to_a
 
       # filter the downloads to only include ones with a timestamp equal to or after the dataset modified date.
@@ -66,5 +34,13 @@ module PublishMyData
       end
     end
 
+    # /data?page=2&per_page=10
+    def index
+      dataset_criteria = Dataset.ordered_datasets_criteria
+      @pagination_params = ResourcePaginationParams.from_request(request)
+      @datasets = Paginator.new(dataset_criteria, @pagination_params).paginate
+      respond_with(@datasets)
+    end
+
   end
 end

data/app/controllers/publish_my_data/information_resources_controller.rb

@@ -0,0 +1,18 @@
+require_dependency "publish_my_data/application_controller"
+
+module PublishMyData
+  class InformationResourcesController < ApplicationController
+
+    respond_to :html, :ttl, :rdf, :nt, :json, :text
+
+    include PublishMyData::Concerns::Controllers::Resource
+
+    def show
+      the_uri = "http://#{PublishMyData.local_domain}/data/#{params[:id]}"
+      puts the_uri
+      render_resource_with_uri(the_uri)
+    end
+
+  end
+
+end

data/app/controllers/publish_my_data/resources_controller.rb

@@ -3,6 +3,8 @@ require_dependency "publish_my_data/application_controller"
 module PublishMyData
   class ResourcesController < ApplicationController
 
+    include PublishMyData::Concerns::Controllers::Resource
+
     respond_to :html, :ttl, :rdf, :nt, :json, :text
 
     # /resources
@@ -66,24 +68,6 @@ module PublishMyData
 
     private
 
-    def render_resource_with_uri(uri)
-      resource = Resource.find(uri)
-
-      if is_request_html_format?
-        resource.eager_load_predicate_triples!(:labels_only => true)
-        resource.eager_load_object_triples!(:labels_only => true)
-      end
-
-      # result = RubyProf.stop
-      # File.open "#{Rails.root}/tmp/profile-graph.html", 'w' do |file|
-      #   RubyProf::CallStackPrinter.new(result).print(file)
-      # end
-
-      respond_with(resource) do |format|
-        format.html { render resource.render_params(request) }
-      end
-    end
-
     # TODO: move the filter management into an object
     def add_type_filter(criteria)
       unless params[:type_uri].blank?

data/app/models/publish_my_data/dataset.rb

@@ -61,6 +61,10 @@ module PublishMyData
 
     class << self
 
+      def uri_from_data_graph_uri(data_graph_uri)
+        data_graph_uri.to_s.gsub("graph/", "data/")
+      end
+
       # this is the graph that dataset metadata goes in.
       def metadata_graph_uri(slug)
         "#{data_graph_uri(slug)}/metadata"
@@ -71,6 +75,10 @@ module PublishMyData
         "http://#{PublishMyData.local_domain}/graph/#{slug}"
       end
 
+      def uri_from_data_graph_uri(data_graph_uri)
+        data_graph_uri.to_s.sub("/graph/", "/data/")
+      end
+
       def find_by_slug(slug)
         Dataset.find(uri_from_slug(slug))
       end
@@ -80,11 +88,8 @@ module PublishMyData
       end
 
       def slug_from_uri(uri)
-        uri.to_s.split('/').last
-      end
-
-      def slug_from_data_graph_uri(data_graph_uri)
-        data_graph_uri.to_s.split("/").last
+        root_uri = uri_from_slug('')
+        uri.to_s.gsub(root_uri, '')
       end
 
       def ordered_datasets_criteria

data/app/models/publish_my_data/resource.rb

@@ -16,14 +16,18 @@ module PublishMyData
     end
 
     def dataset
-      slug = Dataset.slug_from_data_graph_uri(self.graph_uri)
-      Dataset.find_by_slug(slug) rescue nil
+      Dataset.find(Dataset.uri_from_data_graph_uri(self.graph_uri)) rescue nil
     end
 
     # this calls render_params on the right type of RenderParams object.
     # (strategy pattern-ish).
     def render_params(request)
-      render_params_class.new(self).render_params(pagination_params: ResourcePaginationParams.from_request(request))
+      is_html = (request.format.to_sym || :html) == :html
+      render_params_class.new(self).
+        render_params(
+          pagination_params: ResourcePaginationParams.from_request(request),
+          is_html: is_html
+        )
     end
 
     # Don't worry that these as_xxx methods look like they'll do an extra lookup.
@@ -36,6 +40,10 @@ module PublishMyData
       r
     end
 
+    def as_dataset
+      as_resource_of_class(Dataset)
+    end
+
     def as_ontology
       as_resource_of_class(Ontology)
     end
@@ -56,6 +64,10 @@ module PublishMyData
       as_resource_of_class(OntologyClass)
     end
 
+    def is_dataset?
+      read_type_predicate.include?(RDF::PMD_DS.Dataset)
+    end
+
     def is_ontology?
       read_type_predicate.include?(RDF::OWL.Ontology)
     end
@@ -83,7 +95,9 @@ module PublishMyData
     end
 
     def render_params_class
-      if self.is_ontology?
+      if self.is_dataset?
+        DatasetRenderParams
+      elsif self.is_ontology?
         OntologyRenderParams
       elsif self.is_class?
         OntologyClassRenderParams

data/app/views/publish_my_data/datasets/index.html.erb

@@ -6,7 +6,7 @@
 <% end %>
 
 <% @datasets.each do |d| %>
-  <%= link_to d.title, d.uri.to_s %> <br/>
+  <%= link_to d.title, d %> <br/>
 <% end %>
 
 <%= paginate @datasets %>

data/app/views/publish_my_data/datasets/show.html.erb

@@ -1,12 +1,12 @@
-<h1>Dataset: <%= @dataset.title %></h1>
+<h1>Dataset: <%= dataset.title %></h1>
 
-<%= @dataset.description %>
+<%= dataset.description %>
 
 <h2> Types in this ds</h2>
 
-<% @types.each do |t| %>
+<% types.each do |t| %>
   <%= link_to t.label || t.uri, resource_path_from_uri(t.uri) %>
-  (<%= link_to "#{@type_resource_counts[t.uri.to_s]} resources", list_resources_path(dataset: @dataset.slug, type_uri: t.uri)%>)
+  (<%= link_to "#{type_resource_counts[t.uri.to_s]} resources", list_resources_path(dataset: dataset.slug, type_uri: t.uri)%>)
   <br/>
 <% end %>
 

data/config/routes.rb

@@ -7,11 +7,12 @@ PublishMyData::Engine.routes.draw do
   match "/resources(.:format)" => "resources#index", :as => 'list_resources' # +filters on thh query string
 
   # datasets
-  match "/data/:id(.:format)" => "datasets#show", :as => 'dataset'
-  match "/data/:id/dump" => "datasets#dump", :as => 'dataset_dump'
-  match "/data(.:format)" => "datasets#index",  :as => 'datasets'
 
-  resources :datasets, :only => [:index, :show]
+  # note that the separate .:format and no-format verisons allow extensions like .json on the end of the uri not to be globbed as the *id
+  match "/data/*id/dump" => "datasets#dump", :as => 'dataset_dump'
+  match "/data/*id.:format" => "information_resources#show"
+  match "/data/*id" => "information_resources#show", :as => 'dataset'
+  match "/data(.:format)" => "datasets#index",  :as => 'datasets'
 
   # themes
   resources :themes, :only => [:index, :show]

data/lib/publish_my_data/concerns/controllers/resource.rb

@@ -0,0 +1,23 @@
+module PublishMyData
+  module Concerns
+    module Controllers
+      module Resource
+        extend ActiveSupport::Concern
+
+        included do
+
+          private
+
+          def render_resource_with_uri(uri)
+            resource = PublishMyData::Resource.find(uri)
+
+            respond_with(resource) do |format|
+              format.html { render resource.render_params(request) }
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/publish_my_data/concerns.rb

@@ -1,2 +1,4 @@
 require "publish_my_data/concerns/models/resource"
+
+require "publish_my_data/concerns/controllers/resource"
 require "publish_my_data/concerns/controllers/sparql"

data/lib/publish_my_data/render_params/concept_render_params.rb

@@ -7,6 +7,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @concept.eager_load_predicate_triples!(:labels_only => true)
+        @concept.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/concepts/show', locals: {concept: @concept}}
     end
 

data/lib/publish_my_data/render_params/concept_scheme_render_params.rb

@@ -7,6 +7,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @concept_scheme.eager_load_predicate_triples!(:labels_only => true)
+        @concept_scheme.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/concept_schemes/show', locals: {concept_scheme: @concept_scheme}}
     end
 

data/lib/publish_my_data/render_params/dataset_render_params.rb

@@ -0,0 +1,34 @@
+module PublishMyData
+  class DatasetRenderParams
+
+    def initialize(resource)
+      @resource = resource
+      @dataset = resource.as_dataset
+    end
+
+    def render_params(opts={})
+
+      if opts[:is_html]
+        @types = RdfType.where('?s a ?uri').graph(@dataset.data_graph_uri).resources
+        @dataset.eager_load_object_triples!(:labels_only => true) # for the owner URI label
+        @type_resource_counts = {}
+        @resources_count = 0
+        @types.each do |t|
+          count_query = "SELECT ?uri WHERE { GRAPH <#{@dataset.data_graph_uri.to_s}> { ?uri a <#{t.uri.to_s}> } }"
+          @type_resource_counts[t.uri.to_s] = SparqlQuery.new(count_query).count
+          @resources_count += @type_resource_counts[t.uri.to_s]
+        end
+      end
+
+      {
+        template: 'publish_my_data/datasets/show', locals: {
+          dataset: @dataset,
+          types: @types,
+          type_resource_counts: @type_resource_counts,
+          resources_count: @resources_count
+        }
+      }
+    end
+
+  end
+end

data/lib/publish_my_data/render_params/ontology_class_render_params.rb

@@ -7,6 +7,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @ontology_class.eager_load_predicate_triples!(:labels_only => true)
+        @ontology_class.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/classes/show', locals: {ontology_class: @ontology_class}}
     end
 

data/lib/publish_my_data/render_params/ontology_render_params.rb

@@ -7,6 +7,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @ontology.eager_load_predicate_triples!(:labels_only => true)
+        @ontology.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/ontologies/show', locals: {ontology: @ontology}}
     end
 

data/lib/publish_my_data/render_params/property_render_params.rb

@@ -7,6 +7,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @resource.eager_load_predicate_triples!(:labels_only => true)
+        @resource.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/properties/show', locals: {property: @property}}
     end
 

data/lib/publish_my_data/render_params/resource_render_params.rb

@@ -6,6 +6,12 @@ module PublishMyData
     end
 
     def render_params(opts={})
+
+      if opts[:is_html]
+        @resource.eager_load_predicate_triples!(:labels_only => true)
+        @resource.eager_load_object_triples!(:labels_only => true)
+      end
+
       {template: 'publish_my_data/resources/show', locals: {resource: @resource}}
     end
 

data/lib/publish_my_data/render_params/theme_render_params.rb

@@ -7,7 +7,7 @@ module PublishMyData
     end
 
     # e.g. opts[:pagination_params] => ResourcePaginationParams.new
-    def render_params(opts)
+    def render_params(opts={})
       datasets = Paginator.new(@theme.datasets_criteria, opts[:pagination_params]).paginate
       {
          template: 'publish_my_data/themes/show',

data/lib/publish_my_data/render_params.rb

@@ -1,3 +1,4 @@
+require "publish_my_data/render_params/dataset_render_params"
 require "publish_my_data/render_params/resource_render_params"
 require "publish_my_data/render_params/ontology_render_params"
 require "publish_my_data/render_params/theme_render_params"

data/lib/publish_my_data/version.rb

@@ -1,3 +1,3 @@
 module PublishMyData
-  VERSION = "0.0.20"
+  VERSION = "0.0.21"
 end

data/spec/controllers/publish_my_data/datasets_controller_spec.rb

@@ -3,96 +3,6 @@ require 'spec_helper'
 module PublishMyData
   describe DatasetsController do
 
-    describe "#show" do
-
-      let(:dataset) { FactoryGirl.create(:my_dataset) }
-
-      shared_examples_for "dataset show" do
-
-        context "for an existing dataset" do
-          it "should respond successfully" do
-            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
-            response.should be_success
-          end
-
-          it "should set the types variable" do
-            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
-            assigns['types'].class.should == Tripod::ResourceCollection
-          end
-        end
-
-        context "with a non-existent dataset slug" do
-          it "should respond with not found" do
-            get :show, id: "slug-that-doesnt-exist", use_route: :publish_my_data, :format => format
-            response.should be_not_found
-          end
-        end
-      end
-
-      shared_examples_for "a non html format" do
-
-        context "for an existing dataset" do
-          it "should return the dataset dtls in that format" do
-            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
-            response.body.should == dataset.send("to_#{format}")
-          end
-        end
-
-        context "for a non-existent dataset slug" do
-          it "should return a blank body" do
-            get :show, id: "slug-that-doesnt-exist", use_route: :publish_my_data, :format => format
-            response.body.should == "Not Found"
-          end
-        end
-      end
-
-      context "for rdf format" do
-        let(:format){ 'html' }
-        it_should_behave_like "dataset show"
-      end
-
-      context "for rdf format" do
-        let(:format){ 'rdf' }
-        it_should_behave_like "a non html format"
-        it_should_behave_like "dataset show"
-      end
-
-      context "for json format" do
-        let(:format){ 'json' }
-
-        # note: we don't use the shared example group here because the JSON format sometimes brings stuff back in different orders!
-
-        context "for an existing dataset" do
-          it "should return the dataset dtls in that format" do
-            get :show, id: dataset.slug, use_route: :publish_my_data, :format => format
-            JSON.parse(response.body).should == JSON.parse(dataset.send("to_#{format}"))
-          end
-        end
-
-        context "for a non-existent dataset slug" do
-          it "should return a blank body" do
-            get :show, id: "slug-that-doesnt-exist", use_route: :publish_my_data, :format => format
-            response.body.should == "Not Found"
-          end
-        end
-
-        it_should_behave_like "dataset show"
-      end
-
-      context "for ttl format" do
-        let(:format){ 'ttl' }
-        it_should_behave_like "a non html format"
-        it_should_behave_like "dataset show"
-      end
-
-      context "for ntriples format" do
-        let(:format){ 'nt' }
-        it_should_behave_like "a non html format"
-        it_should_behave_like "dataset show"
-      end
-
-    end
-
     describe "#index" do
 
       # make some datasets
@@ -200,7 +110,7 @@ module PublishMyData
         bucket.clear! # wipe the bucket
       end
 
-      context "when a dataset with the slug exists" do
+      context "and a dataset with the slug exists" do
 
         let(:dataset) { FactoryGirl.create(:my_dataset) }
 
@@ -211,18 +121,19 @@ module PublishMyData
             s3 = AWS::S3.new
             bucket = s3.buckets[PublishMyData.dataset_downloads_s3_bucket]
 
-            @obj1 = bucket.objects.create("dataset_data_#{dataset.slug}_201007011200.nt.zip", 'data')
-            @obj2 = bucket.objects.create("dataset_data_#{dataset.slug}_201007011201.nt.zip", 'data')
-            @obj3 = bucket.objects.create("dataset_data_#{dataset.slug}_201007011202.nt.zip", 'data')
+            @obj1 = bucket.objects.create("dataset_data_my|dataset_201007011200.nt.zip", 'data')
+            @obj2 = bucket.objects.create("dataset_data_my|dataset_201007011201.nt.zip", 'data')
+            @obj3 = bucket.objects.create("dataset_data_my|dataset_201007011202.nt.zip", 'data')
             # this one's on another day:
-            @obj4 = bucket.objects.create("dataset_data_#{dataset.slug}_201007021202.nt.zip", 'data')
+            @obj4 = bucket.objects.create("dataset_data_my|dataset_201007021202.nt.zip", 'data')
 
             # make them public readable
             [@obj1, @obj2, @obj3].each { |o| o.acl = :public_read }
           end
 
           it "should redirect to the latest download that exists for that dataset" do
-            get "dump", :id => dataset.slug, :use_route => :publish_my_data
+            get :dump, :id => dataset.slug, :use_route => :publish_my_data
+            puts assigns[:dataset].inspect
             response.should be_redirect
             response.should redirect_to(@obj3.public_url.to_s)
           end
@@ -243,7 +154,7 @@ module PublishMyData
           end
 
           it "should 404" do
-            get "dump", :id => dataset.slug, :use_route => :publish_my_data
+            get :dump, :id => dataset.slug, :use_route => :publish_my_data
             response.should be_not_found
           end
 
@@ -251,7 +162,7 @@ module PublishMyData
 
         context "when a download doesn't exist on s3" do
           it "should 404" do
-            get "dump", :id => dataset.slug, :use_route => :publish_my_data
+            get :dump, :id => dataset.slug, :use_route => :publish_my_data
             response.should be_not_found
           end
         end
@@ -260,12 +171,12 @@ module PublishMyData
 
       context "when a dataset with that slug doesn't exist" do
         it "should 404" do
-          get "dump", :id => 'foo', :use_route => :publish_my_data
+          get :dump, :id => "i-dont-exist", :use_route => :publish_my_data
           response.should be_not_found
         end
       end
 
-    end
 
+    end
   end
 end