publish_my_data 0.0.30 → 0.0.31

data/app/controllers/concerns/publish_my_data/sparql_processing.rb

@@ -5,8 +5,8 @@ module PublishMyData
     included do
 
       rescue_from PublishMyData::SparqlQueryExecutionException, :with => :show_sparql_execution_message
-
-      rescue_from PublishMyData::SparqlQueryMissingVariablesException, :with => :missing_variables
+      rescue_from PublishMyData::SparqlQueryReservedVariablesException, :with => :reserved_variables
+      rescue_from Tripod::SparqlQueryMissingVariables, :with => :missing_variables
 
       respond_to :html, :csv, :text, :nt, :ttl, :xml, :rdf, :json
 
@@ -20,11 +20,14 @@ module PublishMyData
       end
 
       def build_sparql_query(query_text)
-        interpolations = request.params.reject{ |p| ['controller', 'action', 'page', 'per_page', 'id', 'commit' ,'utf8', 'query'].include?(p) }
-        PublishMyData::SparqlQuery.new(query_text, {
+        @sparql_query = PublishMyData::SparqlQuery.new(query_text, {
           :request_format => request.format.to_sym,
-          :interpolations => interpolations
+          :interpolations => request.params.clone
         })
+
+        @expected_variables = @sparql_query.expected_variables
+        @interpolations = @sparql_query.interpolations
+        # note: if there are missing variables, then this will be caught by them missing_variables error handler
       end
 
       # process the sparql query, paginating if appropriate
@@ -60,6 +63,17 @@ module PublishMyData
       end
 
       def missing_variables(e)
+        @missing_variables = e.missing_variables
+        @expected_variables = e.expected_variables
+        @interpolations = e.received_variables
+        @error_message = e.message
+        respond_with_error
+      end
+
+      def reserved_variables(e)
+        @reserved_variables_used = e.reserved_variables
+        @expected_variables = e.expected_variables
+        @interpolations = e.interpolations
         @error_message = e.message
         respond_with_error
       end

data/app/controllers/publish_my_data/sparql_controller.rb

@@ -16,7 +16,7 @@ module PublishMyData
           render :text => "no query supplied", :status => 400
         end
       else
-        @sparql_query = build_sparql_query(@query_text)
+        build_sparql_query(@query_text)
         @sparql_query_result = process_sparql_query(@sparql_query)
         respond_with(@sparql_query_result)
       end

data/lib/publish_my_data/sparql_query.rb

@@ -2,27 +2,29 @@ module PublishMyData
 
   class SparqlQueryExecutionException < StandardError; end
 
-  class SparqlQueryMissingVariablesException < StandardError
-    attr_reader :missing_variables, :expected_variables
+  class SparqlQueryReservedVariablesException < StandardError
+    attr_reader :reserved_variables, :expected_variables, :interpolations
 
-    def initialize(missing_variables, expected_variables)
-      raise ArgumentError.new("Missing parameters should be an array") unless missing_variables.is_a?(Array)
-      @missing_variables = missing_variables
+    def initialize(reserved_variables, expected_variables, interpolations)
+      @reserved_variables = reserved_variables
       @expected_variables = expected_variables
+      @interpolations = interpolations
     end
 
     def to_s
-      "Missing parameters for interpolation: #{@missing_variables.map(&:to_s).join(', ')}"
+      "Reserved tokens used: #{@reserved_variables.map(&:to_s).join(', ')}"
     end
   end
 
   class SparqlQuery < Tripod::SparqlQuery
 
+    @@reserved_variables = [:controller, :action, :page, :per_page, :id, :commit ,:utf8, :query]
+    cattr_reader :reserved_variables
+
     attr_reader :request_format # symbol representing the format of the original request
     attr_reader :parent_query # set if this query originated from another (e.g. pagination or count)
-
-    attr_reader :interpolations # interpolations supplied at construct-time
-    attr_reader :expected_variables # list of variables used in the query,
+    attr_reader :expected_variables # tokens that appear in the query
+    attr_reader :interpolations # interpolations supplied at construct time
 
     # options
     #  :request_format (symbol, e.g. :html, :json )
@@ -31,12 +33,11 @@ module PublishMyData
     def initialize(query_string, opts={})
       @opts = opts # save off the original opts
 
-      @interpolations = opts[:interpolations] || {}
-
-      # modify the query string, before constructing
-      query_string = interpolate_query(query_string, self.interpolations)
+      @interpolations = (opts[:interpolations] || {}).delete_if{ |k,v| self.class.reserved_variables.include?(k.to_sym) }
+      @expected_variables = self.class.get_expected_variables(query_string)
+      check_reserved_variables!
 
-      super(query_string)
+      super(query_string, @interpolations)
 
       @parent_query = opts[:parent_query]
       @request_format = opts[:request_format] || :html
@@ -113,21 +114,16 @@ LIMIT #{limit} OFFSET #{offset}"
       PublishMyData::SparqlQuery.new(paginated_query, {:request_format => self.request_format, :parent_query => self}) # pass in the original query
     end
 
-    def self.get_expected_variables(query_string)
-      query_string.scan(/[.]?\%\{(\w+)\}[.]?/).flatten.uniq.map &:to_sym
-    end
-
     private
 
-    def interpolate_query(query_string, interpolations)
-      i = interpolations.symbolize_keys.select{ |k,v| v && v.length > 0 }
-      # regular expression finds words inside %{variable} tokens
-      @expected_variables = self.class.get_expected_variables(query_string)
-      missing_variables = @expected_variables - i.keys
-      if missing_variables.length > 0
-        raise SparqlQueryMissingVariablesException.new(missing_variables, @expected_variables)
+    def check_reserved_variables!
+      if @expected_variables && @expected_variables.any? # this will be set by the base class
+
+        reserved_variables_used = (@expected_variables & SparqlQuery.reserved_variables)
+        if reserved_variables_used.any?
+          raise SparqlQueryReservedVariablesException.new(reserved_variables_used, @expected_variables, @interpolations)
+        end
       end
-      query_string % i # do the interpolating
     end
 
     def process_sparql_parse_failed_exception_message(bad_sparql_request)

data/lib/publish_my_data/version.rb

@@ -1,3 +1,3 @@
 module PublishMyData
-  VERSION = "0.0.30"
+  VERSION = "0.0.31"
 end

data/spec/controllers/publish_my_data/sparql_controller_spec.rb

@@ -74,6 +74,105 @@ module PublishMyData
 
         end
 
+        context "where the query expects parameters" do
+          let(:query) {"select * where {?s ?%{p} ?%{o}}"}
+
+          it "should assign the expected_variables" do
+            get :endpoint, query: query, use_route: :publish_my_data
+            assigns['expected_variables'].should == [:p, :o]
+          end
+
+          context "when a reserved parameter is used" do
+
+            # page is reserved.
+            let(:query) {"select * where {?s ?%{page} ?%{o}}"}
+            let (:parameters) { {:query => query, :o => 'oh', :page => 1, use_route: :publish_my_data} }
+
+            it "should assign the reserved_variables_used" do
+              get :endpoint, parameters
+              assigns['reserved_variables_used'].should == [:page]
+            end
+
+            context "for html format" do
+              before { get :endpoint, parameters }
+
+              it 'should respond with success' do
+                response.should be_success
+              end
+
+              it 'should assign the error message' do
+                assigns['error_message'].should == "Reserved tokens used: page"
+              end
+            end
+
+            context "for non-html format" do
+              before { get :endpoint, parameters.merge(format:'json') }
+
+              it 'should respond with a 400' do
+                response.code.should == "400"
+              end
+
+              it 'should include a message in the body' do
+                response.body.should == "Reserved tokens used: page"
+              end
+            end
+
+          end
+
+          context "when all parameters supplied" do
+            let (:parameters) { {:query => query, :o => 'oh', :p => 'pee', use_route: :publish_my_data} }
+
+            it "should set the interpolations" do
+              get :endpoint, parameters
+              assigns['interpolations'].should == {"o" => 'oh', "p" => 'pee'}
+            end
+
+            it "should respond successfully" do
+              get :endpoint, parameters
+              response.should be_success
+            end
+          end
+
+          context "when some parameters missing" do
+            let (:parameters) { {:query => query, :o => 'oh', use_route: :publish_my_data} }
+
+            it "should set the missing_variables" do
+              get :endpoint, parameters
+              assigns['missing_variables'].should == [:p]
+            end
+
+            it "should set the interpolations" do
+              get :endpoint, parameters
+              assigns['interpolations'].should == {"o" => 'oh'}
+            end
+
+            context "for html format" do
+              before { get :endpoint, parameters }
+              it 'should respond with success' do
+                response.should be_success
+              end
+
+              it 'should assign the error message' do
+                assigns['error_message'] = "Missing parameters: p"
+              end
+            end
+
+            context "for non-html format" do
+              before { get :endpoint, parameters.merge(format:'json') }
+
+              it 'should respond with a 400' do
+                response.code.should == "400"
+              end
+
+              it 'should include a message in the body' do
+                response.body.should == "Missing parameters: p"
+              end
+            end
+
+          end
+
+        end
+
         context "non-html queries" do
           context 'for SELECTs' do