ruby_odata 0.1.3 → 0.1.4

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -10,9 +10,12 @@ doc/*
 *.gem
 .bundle
 Gemfile.lock
+Gemfile.*.lock
 pkg/*
 test/applicationhost.config
 .rvmrc
+.ruby-version
+.ruby-gemset
 .DS_Store
 *ReSharper*
 *.suo
@@ -20,3 +23,4 @@ obj
 *.pdb
 test/RubyODataService/RubyODataService/bin/*.xml
 test/RubyODataService/RubyODataService/App_Data/*.sdf
+coverage/*

data/.simplecov

@@ -0,0 +1,10 @@
+if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9') && ENV['COVERAGE']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter
+  ]
+
+  SimpleCov.start
+end

data/.travis.yml

@@ -1,5 +1,10 @@
-rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-script: "bundle exec rake"
+matrix:
+  include:
+    - rvm: 1.8.7
+      gemfile: gemfiles/Gemfile.ruby187
+    - rvm: 1.9.3
+      gemfile: Gemfile
+    - rvm: 2.0.0
+      gemfile: Gemfile
+
+script: "bundle exec rake test_with_coveralls"

data/CHANGELOG.md

@@ -115,4 +115,24 @@
     * Persists the additional_params for partial calls (thanks [@levelboy](https://github.com/levelboy))
 
 * Other
-    * Specified v2.3.4 of the addressable gem since there was a bug when testing ruby_odata against Ruby 1.8.7
+    * Specified v2.3.4 of the addressable gem since there was a bug when testing ruby_odata against Ruby 1.8.7
+
+### 0.1.4
+* New Features
+    * Added option to override content type used for json updates ([issue 29](https://github.com/visoft/ruby_odata/pull/29), thanks [@sigmunau](https://github.com/sigmunau))
+
+* Bug Fixes
+    * Fixed issue with building a collection of complex types ([issue 26](https://github.com/visoft/ruby_odata/issues/26))
+    * A collection of complex types is now returned as an array ([issue 26](https://github.com/visoft/ruby_odata/issues/26))
+    * Fixed issue with building a child collection of native types ([issue 27](https://github.com/visoft/ruby_odata/issues/27))
+    * Corrected problem with addressable not being referenced
+    * Fixed issue with building nested expands ([issue 24](https://github.com/visoft/ruby_odata/pull/24), thanks [@joshuap](https://github.com/joshuap))
+    * Edm.Int64 is now formatted as a string, according to odata json spec ([issue 29](https://github.com/visoft/ruby_odata/pull/29), thanks [@sigmunau](https://github.com/sigmunau))
+    * Fixed formatting of collections for json output ([issue 29](https://github.com/visoft/ruby_odata/pull/29), thanks [@sigmunau](https://github.com/sigmunau))
+    * Fixed handling exceptions that are not http exceptions ([issue 29](https://github.com/visoft/ruby_odata/pull/29), thanks [@sigmunau](https://github.com/sigmunau))
+    * Fixed parsing of null strings ([issue 29](https://github.com/visoft/ruby_odata/pull/29), thanks [@sigmunau](https://github.com/sigmunau))
+
+* Other
+    * Updated the [VCR](https://github.com/myronmarston/vcr) and [WebMock](https://github.com/bblimke/webmock) gems to the latest versions (used for testing)
+    * Specified activesupport ~> 3.0 (in gemfiles/ruby187) for Ruby 1.8.7 as activesupport 4 doesn't support Ruby < 1.9.3
+

data/Rakefile

@@ -13,6 +13,23 @@ Cucumber::Rake::Task.new(:features) do |t|
   t.cucumber_opts = "features --format progress"
 end
 
-
 Bundler::GemHelper.install_tasks
-task :default => [:spec, :features]
+task :default => [:spec, :features]
+
+desc "Run with code coverage"
+task :coverage do
+  ENV['COVERAGE'] = 'true' if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9')
+
+  Rake::Task["spec"].execute
+  Rake::Task["features"].execute
+end
+
+desc "Run test with coveralls"
+task :test_with_coveralls =>   [:coverage, 'coveralls_push_workaround']
+task :coveralls_push_workaround do
+  if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9')
+    require 'coveralls/rake/task'
+    Coveralls::RakeTask.new
+    Rake::Task["coveralls:push"].invoke
+  end
+end

data/features/step_definitions/service_steps.rb

@@ -20,14 +20,6 @@ Given /^a HTTP ODataService exists$/ do
   end
 end
 
-Given /^a HTTP BasicAuth ODataService exists$/ do
-  @service = OData::Service.new(BASICAUTH_URL)
-end
-
-Given /^a HTTPS BasicAuth ODataService exists$/ do
-  @service = OData::Service.new(HTTPS_BASICAUTH_URL)
-end
-
 Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
   @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password })
 end
@@ -36,14 +28,6 @@ Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and passw
   lambda { @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password }) }.should raise_error(msg)
 end
 
-Given /^a HTTP BasicAuth ODataService exists it should throw an exception with message containing "([^\"]*)"$/ do |msg|
-  lambda { @service = OData::Service.new(BASICAUTH_URL) }.should raise_error(/#{msg}.*/)
-end
-
-Given /^a HTTPS BasicAuth ODataService exists it should throw an exception with message containing "([^"]*)"$/ do |msg|
-  lambda { @service = OData::Service.new(HTTPS_BASICAUTH_URL) }.should 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)
 end
@@ -56,10 +40,6 @@ When /^I call "([^\"]*)" on the service$/ do |method|
   @service_query = @service.send(method)
 end
 
-Then /^the result should be "([^\"]*)"$/ do |result|
-  @service_result.should eq result
-end
-
 Then /^the integer result should be ([^\"]*)$/ do |result|
   @service_result.should eq result.to_i
 end
@@ -216,27 +196,6 @@ Then /^the result should be:$/ do |table|
   table.diff!(result_table)
 end
 
-Then /^the save result should be:$/ do |table|
-  # table is a Cucumber::Ast::Table
-
-  fields = table.hashes[0].keys
-
-  # Build an array of hashes so that we can compare tables
-  results = []
-
-  @saved_result.each do |result|
-    obj_hash = Hash.new
-    fields.each do |field|
-      obj_hash[field] = result.send(field)
-    end
-    results << obj_hash
-  end
-
-  result_table = Cucumber::Ast::Table.new(results)
-
-  table.diff!(result_table)
-end
-
 Then /^a class named "([^\"]*)" should exist$/ do |klass_name|
   (Object.const_defined? klass_name).should eq true
 end
@@ -261,14 +220,6 @@ When /^I set "([^\"]*)" on the result's method "([^\"]*)" to "([^\"]*)"$/ do |pr
 end
 
 # Type tests
-Then /^the "([^\"]*)" method should return a (.*)/ do |method_name, type|
-  methods = method_name.split '.'
-  if methods.length == 1
-    @service_result.send(method_name).class.to_s.should eq type
-  else
-    @service_result.send(methods[0]).send(methods[1]).class.to_s.should eq type
-  end
-end
 Then /^the "([^\"]*)" method on the object should return a (.*)/ do |method_name, type|
   methods = method_name.split '.'
   if methods.length == 1
@@ -284,16 +235,9 @@ end
 
 Then /^the new query result's time "([^\"]*)" should equal the saved query result$/ do |method_name|
   methods = method_name.split '.'
-  if methods.length == 1
-    @service_result.send(method_name).xmlschema(3).should eq @stored_query_result.send(method_name).xmlschema(3)
-  else
-    @service_result.send(methods[0]).send(methods[1]).xmlschema(3).should eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
-  end
+  @service_result.send(methods[0]).send(methods[1]).xmlschema(3).should eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
 end
 
-Then /^show me the results$/ do
-  puts @service_result
-end
 
 Then /^the result count should be (\d+)$/ do |expected_count|
   @service_result.count.should eq expected_count.to_i
@@ -313,4 +257,4 @@ end
 
 When /^(.*) within a cassette named "([^"]*)"$/ do |the_step, cassette_name|
   VCR.use_cassette(cassette_name) { step the_step }
-end
+end

data/features/support/env.rb

@@ -1,4 +1,9 @@
 lib = File.expand_path(File.join(File.dirname(__FILE__), "../..", "lib"))
 
 require lib + '/ruby_odata'
-require "machinist"
+require 'machinist'
+
+require 'simplecov'
+# require 'coveralls'
+
+# Coveralls.wear_merged!

data/gemfiles/Gemfile.ruby187

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec :path => '../'
+
+gem 'nokogiri', '~> 1.5.10'
+gem 'activesupport',  '~> 3.0'

data/lib/ruby_odata.rb

@@ -12,6 +12,7 @@ require "nokogiri"
 require "bigdecimal"
 require "bigdecimal/util"
 require "backports"
+require "addressable/uri"
 
 require lib + "/ruby_odata/exceptions"
 require lib + "/ruby_odata/association"

data/lib/ruby_odata/class_builder.rb

@@ -110,6 +110,20 @@ module OData
           end
         end
 
+        props = self.class.properties
+
+        # Convert a Int64 to a string for serialization (to match Edm.Int64)
+        bigints = vars.find_all { |o| props[o[0]] && props[o[0]].type == "Edm.Int64" } || []
+        bigints.each do |i|
+          vars[i[0]] = i[1].to_s
+        end
+
+        # 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] }
+        end
+
         # Convert a BigDecimal to a string for serialization (to match Edm.Decimal)
         decimals = vars.find_all { |o| o[1].class == BigDecimal } || []
         decimals.each do |d|

data/lib/ruby_odata/service.rb

@@ -1,7 +1,7 @@
 module OData
 # The main service class, also known as a *Context*
 class Service
-  attr_reader :classes, :class_metadata, :options, :collections, :edmx, :function_imports
+  attr_reader :classes, :class_metadata, :options, :collections, :edmx, :function_imports, :response
   # Creates a new instance of the Service class
   #
   # @param [String] service_uri the root URI of the OData service
@@ -97,9 +97,9 @@ class Service
   # Performs query operations (Read) against the server.
   # Typically this returns an array of record instances, except in the case of count queries
   def execute
-    result = RestClient::Resource.new(build_query_uri, @rest_options).get
-    return Integer(result) if result =~ /^\d+$/
-    handle_collection_result(result)
+    @response = RestClient::Resource.new(build_query_uri, @rest_options).get
+    return Integer(@response) if @response =~ /^\d+$/
+    handle_collection_result(@response)
   end
 
   # Overridden to identify methods handled by method_missing
@@ -176,6 +176,7 @@ class Service
     @rest_options.merge!(options[:rest_options] || {})
     @additional_params = options[:additional_params] || {}
     @namespace = options[:namespace]
+    @json_type = options[:json_type] || :json
   end
 
   def default_instance_vars!
@@ -312,7 +313,7 @@ class Service
 
   # Handles errors from the OData service
   def handle_exception(e)
-    raise e unless e.response
+    raise e unless defined? e.response
 
     code = e.http_code
     error = Nokogiri::XML(e.response)
@@ -375,11 +376,7 @@ class Service
 
     return nil if klass_name.nil?
 
-    # If we are working against a child (inline) entry, we need to use the more generic xpath because a child entry WILL
-    # have properties that are ancestors of m:inline. Check if there is an m:inline child to determine the xpath query to use
-    has_inline = entry.xpath(".//m:inline", @ds_namespaces).any?
-    properties_xpath = has_inline ? ".//m:properties[not(ancestor::m:inline)]/*" : ".//m:properties/*"
-    properties = entry.xpath(properties_xpath, @ds_namespaces)
+    properties = entry.xpath("./atom:content/m:properties/*", @ds_namespaces)
 
     klass = @classes[qualify_class_name(klass_name)].new
 
@@ -390,7 +387,7 @@ class Service
     # Fill properties
     for prop in properties
       prop_name = prop.name
-      klass.send "#{prop_name}=", parse_value(prop)
+      klass.send "#{prop_name}=", parse_value_xml(prop)
     end
 
     # Fill properties represented outside of the properties collection
@@ -407,15 +404,14 @@ class Service
     inline_links = entry.xpath("./atom:link[m:inline]", @ds_namespaces)
 
     for link in inline_links
-      inline_entries = link.xpath(".//atom:entry", @ds_namespaces)
-
       # TODO: Use the metadata's associations to determine the multiplicity instead of this "hack"
       property_name = link.attributes['title'].to_s
-      if inline_entries.length == 1 && singular?(property_name)
-        inline_klass = build_inline_class(klass, inline_entries[0], property_name)
+      if singular?(property_name)
+        inline_entry = link.xpath("./m:inline/atom:entry", @ds_namespaces).first
+        inline_klass = build_inline_class(klass, inline_entry, property_name)
         klass.send "#{property_name}=", inline_klass
       else
-        inline_classes = []
+        inline_classes, inline_entries = [], link.xpath("./m:inline/atom:feed/atom:entry", @ds_namespaces)
         for inline_entry in inline_entries
           # Build the class
           inline_klass = entry_to_class(inline_entry)
@@ -438,7 +434,7 @@ class Service
     next_links = doc.xpath('//atom:link[@rel="next"]', @ds_namespaces)
     @has_partial = next_links.any?
     if @has_partial
-      uri = Addressable::URI.parse(next_links[0]['href']) 
+      uri = Addressable::URI.parse(next_links[0]['href'])
       uri.query_values = uri.query_values.merge @additional_params unless @additional_params.empty?
       @next_uri = uri.to_s
     end
@@ -537,12 +533,12 @@ class Service
     if operation.kind == "Add"
       save_uri = build_save_uri(operation)
       json_klass = operation.klass.to_json(:type => :add)
-      post_result = RestClient::Resource.new(save_uri, @rest_options).post json_klass, {:content_type => :json}
+      post_result = RestClient::Resource.new(save_uri, @rest_options).post json_klass, {:content_type => @json_type}
       return build_classes_from_result(post_result)
     elsif operation.kind == "Update"
       update_uri = build_resource_uri(operation)
       json_klass = operation.klass.to_json
-      update_result = RestClient::Resource.new(update_uri, @rest_options).put json_klass, {:content_type => :json}
+      update_result = RestClient::Resource.new(update_uri, @rest_options).put json_klass, {:content_type => @json_type}
       return (update_result.code == 204)
     elsif operation.kind == "Delete"
       delete_uri = build_resource_uri(operation)
@@ -551,7 +547,7 @@ class Service
     elsif operation.kind == "AddLink"
       save_uri = build_add_link_uri(operation)
       json_klass = operation.child_klass.to_json(:type => :link)
-      post_result = RestClient::Resource.new(save_uri, @rest_options).post json_klass, {:content_type => :json}
+      post_result = RestClient::Resource.new(save_uri, @rest_options).post json_klass, {:content_type => @json_type}
 
       # Attach the child to the parent
       link_child_to_parent(operation) if (post_result.code == 204)
@@ -636,16 +632,45 @@ class Service
 
   # Complex Types
   def complex_type_to_class(complex_type_xml)
-    klass_name = qualify_class_name(Helpers.get_namespaced_attribute(complex_type_xml, 'type', 'm').split('.')[-1])
-    klass = @classes[klass_name].new
+    type = Helpers.get_namespaced_attribute(complex_type_xml, 'type', 'm')
+
+    is_collection = false
+    # Extract the class name in case this is a Collection
+    if type =~ /\(([^)]*)\)/m
+    	type = $~[1]
+      is_collection = true
+      collection = []
+    end
 
-    # Fill in the properties
+    klass_name = qualify_class_name(type.split('.')[-1])
+
+    if is_collection
+      # extract the elements from the collection
+      elements = complex_type_xml.xpath(".//d:element", @namespaces)
+      elements.each do |e|
+        if type.match(/^Edm/)
+          collection << parse_value(e.content, type)
+        else
+          element = @classes[klass_name].new
+          fill_complex_type_properties(e, element)
+          collection << element
+        end
+      end
+      return collection
+    else
+      klass = @classes[klass_name].new
+      # Fill in the properties
+      fill_complex_type_properties(complex_type_xml, klass)
+      return klass
+    end
+  end
+
+  # Helper method for complex_type_to_class
+  def fill_complex_type_properties(complex_type_xml, klass)
     properties = complex_type_xml.xpath(".//*")
     properties.each do |prop|
-      klass.send "#{prop.name}=", parse_value(prop)
+      klass.send "#{prop.name}=", parse_value_xml(prop)
     end
-
-    return klass
   end
 
   # Field Converters
@@ -668,31 +693,36 @@ class Service
   end
 
   # Parses a value into the proper type based on an xml property element
-  def parse_value(property_xml)
+  def parse_value_xml(property_xml)
     property_type = Helpers.get_namespaced_attribute(property_xml, 'type', 'm')
     property_null = Helpers.get_namespaced_attribute(property_xml, 'null', 'm')
 
-    # Handle a nil property type, this is a string
-    return property_xml.content if property_type.nil?
+    if property_type.nil? || (property_type && property_type.match(/^Edm/))
+      return parse_value(property_xml.content, property_type, property_null)
+    end
+
+    complex_type_to_class(property_xml)
+  end
 
+  def parse_value(content, property_type = nil, property_null = nil)
     # Handle anything marked as null
     return nil if !property_null.nil? && property_null == "true"
 
-    # Handle complex types
-    return complex_type_to_class(property_xml) if !property_type.match(/^Edm/)
+    # Handle a nil property type, this is a string
+    return content if property_type.nil?
 
     # Handle integers
-    return property_xml.content.to_i if property_type.match(/^Edm.Int/)
+    return content.to_i if property_type.match(/^Edm.Int/)
 
     # Handle decimals
-    return property_xml.content.to_d if property_type.match(/Edm.Decimal/)
+    return content.to_d if property_type.match(/Edm.Decimal/)
 
     # Handle DateTimes
     # return Time.parse(property_xml.content) if property_type.match(/Edm.DateTime/)
-    return parse_date(property_xml.content) if property_type.match(/Edm.DateTime/)
+    return parse_date(content) if property_type.match(/Edm.DateTime/)
 
     # If we can't parse the value, just return the element's content
-    property_xml.content
+    content
   end
 
   # Parses a value into the proper type based on a specified return type