publish_my_data 0.0.28 → 0.0.29

data/app/controllers/publish_my_data/datasets_controller.rb

@@ -36,9 +36,8 @@ module PublishMyData
 
     # /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
+      @datasets = Paginator.new(Dataset.deprecation_last_query_str, @pagination_params, resource_class: PublishMyData::Dataset).paginate
       respond_with(@datasets)
     end
 

data/app/controllers/publish_my_data/resources_controller.rb

@@ -18,6 +18,7 @@ module PublishMyData
 
       @pagination_params = ResourcePaginationParams.from_request(request)
       @resources = Paginator.new(resource_criteria, @pagination_params).paginate
+
       respond_with(@resources)
     end
 

data/app/controllers/publish_my_data/themes_controller.rb

@@ -16,7 +16,7 @@ module PublishMyData
 
       if @theme
         @pagination_params = ResourcePaginationParams.from_request(request)
-        @datasets = Paginator.new(@theme.datasets_criteria, @pagination_params).paginate
+        @datasets = Paginator.new(@theme.datasets_query_str, @pagination_params, resource_class: PublishMyData::Dataset).paginate
         respond_with(@datasets)
       else
         raise Tripod::Errors::ResourceNotFound

data/app/models/publish_my_data/dataset.rb

@@ -103,6 +103,33 @@ module PublishMyData
       def ordered_datasets_criteria
         Dataset.all.where("?uri <#{RDF::DC.title}> ?title").order("?title")
       end
+
+      def deprecation_last_query_str
+        "
+        SELECT ?uri where {
+          # this bit is all the non-deprecated ones
+          {
+            SELECT * WHERE {
+              ?uri a <http://publishmydata.com/def/dataset#Dataset> .
+              ?uri <#{RDF::DC.title}> ?title . # select title so we can order
+              MINUS {
+                ?uri a <http://publishmydata.com/def/dataset#DeprecatedDataset>
+              }
+            }
+            ORDER BY ?title
+          }
+          UNION
+          # this bit is all the deprecated ones
+          {
+            SELECT * WHERE {
+              ?uri a <http://publishmydata.com/def/dataset#DeprecatedDataset> .
+              ?uri <#{RDF::DC.title}> ?title . # select title so we can order
+            }
+            ORDER BY ?title
+          }
+        }
+        "
+      end
     end
   end
 end

data/app/models/publish_my_data/theme.rb

@@ -22,10 +22,38 @@ module PublishMyData
     field :slug, RDF::SKOS.notation
     field :comment, RDF::RDFS.comment
 
-    def datasets_criteria
-      Dataset
-        .ordered_datasets_criteria
-        .where("?uri <#{RDF::DCAT.theme}> <#{self.uri.to_s}>")
+    def datasets_count
+      PublishMyData::SparqlQuery.new(datasets_query_str).count
+    end
+
+    def datasets_query_str
+      # this is similar to the deprecation_last_query_str, but with a theme restriction
+      "
+      SELECT ?uri where {
+        # this bit is all the non-deprecated ones
+        {
+          SELECT * WHERE {
+            ?uri a <http://publishmydata.com/def/dataset#Dataset> .
+            ?uri <#{RDF::DCAT.theme}> <#{self.uri.to_s}> . # limit to this theme
+            ?uri <#{RDF::DC.title}> ?title . # select title so we can order
+            MINUS {
+              ?uri a <http://publishmydata.com/def/dataset#DeprecatedDataset>
+            }
+          }
+          ORDER BY ?title
+        }
+        UNION
+        # this bit is all the deprecated ones
+        {
+          SELECT * WHERE {
+            ?uri a <http://publishmydata.com/def/dataset#DeprecatedDataset> .
+            ?uri <#{RDF::DCAT.theme}> <#{self.uri.to_s}> . # limit to this theme
+            ?uri <#{RDF::DC.title}> ?title . # select title so we can order
+          }
+          ORDER BY ?title
+        }
+      }
+      "
     end
 
     def to_param

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

@@ -1,7 +1,7 @@
 <h1>Themes</h1>
 
 <% @themes.each do |t| %>
-  <%= link_to (t.label || t.uri), theme_path(t) %> (<%= pluralize( t.datasets_criteria.count, "dataset" )%>)
+  <%= link_to (t.label || t.uri), theme_path(t) %> (<%= pluralize( t.datasets_count, "dataset" )%>)
   <%= t.comment %>
 <% end %>
 

data/lib/publish_my_data/paginator.rb

@@ -49,38 +49,55 @@ module PublishMyData
   class Paginator
 
     attr_accessor :pagination_params
-    attr_accessor :criteria
+    attr_accessor :resource_class
+    attr_accessor :sparql_query # PublishMyData::SparqlQuery
+
+    # criteria can be a Tripod::Criteria or a sparql string.
+    # pagination_params should be an instance pagination params.
+    # if criteria is a sparql string, optionally pass options[:resource_class] to dictate what type of objects to return (else it will return Resources)
+    def initialize(criteria, pagination_params, opts={})
+
+      if criteria.class == String
+        self.sparql_query = PublishMyData::SparqlQuery.new(criteria)
+        self.resource_class = opts[:resource_class] || PublishMyData::Resource
+      elsif criteria.class == Tripod::Criteria
+        # Note that this uses the :return_graph => false option for criteria execution to avoid duplicate graphs in the results
+        self.sparql_query = PublishMyData::SparqlQuery.new(criteria.as_query(:return_graph => false))
+        self.resource_class = criteria.resource_class
+      end
 
-    def initialize(criteria, pagination_params)
-      self.criteria = criteria
       self.pagination_params = pagination_params
     end
 
-    # returns a Kaminari paginatable array, or a plain old array
-    # Note that this uses the :return_graph => false option for criteria execution to avoid duplicate graphs in the results
-    # (which could mess with the pagination counts)
-    # optionally pass an integer to use for the total count.
-    def paginate(total_count=nil)
-      if self.pagination_params.format == :html && pagination_params.per_page && pagination_params.page
-        count = total_count || criteria.count #this has to happen first, before we modify the criteria with limit/offset
-        add_limit_and_offset_criteria(criteria)
-        paginatable = Kaminari.paginate_array(criteria.resources(:return_graph => false).to_a, total_count: count).page(self.pagination_params.page).per(self.pagination_params.per_page)
+    # returns a Kaminari paginatable array (for html), or a plain old array (for data formats)
+    def paginate(force_total_count=nil)
+
+      page = self.pagination_params.page
+      per_page = self.pagination_params.per_page
+      pagination_query_str = self.sparql_query.as_pagination_query(page, per_page).query
+
+      if self.pagination_params.format == :html
+        total_count = force_total_count || self.sparql_query.count
+        page_of_results = resource_class.find_by_sparql(pagination_query_str)
+        Kaminari.paginate_array(page_of_results, total_count: total_count).page(page).per(per_page)
       else
-        add_limit_and_offset_criteria(criteria)
-        criteria.resources(:return_graph => false) # non html versions just need the raw array
+        page_of_results = resource_class.find_by_sparql(pagination_query_str)
+
+        Tripod::ResourceCollection.new(
+          page_of_results,
+          :return_graph => false,
+          :sparql_query_str => pagination_query_str,
+          :resource_class => self.resource_class
+        )
+
       end
+
     end
 
     def ==(other)
       self.pagination_params == other.pagination_params &&
-        self.criteria == other.criteria
-    end
-
-    private
-
-    def add_limit_and_offset_criteria(criteria)
-      criteria.limit(self.pagination_params.per_page) if self.pagination_params.per_page
-      criteria.offset(self.pagination_params.offset) if self.pagination_params.offset
+        self.sparql_query == other.sparql_query  &&
+        self.resource_class == self.resource_class
     end
 
   end

data/lib/publish_my_data/render_params.rb

@@ -1,7 +1,6 @@
 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"
 require "publish_my_data/render_params/property_render_params"
 require "publish_my_data/render_params/ontology_class_render_params"
 require "publish_my_data/render_params/concept_scheme_render_params"

data/lib/publish_my_data/sparql_query.rb

@@ -91,7 +91,6 @@ module PublishMyData
     end
 
     def as_count_query(format = :json)
-      # return the paginated version
       PublishMyData::SparqlQuery.new(as_count_query_str, {:request_format => format, :parent_query => self}) # pass in the original query
     end
 

data/lib/publish_my_data/version.rb

@@ -1,3 +1,3 @@
 module PublishMyData
-  VERSION = "0.0.28"
+  VERSION = "0.0.29"
 end

data/spec/controllers/publish_my_data/datasets_controller_spec.rb

@@ -20,7 +20,18 @@ module PublishMyData
       shared_examples_for "a dataset collection in non-html" do
         it "should render the collection in the right format" do
           get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
-          response.body.should == Dataset.ordered_datasets_criteria.limit(per_page).offset(offset).resources.send("to_#{format}")
+
+          q = SparqlQuery.new(Dataset.deprecation_last_query_str).as_pagination_query(page, per_page).query
+          datasets_array = Dataset.find_by_sparql(q).to_a
+
+          collection = Tripod::ResourceCollection.new(
+            datasets_array,
+            :return_graph => false,
+            :sparql_query_str => q,
+            :resource_class => Dataset
+          )
+
+          response.body.should == collection.send("to_#{format}")
         end
 
         it "shouldn't call Kaminari" do
@@ -36,21 +47,26 @@ module PublishMyData
 
       shared_examples_for "dataset kaminari pagination" do
         it "should call kaminari to paginate the results" do
-          datasets_array = Dataset.ordered_datasets_criteria.limit(per_page).offset(offset).resources.to_a
+          q = SparqlQuery.new(Dataset.deprecation_last_query_str).as_pagination_query(page, per_page).query
+          datasets_array = Dataset.find_by_sparql(q).to_a
           count = Dataset.count
 
           kam = Kaminari.paginate_array(datasets_array, total_count: count)
-
           Kaminari.should_receive(:paginate_array).with(datasets_array, total_count: count).and_return(kam)
           kam.should_receive(:page).with(page).and_return(kam)
           kam.should_receive(:per).with(per_page).and_return(kam)
+
           get :index, page: page, per_page: per_page, use_route: :publish_my_data
         end
 
         it "should set @datasets with the right page of datasets" do
           get :index, page: page, per_page: per_page, use_route: :publish_my_data
+
+          datasets = Dataset.find_by_sparql(Dataset.deprecation_last_query_str)
+
           assigns['datasets'].map{ |d| d.uri.to_s }.should ==
-            Dataset.ordered_datasets_criteria.resources[offset...offset+per_page].map{ |d| d.uri.to_s }
+            datasets[offset...offset+per_page].map{ |d| d.uri.to_s }
+
           assigns['datasets'].length.should == per_page
         end
 
@@ -62,10 +78,7 @@ module PublishMyData
         let(:offset) { (page-1)*per_page }
 
         it "should retreive the first page of results" do
-          crit = Dataset.ordered_datasets_criteria
-          Dataset.should_receive(:ordered_datasets_criteria).at_least(:once).and_return(crit)
-          crit.should_receive(:limit).with(per_page).and_call_original
-          crit.should_receive(:offset).with(offset).and_call_original
+          PublishMyData::SparqlQuery.any_instance.should_receive(:as_pagination_query).with(page, per_page)
           get :index, use_route: :publish_my_data
         end
 
@@ -85,10 +98,7 @@ module PublishMyData
         let(:offset) { (page-1)*per_page }
 
         it "should retreive the right page of results" do
-          crit = Dataset.ordered_datasets_criteria
-          Dataset.should_receive(:ordered_datasets_criteria).at_least(:once).and_return(crit)
-          crit.should_receive(:limit).with(per_page).and_call_original
-          crit.should_receive(:offset).with(offset).and_call_original
+          PublishMyData::SparqlQuery.any_instance.should_receive(:as_pagination_query).with(page, per_page)
           get :index, page: page, per_page: per_page, use_route: :publish_my_data
         end
 

data/spec/controllers/publish_my_data/resources_controller_spec.rb

@@ -286,6 +286,7 @@ module PublishMyData
       shared_examples_for "a resource collection in non-html" do
         it "should render the collection in the right format" do
           get :index, :page => page, :per_page => per_page, :format => format, use_route: :publish_my_data
+          puts format
           response.body.should == Resource.all.limit(per_page).offset(offset).resources.send("to_#{format}")
         end
 
@@ -350,10 +351,7 @@ module PublishMyData
         let(:offset) { (page-1)*per_page }
 
         it "should retreive the right page of results" do
-          crit = Resource.all
-          Resource.should_receive(:all).at_least(:once).and_return(crit)
-          crit.should_receive(:limit).with(per_page).and_call_original
-          crit.should_receive(:offset).with(offset).and_call_original
+          PublishMyData::SparqlQuery.any_instance.should_receive(:as_pagination_query).with(page, per_page)
           get :index, page: page, per_page: per_page, use_route: :publish_my_data
         end
 

data/spec/controllers/publish_my_data/themes_controller_spec.rb

@@ -53,7 +53,7 @@ module PublishMyData
         it "should respond with the paginated collection of datasets in that theme" do
           get :show, :id => theme.slug, :use_route => :publish_my_data, :format => 'ttl', :per_page => 5
           pagination_params = ResourcePaginationParams.from_request(@request)
-          paginator = Paginator.new(theme.datasets_criteria, ResourcePaginationParams.from_request(@request))
+          paginator = Paginator.new(theme.datasets_query_str, ResourcePaginationParams.from_request(@request), resource_class: PublishMyData::Dataset)
           paginator.paginate.length.should == 5 #just the page's worth
           response.body.should == paginator.paginate.to_ttl
         end