ruby_odata 0.1.6 → 0.2.0.beta1

data/lib/ruby_odata/resource.rb

@@ -0,0 +1,153 @@
+module OData
+  class Resource
+    attr_reader :url, :options, :block
+
+    def initialize(url, options={}, backwards_compatibility=nil, &block)
+      @url = url
+      @block = block
+      @options = options.is_a?(Hash) ? options : { user: options, password: backwards_compatibility }
+
+      @conn = Faraday.new(url: url, ssl: { verify: verify_ssl }) do |faraday|
+        faraday.use      :gzip
+        faraday.response :raise_error
+        faraday.adapter  :excon
+
+        faraday.options.timeout      = timeout if timeout
+        faraday.options.open_timeout = open_timeout if open_timeout
+
+        faraday.headers = (faraday.headers || {}).merge(@options[:headers] || {})
+        faraday.headers = (faraday.headers).merge({
+          :accept => '*/*; q=0.5, application/xml',
+        })
+
+        faraday.basic_auth user, password if user# this adds to headers so must be behind
+      end
+
+      @conn.headers[:user_agent] = 'Ruby'
+    end
+
+    def get(additional_headers={})
+      @conn.get do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+      end
+    end
+
+    def head(additional_headers={})
+      @conn.head do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+      end
+    end
+
+    def post(payload, additional_headers={})
+      @conn.post do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+        req.body = prepare_payload payload
+      end
+    end
+
+    def put(payload, additional_headers={})
+      @conn.put do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+        req.body = prepare_payload payload
+      end
+    end
+
+    def patch(payload, additional_headers={})
+      @conn.patch do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+        req.body = prepare_payload payload
+      end
+    end
+
+    def delete(additional_headers={})
+      @conn.delete do |req|
+        req.url url
+        req.headers = (headers || {}).merge(additional_headers)
+      end
+    end
+
+    def to_s
+      url
+    end
+
+    def user
+      options[:user]
+    end
+
+    def password
+      options[:password]
+    end
+
+    def verify_ssl
+      options[:verify_ssl]
+    end
+
+    def headers
+      @conn.headers || {}
+    end
+
+    def timeout
+      options[:timeout]
+    end
+
+    def open_timeout
+      options[:open_timeout]
+    end
+
+    # Construct a subresource, preserving authentication.
+    #
+    # Example:
+    #
+    #   site = RestClient::Resource.new('http://example.com', 'adam', 'mypasswd')
+    #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+    #
+    # This is especially useful if you wish to define your site in one place and
+    # call it in multiple locations:
+    #
+    #   def orders
+    #     RestClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
+    #   end
+    #
+    #   orders.get                     # GET http://example.com/orders
+    #   orders['1'].get                # GET http://example.com/orders/1
+    #   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
+    #
+    # Nest resources as far as you want:
+    #
+    #   site = RestClient::Resource.new('http://example.com')
+    #   posts = site['posts']
+    #   first_post = posts['1']
+    #   comments = first_post['comments']
+    #   comments.post 'Hello', :content_type => 'text/plain'
+    #
+    def [](suburl, &new_block)
+      case
+        when block_given? then self.class.new(concat_urls(url, suburl), options, &new_block)
+        when block        then self.class.new(concat_urls(url, suburl), options, &block)
+      else
+        self.class.new(concat_urls(url, suburl), options)
+      end
+    end
+
+    def concat_urls(url, suburl) # :nodoc:
+      url = url.to_s
+      suburl = suburl.to_s
+      if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
+        url + suburl
+      else
+        "#{url}/#{suburl}"
+      end
+    end
+
+    def prepare_payload payload
+      JSON.generate(payload)
+    rescue JSON::GeneratorError
+      payload
+    end
+  end
+end

data/lib/ruby_odata/service.rb

@@ -9,7 +9,7 @@ class Service
   # @option options [String] :username for http basic auth
   # @option options [String] :password for http basic auth
   # @option options [Object] :verify_ssl false if no verification, otherwise mode (OpenSSL::SSL::VERIFY_PEER is default)
-  # @option options [Hash] :rest_options a hash of rest-client options that will be passed to all RestClient::Resource.new calls
+  # @option options [Hash] :rest_options a hash of rest-client options that will be passed to all OData::Resource.new calls
   # @option options [Hash] :additional_params a hash of query string params that will be passed on all calls
   # @option options [Boolean, true] :eager_partial true if queries should consume partial feeds until the feed is complete, false if explicit calls to next must be performed
   def initialize(service_uri, options = {})
@@ -97,12 +97,12 @@ class Service
   # @raise [ServiceError] if there is an error when talking to the service
   def execute
     begin
-      @response = RestClient::Resource.new(build_query_uri, @rest_options).get
+      @response = OData::Resource.new(build_query_uri, @rest_options).get
     rescue Exception => e
       handle_exception(e)
     end
-    return Integer(@response) if @response =~ /^\d+$/
-    handle_collection_result(@response)
+    return Integer(@response.body) if @response.body =~ /^\d+$/
+    handle_collection_result(@response.body)
   end
 
   # Overridden to identify methods handled by method_missing
@@ -147,8 +147,8 @@ class Service
     raise NotSupportedError, "You cannot load a property on an entity that isn't tracked" if obj.send(:__metadata).nil?
     raise ArgumentError, "'#{nav_prop}' is not a valid navigation property" unless obj.respond_to?(nav_prop.to_sym)
     raise ArgumentError, "'#{nav_prop}' is not a valid navigation property" unless @class_metadata[obj.class.to_s][nav_prop].nav_prop
-    results = RestClient::Resource.new(build_load_property_uri(obj, nav_prop), @rest_options).get
-    prop_results = build_classes_from_result(results)
+    results = OData::Resource.new(build_load_property_uri(obj, nav_prop), @rest_options).get
+    prop_results = build_classes_from_result(results.body)
     obj.send "#{nav_prop}=", (singular?(nav_prop) ? prop_results.first : prop_results)
   end
 
@@ -224,7 +224,7 @@ class Service
     @rest_options.merge!(options[:rest_options] || {})
     @additional_params = options[:additional_params] || {}
     @namespace = options[:namespace]
-    @json_type = options[:json_type] || :json
+    @json_type = options[:json_type] || 'application/json'
   end
 
   def default_instance_vars!
@@ -236,7 +236,7 @@ class Service
   end
 
   def set_namespaces
-    @edmx = Nokogiri::XML(RestClient::Resource.new(build_metadata_uri, @rest_options).get)
+    @edmx = Nokogiri::XML(OData::Resource.new(build_metadata_uri, @rest_options).get.body)
     @ds_namespaces = {
       "m" => "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata",
       "edmx" => "http://schemas.microsoft.com/ado/2007/06/edmx",
@@ -376,8 +376,8 @@ class Service
   def handle_exception(e)
     raise e unless defined? e.response
 
-    code = e.http_code
-    error = Nokogiri::XML(e.response)
+    code = e.response[:status]
+    error = Nokogiri::XML(e.response[:body])
 
     message = if error.xpath("m:error/m:message", @ds_namespaces).first
                 error.xpath("m:error/m:message", @ds_namespaces).first.content
@@ -509,8 +509,8 @@ class Service
 
   def handle_partial
     if @next_uri
-      result = RestClient::Resource.new(@next_uri, @rest_options).get
-      results = handle_collection_result(result)
+      result = OData::Resource.new(@next_uri, @rest_options).get
+      results = handle_collection_result(result.body)
     end
     results
   end
@@ -600,26 +600,26 @@ 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_type}
-      return build_classes_from_result(post_result)
+      post_result = OData::Resource.new(save_uri, @rest_options).post json_klass, {:content_type => @json_type}
+      return build_classes_from_result(post_result.body)
     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_type}
-      return (update_result.code == 204)
+      update_result = OData::Resource.new(update_uri, @rest_options).put json_klass, {:content_type => @json_type}
+      return (update_result.status == 204)
     elsif operation.kind == "Delete"
       delete_uri = build_resource_uri(operation)
-      delete_result = RestClient::Resource.new(delete_uri, @rest_options).delete
-      return (delete_result.code == 204)
+      delete_result = OData::Resource.new(delete_uri, @rest_options).delete
+      return (delete_result.status == 204)
     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_type}
+      post_result = OData::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)
+      link_child_to_parent(operation) if (post_result.status == 204)
 
-      return(post_result.code == 204)
+      return(post_result.status == 204)
     end
   end
 
@@ -633,11 +633,11 @@ class Service
     batch_uri = build_batch_uri
 
     body = build_batch_body(operations, batch_num, changeset_num)
-    result = RestClient::Resource.new( batch_uri, @rest_options).post body, {:content_type => "multipart/mixed; boundary=batch_#{batch_num}"}
+    result = OData::Resource.new( batch_uri, @rest_options).post body, {:content_type => "multipart/mixed; boundary=batch_#{batch_num}"}
 
     # TODO: More result validation needs to be done.
     # The result returns HTTP 202 even if there is an error in the batch
-    return (result.code == 202)
+    return (result.status == 202)
   end
   def build_batch_body(operations, batch_num, changeset_num)
     # Header
@@ -827,17 +827,17 @@ class Service
     func[:parameters].keys.each_with_index { |key, i| params[key] = args[0][i] } unless func[:parameters].nil?
 
     function_uri = build_function_import_uri(name, params)
-    result = RestClient::Resource.new(function_uri, @rest_options).send(func[:http_method].downcase, {})
+    result = OData::Resource.new(function_uri, @rest_options).send(func[:http_method].downcase, {})
 
     # Is this a 204 (No content) result?
-    return true if result.code == 204
+    return true if result.status == 204
 
     # No? Then we need to parse the results. There are 4 kinds...
     if func[:return_type] == Array
       # a collection of entites
-      return build_classes_from_result(result) if @classes.include?(func[:inner_return_type].to_s)
+      return build_classes_from_result(result.body) if @classes.include?(func[:inner_return_type].to_s)
       # a collection of native types
-      elements = Nokogiri::XML(result).xpath("//ds:element", @ds_namespaces)
+      elements = Nokogiri::XML(result.body).xpath("//ds:element", @ds_namespaces)
       results = []
       elements.each do |e|
         results << parse_primative_type(e.content, func[:inner_return_type])
@@ -847,18 +847,18 @@ class Service
 
     # a single entity
     if @classes.include?(func[:return_type].to_s)
-      entry = Nokogiri::XML(result).xpath("atom:entry[not(ancestor::atom:entry)]", @ds_namespaces)
+      entry = Nokogiri::XML(result.body).xpath("atom:entry[not(ancestor::atom:entry)]", @ds_namespaces)
       return entry_to_class(entry)
     end
 
     # or a single native type
     unless func[:return_type].nil?
-      e = Nokogiri::XML(result).xpath("/*").first
+      e = Nokogiri::XML(result.body).xpath("/*").first
       return parse_primative_type(e.content, func[:return_type])
     end
 
     # Nothing could be parsed, so just return if we got a 200 or not
-    return (result.code == 200)
+    return (result.status == 200)
   end
 
   # Helpers

data/lib/ruby_odata/version.rb

@@ -1,5 +1,5 @@
 # The ruby_odata namespace
 module OData
   # The current version of ruby_odata
-  VERSION = "0.1.6"
+  VERSION = "0.2.0.beta1"
 end

data/ruby_odata.gemspec

@@ -1,43 +1,48 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "ruby_odata/version"
-
-Gem::Specification.new do |s|
-  s.name        = "ruby_odata"
-  s.version     = OData::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Damien White"]
-  s.email       = ["damien.white@visoftinc.com"]
-  s.homepage    = %q{http://github.com/visoft/ruby_odata}
-  s.summary     = %q{Ruby consumer of OData services.}
-  s.description = %q{An OData Client Library for Ruby.  Use this to interact with OData services}
-  s.license     = "MIT"
-
-  s.rubyforge_project = "ruby-odata"
-
-  s.required_ruby_version = '>= 1.9.3'
-
-  s.add_dependency("addressable", ">= 2.3.4")
-  s.add_dependency("i18n", "~> 0.6.0")
-  s.add_dependency("activesupport", ">= 3.0.0")
-  s.add_dependency("rest-client", ">= 1.5.1")
-  s.add_dependency("nokogiri", ">= 1.4.2")
-
-  s.add_development_dependency("rake", "0.9.2")
-  s.add_development_dependency("rspec", "~> 2.11.0")
-  s.add_development_dependency("cucumber", "~> 1.2.1")
-  s.add_development_dependency("pickle", "~> 0.4.11")
-  s.add_development_dependency("machinist", "~> 2.0")
-  s.add_development_dependency("webmock", "~> 1.11.0")
-  s.add_development_dependency("guard", "~> 1.3.0")
-  s.add_development_dependency("guard-rspec", "~> 1.2.1")
-  s.add_development_dependency("guard-cucumber", "~> 1.2.0")
-  s.add_development_dependency("vcr", "~> 2.5.0")
-  s.add_development_dependency("simplecov", "~> 0.7.1")
-  s.add_development_dependency("coveralls", "~> 0.6.7")
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby_odata/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ruby_odata"
+  s.version     = OData::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Damien White"]
+  s.email       = ["damien.white@visoftinc.com"]
+  s.homepage    = %q{http://github.com/visoft/ruby_odata}
+  s.summary     = %q{Ruby consumer of OData services.}
+  s.description = %q{An OData Client Library for Ruby.  Use this to interact with OData services}
+  s.license     = "MIT"
+
+  s.rubyforge_project = "ruby-odata"
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency("addressable", ">= 2.3.4")
+  s.add_dependency("i18n", ">= 0.7.0")
+  s.add_dependency("activesupport", ">= 3.0.0")
+  s.add_dependency("excon", "~> 0.45.3")
+  s.add_dependency("faraday_middleware")
+  s.add_dependency("faraday", "~> 0.9.1")
+  s.add_dependency("nokogiri", ">= 1.4.2")
+
+  s.add_development_dependency("rake", ">=0.9.2")
+  s.add_development_dependency("rspec", "~> 3.2.0")
+  s.add_development_dependency("rspec-its", "~> 1.2.0")
+  s.add_development_dependency("cucumber", "~> 2.0.0")
+  s.add_development_dependency("pickle", "~> 0.5.1")
+  s.add_development_dependency("machinist", "~> 2.0")
+  s.add_development_dependency("webmock", "~> 1.21.0")
+  s.add_development_dependency("guard", "~> 2.12.5")
+  s.add_development_dependency("guard-rspec", "~> 4.5.0")
+  s.add_development_dependency("guard-cucumber", "~> 1.6.0")
+  s.add_development_dependency("vcr", "~> 2.9.3")
+  s.add_development_dependency("simplecov", "~> 0.7.1")
+  s.add_development_dependency("coveralls", "~> 0.6.7")
+  s.add_development_dependency("pry")
+  s.add_development_dependency("pry-nav")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/association_spec.rb

@@ -4,7 +4,7 @@ module OData
   describe Association do
     before(:all) do
       stub_request(:get, /http:\/\/test\.com\/test\.svc\/\$metadata(?:\?.+)?/).
-      with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate'}).
+      with(:headers => DEFAULT_HEADERS).
       to_return(:status => 200, :body => File.new(File.expand_path("../fixtures/sample_service/edmx_categories_products.xml", __FILE__)), :headers => {})
 
       @svc = OData::Service.new "http://test.com/test.svc/$metadata"
@@ -13,33 +13,37 @@ module OData
     describe "#initialize singlular navigation property" do
       before { @association = Association.new @product_category, @svc.edmx }
       subject { @association }
-      
-      it "should set the association name" do
+
+      it "sets the association name" do
         subject.name.should eq 'Category_Products'
       end
-      it "should set the association namespace" do
+
+      it "sets the association namespace" do
         subject.namespace.should eq 'RubyODataService'
       end
-      it "should set the relationship name" do
+
+      it "sets the relationship name" do
         subject.relationship.should eq 'RubyODataService.Category_Products'
       end
+
       context "from_role method" do
         subject { @association.from_role }
-        it { should have_key 'Category_Products_Target'}        
-        it "should set the edmx type" do
+        it { should have_key 'Category_Products_Target'}
+        it "sets the edmx type" do
           subject['Category_Products_Target'][:edmx_type].should eq 'RubyODataService.Product'
         end
-        it "should set the multiplicity" do
+        it "sets the multiplicity" do
           subject['Category_Products_Target'][:multiplicity].should eq '*'
         end
       end
+
       context "to_role method" do
         subject { @association.to_role }
-        it { should have_key 'Category_Products_Source'}        
-        it "should set the edmx type" do
+        it { should have_key 'Category_Products_Source'}
+        it "sets the edmx type" do
           subject['Category_Products_Source'][:edmx_type].should eq 'RubyODataService.Category'
         end
-        it "should set the multiplicity" do
+        it "sets the multiplicity" do
           subject['Category_Products_Source'][:multiplicity].should eq '1'
         end
       end