ruby_odata 0.1.6 → 0.2.0.beta1

data/features/step_definitions/pickle_steps.rb

@@ -22,12 +22,12 @@ end
 
 # not find a model
 Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should be_nil
+  expect(find_model(name, fields)).to be_nil
 end
 
 # find models with a table
 Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
-  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+  expect(find_models_from_table(plural_factory, table)).to_not be_any(&:nil?)
 end
 
 # find exactly n models
@@ -42,7 +42,7 @@ end
 
 # assert model is in another model's has_many assoc
 Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model_with_associations(owner).send(association).should include(model!(target))
+  expect(model_with_associations(owner).send(association)).to include(model!(target))
 end
 
 # assert model is not in another model's has_many assoc
@@ -60,7 +60,7 @@ Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |targe
   model!(owner).send(association).should_not == model!(target)
 end
 
-# assert model.predicate? 
+# assert model.predicate?
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
     model!(name).should send("have_#{predicate.gsub(' ', '_')}")
@@ -83,7 +83,7 @@ end
 Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
   actual_value  = model(name).send(attribute)
   expectation   = expectation.gsub(' ', '_')
-  
+
   case expected
   when 'nil', 'true', 'false'
     actual_value.send(expectation, send("be_#{expected}"))

data/features/step_definitions/service_steps.rb

@@ -25,11 +25,11 @@ Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and passw
 end
 
 Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)" it should throw an exception with message "([^\"]*)"$/ do |username, password, msg|
-  lambda { @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password }) }.should raise_error(msg)
+  expect { @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password }) }.to raise_error(msg)
 end
 
 Given /^a HTTP BasicAuth ODataService exists it should throw an exception with message "([^\"]*)"$/ do |msg|
-  lambda { @service = OData::Service.new(BASICAUTH_URL) }.should raise_error(msg)
+  expect { @service = OData::Service.new(BASICAUTH_URL) }.to raise_error(msg)
 end
 
 Given /^a HTTPS BasicAuth ODataService exists using self-signed certificate and username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
@@ -41,19 +41,19 @@ When /^I call "([^\"]*)" on the service$/ do |method|
 end
 
 Then /^the integer result should be ([^\"]*)$/ do |result|
-  @service_result.should eq result.to_i
+  expect(@service_result).to eq result.to_i
 end
 
 Then /^I should be able to call "([^\"]*)" on the service$/ do |method|
-  lambda { @service.send(method) }.should_not raise_error
+  expect { @service.send(method) }.to_not raise_error
 end
 
 Then /^I should not be able to call "([^\"]*)" on the service$/ do |method|
-  lambda { @service.send(method) }.should raise_error
+  expect { @service.send(method) }.to raise_error
 end
 
 Then /^I should be able to call "([^\"]*)" on the service with args: "([^\"]*)"$/ do |method, args|
-  lambda { @service.send(method, args) }.should_not raise_error
+  expect { @service.send(method, args) }.to_not raise_error
 end
 
 When /^I call "([^\"]*)" on the service with args: "([^\"]*)"$/ do |method, args|
@@ -65,19 +65,19 @@ When /^I run the query$/ do
 end
 
 Then /^the result should be of type "([^\"]*)"$/ do |type|
-  @service_result.class.to_s.should eq type
+  expect(@service_result.class.to_s).to eq type
 end
 
 Then /^the result should have a method: "([^\"]*)"$/ do |method|
-  @service_result.respond_to?(method.to_sym).should eq true
+  expect(@service_result.respond_to?(method.to_sym)).to eq true
 end
 
 Then /^the method "([^\"]*)" on the result should equal: "([^\"]*)"$/ do |method, value|
-  @service_result.send(method.to_sym).to_s.should eq value
+  expect(@service_result.send(method.to_sym).to_s).to eq value
 end
 
 Then /^the method "([^\"]*)" on the result should be nil$/ do |method|
-  @service_result.send(method.to_sym).should eq nil
+  expect(@service_result.send(method.to_sym)).to eq nil
 end
 
 When /^I set "([^\"]*)" on the result to "([^\"]*)"$/ do |property_name, value|
@@ -114,7 +114,7 @@ end
 
 Then /^the method "([^\"]*)" on the result should be of type "([^\"]*)"$/ do |method, type|
   result = @service_result.send(method.to_sym)
-  result.class.to_s.should eq type
+  expect(result.class.to_s).to eq type
 end
 
 Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object(?: with (.*))?$/ do |method, object, fields|
@@ -129,7 +129,7 @@ When /^I save changes$/ do
 end
 
 Then /^the save result should be of type "([^\"]*)"$/ do |type|
-  @saved_result.class.to_s.should eq type
+  expect(@saved_result.class.to_s).to eq type
 end
 
 When /^I call "([^\"]*)" on the service with the last save result$/ do |method|
@@ -141,12 +141,12 @@ When /^I call "([^\"]*)" on the service with the last query result$/ do |method|
 end
 
 Then /^the save result should equal: "([^\"]*)"$/ do |result|
-  @saved_result.to_s.should eq result
+  expect(@saved_result.to_s).to eq result
 end
 
 Then /^the method "([^\"]*)" on the save result should equal: "([^\"]*)"$/ do |method, value|
   result = @saved_result.send(method.to_sym)
-  result.should eq value
+  expect(result).to eq value
 end
 
 When /^blueprints exist for the service$/ do
@@ -155,23 +155,23 @@ end
 
 Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object it should throw an exception with message "([^\"]*)"$/ do |method, object, msg|
   obj = object.constantize.send :make
-  lambda { @service.send(method.to_sym, obj) }.should raise_error(msg)
+  expect { @service.send(method.to_sym, obj) }.to raise_error(msg)
 end
 
 When /^I save changes it should throw an exception with message containing "([^"]*)"$/ do |msg|
-  lambda { @service.save_changes }.should raise_error(/#{msg}.*/)
+  expect { @service.save_changes }.to raise_error(/#{msg}.*/)
 end
 
 Then /^no "([^\"]*)" should exist$/ do |collection|
   @service.send(collection)
   results = @service.execute
-  results.should eq []
+  expect(results).to eq []
 end
 
 Then /^the primitive results should be:$/ do |table|
   # table is a Cucumber::Ast::Table
   values = table.hashes
-  result_table = Cucumber::Ast::Table.new(values)
+  result_table = values
   table.diff!(result_table)
 end
 
@@ -191,13 +191,13 @@ Then /^the result should be:$/ do |table|
     results << obj_hash
   end
 
-  result_table = Cucumber::Ast::Table.new(results)
+  result_table = results
 
   table.diff!(result_table)
 end
 
 Then /^a class named "([^\"]*)" should exist$/ do |klass_name|
-  (Object.const_defined? klass_name).should eq true
+  expect(Object.const_defined? klass_name).to eq true
 end
 
 # Operations against a method on the service result
@@ -207,12 +207,12 @@ When /^I call "([^\"]*)" for "([^\"]*)" on the result$/ do |method2, method1|
 end
 
 Then /^the operation should not be null$/ do
-  @operation_result.nil?.should eq false
+  expect(@operation_result.nil?).to eq false
 end
 
 Then /^the method "([^\"]*)" on the result's method "([^\"]*)" should equal: "([^\"]*)"$/ do |method, result_method, value|
   obj = @service_result.send(result_method.to_sym)
-  obj.send(method.to_sym).to_s.should eq value
+  expect(obj.send(method.to_sym).to_s).to eq value
 end
 
 When /^I set "([^\"]*)" on the result's method "([^\"]*)" to "([^\"]*)"$/ do |property_name, result_method, value|
@@ -223,9 +223,9 @@ end
 Then /^the "([^\"]*)" method on the object should return a (.*)/ do |method_name, type|
   methods = method_name.split '.'
   if methods.length == 1
-    @service_result.first.send(method_name).class.to_s.should eq type
+    expect(@service_result.first.send(method_name).class.to_s).to eq type
   else
-    @service_result.first.send(methods[0]).send(methods[1]).class.to_s.should eq type
+    expect(@service_result.first.send(methods[0]).send(methods[1]).class.to_s).to eq type
   end
 end
 
@@ -235,12 +235,12 @@ end
 
 Then /^the new query result's time "([^\"]*)" should equal the saved query result$/ do |method_name|
   methods = method_name.split '.'
-  @service_result.send(methods[0]).send(methods[1]).xmlschema(3).should eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
+  expect(@service_result.send(methods[0]).send(methods[1]).xmlschema(3)).to eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
 end
 
 
 Then /^the result count should be (\d+)$/ do |expected_count|
-  @service_result.count.should eq expected_count.to_i
+  expect(@service_result.count).to eq expected_count.to_i
 end
 
 When /^I add a link between #{capture_model} and #{capture_model} on "([^"]*)"$/ do |parent, child, property|

data/features/support/hooks.rb

@@ -1,5 +1,6 @@
 Before do
   VCR.use_cassette("clean_database_for_testing") do
-    RestClient.post "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}/SampleService/RubyOData.svc/CleanDatabaseForTesting", {}
+    conn = Faraday.new(url: "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}")
+    conn.post '/SampleService/RubyOData.svc/CleanDatabaseForTesting'
   end
-end
+end

data/features/support/vcr.rb

@@ -5,20 +5,20 @@ VCR.configure do |c|
   c.hook_into :webmock
   c.cassette_library_dir     = "features/cassettes"
   c.default_cassette_options = {
-    :record => :none,
-    :match_requests_on => [:method, OData::Support::SampleServiceMatcher]
+    record:            :none,
+    match_requests_on: [:method, OData::Support::SampleServiceMatcher]
   }
 end
 
 VCR.cucumber_tags do |t|
-  t.tags  "@basic_auth",
-          "@batch_request",
-          "@complex_types",
-          "@error_handling",
-          "@query_builder",
-          "@service",
-          "@service_manage",
-          "@service_methods",
-          "@ssl",
-          "@type_conversion"
-end
+  t.tags "@basic_auth",
+         "@batch_request",
+         "@complex_types",
+         "@error_handling",
+         "@query_builder",
+         "@service",
+         "@service_manage",
+         "@service_methods",
+         "@ssl",
+         "@type_conversion"
+end

data/lib/ruby_odata.rb

@@ -7,7 +7,9 @@ require "active_support" # Used for serializtion to JSON
 require "active_support/inflector"
 require "active_support/core_ext"
 require "cgi"
-require "rest_client"
+require "excon"
+require "faraday_middleware"
+require "faraday"
 require "nokogiri"
 require "bigdecimal"
 require "bigdecimal/util"
@@ -19,5 +21,6 @@ require lib + "/ruby_odata/property_metadata"
 require lib + "/ruby_odata/query_builder"
 require lib + "/ruby_odata/class_builder"
 require lib + "/ruby_odata/operation"
+require lib + "/ruby_odata/resource"
 require lib + "/ruby_odata/service"
 require lib + "/ruby_odata/helpers"

data/lib/ruby_odata/association.rb

@@ -8,20 +8,27 @@ module OData
       @edmx = edmx
 
       # Get the edm namespace because it varies by version
-      edm_ns = @edmx.xpath("edmx:Edmx/edmx:DataServices/*", "edmx" => "http://schemas.microsoft.com/ado/2007/06/edmx").first.namespaces['xmlns'].to_s
-      @edmx_namespaces = { "edmx" => "http://schemas.microsoft.com/ado/2007/06/edmx", "edm" => edm_ns }
+      root = @edmx.xpath("/edmx:Edmx").first
+      @version = root['Version'].to_i
+      edmxurl = root.namespaces['xmlns:edmx']
+      ds = @edmx.xpath("edmx:Edmx/edmx:DataServices/*", "edmx" => edmxurl).first
+      edm_ns = ds.namespaces['xmlns'].to_s
+      @edmx_namespaces = { "edmx" => edmxurl, "edm" => edm_ns }
       parse_nav_prop(nav_prop_element)
     end
 
     private
 
     def parse_nav_prop(element)
-      @relationship = element['Relationship']
-      relationship_parts = @relationship.split('.')
-      @name = relationship_parts.pop
-      @namespace = relationship_parts.join('.')
-      @from_role = role_hash(@name, element['FromRole'])
-      @to_role = role_hash(@name, element['ToRole'])
+      if @version >= 4
+      else
+        @relationship = element['Relationship']
+        relationship_parts = @relationship.split('.')
+        @name = relationship_parts.pop
+        @namespace = relationship_parts.join('.')
+        @from_role = role_hash(@name, element['FromRole'])
+        @to_role = role_hash(@name, element['ToRole'])
+      end
     end
 
     def role_hash(association_name, role_name)

data/lib/ruby_odata/class_builder.rb

@@ -121,7 +121,11 @@ module OData
         # Convert Arrays into proper Collections
         collections = vars.find_all { |o| o[1].class == Array } || []
         collections.each do |c|
-          vars[c[0]] = { '__metadata' => { 'type' => props[c[0]].type }, 'results' => c[1] }
+          if options[:type] == :add
+            vars[c[0]] = c[1]
+          else
+            vars[c[0]] = { '__metadata' => { 'type' => props[c[0]].type }, 'results' => c[1] }
+          end
         end
 
         # Convert a BigDecimal to a string for serialization (to match Edm.Decimal)

data/lib/ruby_odata/query_builder.rb

@@ -1,194 +1,192 @@
 module OData
-# The query builder is used to call query operations against the service.  This shouldn't be called directly, but rather it is returned from the dynamic methods created for the specific service that you are calling.
-#
-# @example For example, given the following code snippet:
-#   svc = OData::Service.new "http://127.0.0.1:8989/SampleService/RubyOData.svc"
-#   svc.Categories
-# The *Categories* method would return a QueryBuilder
-class QueryBuilder
-  attr_accessor :additional_params
-
-  # Creates a new instance of the QueryBuilder class
-  #
-  # @param [String] root entity collection to query against
-  # @param [Hash, {}] additional_params hash of additional parameters to use for a query
-  def initialize(root, additional_params = {})
-    @root = Helpers.uri_escape(root.to_s)
-    @expands = []
-    @filters = []
-    @order_bys = []
-    @navigation_paths = []
-    @select = []
-    @skip = nil
-    @top = nil
-    @count = nil
-    @links_navigation_property = nil
-    @additional_params = additional_params
-  end
-
-  # Used to eagerly-load data for nested objects, for example, obtaining a Category for a Product within one call to the server
-  #
-  # @param [String] path of the entity to expand relative to the root
-  # @example
-  #   # Without expanding the query (no Category will be filled in for the Product)
-  #   svc.Products(1)
-  #   prod1 = svc.execute
-  #
-  #   # With expanding the query (the Category will be filled in)
-  #   svc.Products(1).expand('Category')
-  #   prod1 = svc.execute
-  def expand(path)
-    @expands << path
-    self
-  end
+  # The query builder is used to call query operations against the service.  This shouldn't be called directly, but rather it is returned from the dynamic methods created for the specific service that you are calling.
+  #
+  # @example For example, given the following code snippet:
+  #   svc = OData::Service.new "http://127.0.0.1:8989/SampleService/RubyOData.svc"
+  #   svc.Categories
+  # The *Categories* method would return a QueryBuilder
+  class QueryBuilder
+    attr_accessor :additional_params
+
+    # Creates a new instance of the QueryBuilder class
+    #
+    # @param [String] root entity collection to query against
+    # @param [Hash, {}] additional_params hash of additional parameters to use for a query
+    def initialize(root, additional_params = {})
+      @root = Helpers.uri_escape(root.to_s)
+      @expands = []
+      @filters = []
+      @order_bys = []
+      @navigation_paths = []
+      @select = []
+      @skip = nil
+      @top = nil
+      @count = nil
+      @links_navigation_property = nil
+      @additional_params = additional_params
+    end
 
-  # Used to filter data being returned
-  #
-  # @param [String] filter conditions to apply to the query
-  #
-  # @example
-  #  svc.Products.filter("Name eq 'Product 2'")
-  #  products = svc.execute
-  def filter(filter)
-    @filters << CGI.escape(filter)
-    self
-  end
+    # Used to eagerly-load data for nested objects, for example, obtaining a Category for a Product within one call to the server
+    #
+    # @param [String] path of the entity to expand relative to the root
+    # @example
+    #   # Without expanding the query (no Category will be filled in for the Product)
+    #   svc.Products(1)
+    #   prod1 = svc.execute
+    #
+    #   # With expanding the query (the Category will be filled in)
+    #   svc.Products(1).expand('Category')
+    #   prod1 = svc.execute
+    def expand(path)
+      @expands << path
+      self
+    end
 
-  # Used to order the data being returned
-  #
-  # @param [String] order_by the order by statement.  Note to specify direction, use "desc" or "asc"; must be lowercase
-  #
-  # @example
-  #   svc.Products.order_by("Name")
-  #   products = svc.execute
-  def order_by(order_by)
-    @order_bys << CGI.escape(order_by)
-    self
-  end
+    # Used to filter data being returned
+    #
+    # @param [String] filter conditions to apply to the query
+    #
+    # @example
+    #  svc.Products.filter("Name eq 'Product 2'")
+    #  products = svc.execute
+    def filter(filter)
+      @filters << CGI.escape(filter)
+      self
+    end
 
-  # Used to skip a number of records
-  # This is typically used for paging, where it would be used along with the `top` method.
-  #
-  # @param [Integer] num the number of items to skip
-  #
-  # @example
-  #   svc.Products.skip(5)
-  #   products = svc.execute # => skips the first 5 items
-  def skip(num)
-    @skip = num
-    self
-  end
+    # Used to order the data being returned
+    #
+    # @param [String] order_by the order by statement.  Note to specify direction, use "desc" or "asc"; must be lowercase
+    #
+    # @example
+    #   svc.Products.order_by("Name")
+    #   products = svc.execute
+    def order_by(order_by)
+      @order_bys << CGI.escape(order_by)
+      self
+    end
 
-  # Used to take only the top X records
-  # This is typically used for paging, where it would be used along with the `skip` method.
-  #
-  # @param [Integer] num the number of items to return
-  #
-  # @example
-  #   svc.Products.top(5)
-  #   products = svc.execute # => returns only the first 5 items
-  def top(num)
-    @top = num
-    self
-  end
+    # Used to skip a number of records
+    # This is typically used for paging, where it would be used along with the `top` method.
+    #
+    # @param [Integer] num the number of items to skip
+    #
+    # @example
+    #   svc.Products.skip(5)
+    #   products = svc.execute # => skips the first 5 items
+    def skip(num)
+      @skip = num
+      self
+    end
 
-  # Used to return links instead of actual objects
-  #
-  # @param [String] navigation_property the NavigationProperty name to retrieve the links for
-  #
-  # @raise [NotSupportedError] if count has already been called on the query
-  #
-  # @example
-  #   svc.Categories(1).links("Products")
-  #   product_links = svc.execute # => returns URIs for the products under the Category with an ID of 1
-  def links(navigation_property)
-    raise OData::NotSupportedError.new("You cannot call both the `links` method and the `count` method in the same query.") if @count
-    raise OData::NotSupportedError.new("You cannot call both the `links` method and the `select` method in the same query.") unless @select.empty?
-    @links_navigation_property = navigation_property
-    self
-  end
+    # Used to take only the top X records
+    # This is typically used for paging, where it would be used along with the `skip` method.
+    #
+    # @param [Integer] num the number of items to return
+    #
+    # @example
+    #   svc.Products.top(5)
+    #   products = svc.execute # => returns only the first 5 items
+    def top(num)
+      @top = num
+      self
+    end
 
-  # Used to return a count of objects instead of the objects themselves
-  #
-  # @raise [NotSupportedError] if links has already been called on the query
-  #
-  # @example
-  #   svc.Products
-  #   svc.count
-  #   product_count = svc.execute
-  def count
-    raise OData::NotSupportedError.new("You cannot call both the `links` method and the `count` method in the same query.") if @links_navigation_property
-    raise OData::NotSupportedError.new("You cannot call both the `select` method and the `count` method in the same query.") unless @select.empty?
-
-    @count = true
-    self
-  end
+    # Used to return links instead of actual objects
+    #
+    # @param [String] navigation_property the NavigationProperty name to retrieve the links for
+    #
+    # @raise [NotSupportedError] if count has already been called on the query
+    #
+    # @example
+    #   svc.Categories(1).links("Products")
+    #   product_links = svc.execute # => returns URIs for the products under the Category with an ID of 1
+    def links(navigation_property)
+      raise OData::NotSupportedError.new("You cannot call both the `links` method and the `count` method in the same query.") if @count
+      raise OData::NotSupportedError.new("You cannot call both the `links` method and the `select` method in the same query.") unless @select.empty?
+      @links_navigation_property = navigation_property
+      self
+    end
 
-  # Used to navigate to a child collection, typically used to filter or perform a similar function against the children
-  #
-  # @param [String] navigation_property the NavigationProperty to drill-down into
-  #
-  # @example
-  #   svc.Genres('Horror Movies').navigate("Titles").filter("Name eq 'Halloween'")
-  def navigate(navigation_property)
-    @navigation_paths << Helpers.uri_escape(navigation_property)
-    self
-  end
+    # Used to return a count of objects instead of the objects themselves
+    #
+    # @raise [NotSupportedError] if links has already been called on the query
+    #
+    # @example
+    #   svc.Products
+    #   svc.count
+    #   product_count = svc.execute
+    def count
+      raise OData::NotSupportedError.new("You cannot call both the `links` method and the `count` method in the same query.") if @links_navigation_property
+      raise OData::NotSupportedError.new("You cannot call both the `select` method and the `count` method in the same query.") unless @select.empty?
+
+      @count = true
+      self
+    end
 
-  # Used to customize the properties that are returned for "ad-hoc" queries
-  #
-  # @param [Array<String>] properties to return
-  #
-  # @example
-  #   svc.Products.select('Price', 'Rating')
-  def select(*fields)
-    raise OData::NotSupportedError.new("You cannot call both the `links` method and the `select` method in the same query.") if @links_navigation_property
-    raise OData::NotSupportedError.new("You cannot call both the `count` method and the `select` method in the same query.") if @count
-
-    @select |= fields
-
-    expands =  fields.find_all { |f| /\// =~ f }
-    expands.each do |e|
-      parts = e.split '/'
-      @expands |= [parts[0...-1].join('/')]
+    # Used to navigate to a child collection, typically used to filter or perform a similar function against the children
+    #
+    # @param [String] navigation_property the NavigationProperty to drill-down into
+    #
+    # @example
+    #   svc.Genres('Horror Movies').navigate("Titles").filter("Name eq 'Halloween'")
+    def navigate(navigation_property)
+      @navigation_paths << Helpers.uri_escape(navigation_property)
+      self
     end
 
+    # Used to customize the properties that are returned for "ad-hoc" queries
+    #
+    # @param [Array<String>] properties to return
+    #
+    # @example
+    #   svc.Products.select('Price', 'Rating')
+    def select(*fields)
+      raise OData::NotSupportedError.new("You cannot call both the `links` method and the `select` method in the same query.") if @links_navigation_property
+      raise OData::NotSupportedError.new("You cannot call both the `count` method and the `select` method in the same query.") if @count
+
+      @select |= fields
+
+      expands =  fields.find_all { |f| /\// =~ f }
+      expands.each do |e|
+        parts = e.split '/'
+        @expands |= [parts[0...-1].join('/')]
+      end
+
+      self
+    end
 
-    self
-  end
+    # Builds the query URI (path, not including root) incorporating expands, filters, etc.
+    # This is used internally when the execute method is called on the service
+    def query
+      q = @root.clone
 
-  # Builds the query URI (path, not including root) incorporating expands, filters, etc.
-  # This is used internally when the execute method is called on the service
-  def query
-    q = @root.clone
+      # Navigation paths come first in the query
+      q << "/#{@navigation_paths.join("/")}" unless @navigation_paths.empty?
 
-    # Navigation paths come first in the query
-    q << "/" + @navigation_paths.join("/") unless @navigation_paths.empty?
+      # Handle links queries, this isn't just a standard query option
+      q << "/$links/#{@links_navigation_property}" if @links_navigation_property
 
-    # Handle links queries, this isn't just a standard query option
-    if @links_navigation_property
-      q << "/$links/#{@links_navigation_property}"
-    end
+      # Handle count queries, this isn't just a standard query option
+      q << "/$count" if @count
+      query_options = generate_query_options
 
-    # Handle count queries, this isn't just a standard query option
-    if @count
-      q << "/$count"
+      q << "?#{query_options.join('&')}" if !query_options.empty?
+      q
     end
 
-    query_options = []
-    query_options << "$select=#{@select.join(',')}" unless @select.empty?
-    query_options << "$expand=#{@expands.join(',')}" unless @expands.empty?
-    query_options << "$filter=#{@filters.join('+and+')}" unless @filters.empty?
-    query_options << "$orderby=#{@order_bys.join(',')}" unless @order_bys.empty?
-    query_options << "$skip=#{@skip}" unless @skip.nil?
-    query_options << "$top=#{@top}" unless @top.nil?
-    query_options << @additional_params.to_query unless @additional_params.empty?
-    if !query_options.empty?
-      q << "?"
-      q << query_options.join('&')
+    private
+
+    def generate_query_options
+      query_options = []
+      query_options << "$select=#{@select.join(',')}" unless @select.empty?
+      query_options << "$expand=#{@expands.join(',')}" unless @expands.empty?
+      query_options << "$filter=#{@filters.join('+and+')}" unless @filters.empty?
+      query_options << "$orderby=#{@order_bys.join(',')}" unless @order_bys.empty?
+      query_options << "$skip=#{@skip}" unless @skip.nil?
+      query_options << "$top=#{@top}" unless @top.nil?
+      query_options << @additional_params.to_query unless @additional_params.empty?
+      query_options
     end
-    return q
   end
-end
-
 end # Module