ruby_odata 0.0.1

data/features/step_definitions/service_steps.rb

@@ -0,0 +1,132 @@
+Given /^an ODataService exists with uri: "([^\"]*)"$/ do |uri|
+  @service = OData::Service.new(uri)
+end
+
+When /^I call "([^\"]*)" on the service$/ do |method|
+  @service_query = @service.send(method)
+end
+
+Then /^the result should be "([^\"]*)"$/ do |result|
+  @service_result.should == result 
+end
+
+Then /^I should be able to call "([^\"]*)" on the service$/ do |method|
+  lambda { @service.send(method) }.should_not raise_error
+end
+
+Then /^I should not be able to call "([^\"]*)" on the service$/ do |method|
+  lambda { @service.send(method) }.should 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
+end
+
+When /^I call "([^\"]*)" on the service with args: "([^\"]*)"$/ do |method, args|
+  @service_query = @service.send(method, args)
+end
+
+When /^I run the query$/ do
+  @service_result = @service.execute
+end
+
+Then /^the result should be of type "([^\"]*)"$/ do |type|
+  @service_result.class.to_s.should == type
+end
+
+Then /^the result should have a method: "([^\"]*)"$/ do |method|
+  @service_result.respond_to?(method.to_sym).should == true
+end
+
+Then /^the method "([^\"]*)" on the result should equal: "([^\"]*)"$/ do |method, value|
+  @service_result.send(method.to_sym).should == value
+end
+
+Then /^the method "([^\"]*)" on the result should be nil$/ do |method|
+  @service_result.send(method.to_sym).should == nil
+end
+
+When /^I set "([^\"]*)" on the result to "([^\"]*)"$/ do |property_name, value|
+	@service_result.send("#{property_name}=", value)
+end
+
+Given /^I expand the query to include "([^\"]*)"$/ do |expands|
+  @service_query.expand(expands)
+end
+
+When /^I filter the query with: "([^\"]*)"$/ do |filter|
+  @service_query.filter(filter)
+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 == type
+end
+
+Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object(?: with (.*))?$/ do |method, object, fields|
+  fields_hash = {}
+  
+  if !fields.nil?
+  	fields.split(', ').each do |field|
+  	if field =~ /^(?:(\w+): "(.*)")$/
+  		key = $1
+  		val = $2
+  		if val =~ /^@@LastSave$/
+  			val = @saved_result
+  		end
+  		
+  		fields_hash.merge!({ key => val })
+		else
+		end
+  	end	
+  end
+  
+  obj = object.constantize.send(:make, fields_hash)
+  @service.send(method.to_sym, obj)
+end
+
+When /^I save changes$/ do
+  @saved_result = @service.save_changes
+end
+
+Then /^the save result should be of type "([^\"]*)"$/ do |type|
+	@saved_result.class.to_s.should == type
+end
+
+When /^I call "([^\"]*)" on the service with the last save result$/ do |method|
+  @service.send(method.to_sym, @saved_result)
+end
+
+When /^I call "([^\"]*)" on the service with the last query result$/ do |method|
+  @service.send(method.to_sym, @service_result)
+end
+
+Then /^the save result should equal: "([^\"]*)"$/ do |result|
+  @saved_result.to_s.should == result
+end
+
+Then /^the method "([^\"]*)" on the save result should equal: "([^\"]*)"$/ do |method, value|
+  result = @saved_result.send(method.to_sym)
+	result.should == value
+end
+
+When /^blueprints exist for the service$/ do
+	require File.expand_path(File.dirname(__FILE__) + "../../../test/blueprints")
+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)
+end
+
+Then /^no "([^\"]*)" should exist$/ do |collection|
+	@service.send(collection)
+	results = @service.execute
+	results.should == []
+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).should == value
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+require 'lib/odata_ruby'
+require 'machinist/object'
+require 'sham'
+require 'faker'

data/features/support/hooks.rb

@@ -0,0 +1,4 @@
+Before do
+	Sham.reset
+	RestClient.post "http://localhost:8888/SampleService/Entities.svc/CleanDatabaseForTesting", {}
+end

data/lib/odata_ruby/class_builder.rb

@@ -0,0 +1,84 @@
+module OData
+	# Internally used helper class for building a dynamic class.  This class shouldn't be called directly.
+	class ClassBuilder
+		# Creates a new instance of the ClassBuilder class
+		#
+		# ==== Required Attributes
+		# - klass_name: 	The name/type of the class to create
+		# - methods:			The accessor methods to add to the class
+		# - nav_props:		The accessor methods to add for navigation properties
+		def initialize(klass_name, methods, nav_props)
+			@klass_name = klass_name
+			@methods = methods
+			@nav_props = nav_props
+		end
+		
+		# Returns a dynamically generated class definition based on the constructor parameters
+		def build
+			# return if already built
+		  return @klass unless @klass.nil?
+		
+		  # need the class name to build class
+		  return nil    if @klass_name.nil?
+		      
+			# return if we can find constant corresponding to class name
+			if Object.constants.include? @klass_name
+				@klass = @klass_name.constantize
+				return @klass
+			end
+		      
+			Object.const_set(@klass_name, Class.new.extend(ActiveSupport::JSON))
+		  @klass = @klass_name.constantize
+ 
+			add_methods(@klass)
+			add_nav_props(@klass)
+			
+		  return @klass
+		end
+		
+		private
+		def add_methods(klass)
+			# Add metadata methods
+			klass.send :define_method, :__metadata do
+				instance_variable_get("@__metadata")
+			end
+			klass.send :define_method, :__metadata= do |value|
+					instance_variable_set("@__metadata", value)
+			end
+		  klass.send :define_method, :as_json do |options|
+				meta = '__metadata'
+				vars = self.instance_values
+				
+				if !options.nil? && !options[:seen].nil? && vars.has_key?(meta)
+					vars.delete_if { |k,v| k != meta}
+				else
+					vars.delete(meta)
+				end
+
+				vars
+			end
+			
+			
+			# Add the methods that were passed in
+			@methods.each do |method_name|
+				klass.send :define_method, method_name do
+					instance_variable_get("@#{method_name}")
+				end
+				klass.send :define_method, "#{method_name}=" do |value|
+					instance_variable_set("@#{method_name}", value)
+				end
+			end
+		end
+		
+		def add_nav_props(klass)
+			@nav_props.each do |method_name|
+				klass.send :define_method, method_name do
+					instance_variable_get("@#{method_name}")
+				end
+				klass.send :define_method, "#{method_name}=" do |value|
+					instance_variable_set("@#{method_name}", value)
+				end				
+			end
+		end
+	end
+end # module OData

data/lib/odata_ruby/operation.rb

@@ -0,0 +1,18 @@
+module OData
+	# Internally used helper class for storing operations called against the service.  This class shouldn't be used directly.
+	class Operation
+		attr_accessor :kind, :klass_name, :klass
+		
+		# Creates a new instance of the Operation class
+		#
+		# ==== Required Attributes
+		# - kind: 				The operation type (Add, Update, or Delete)
+		# - klass_name:		The name/type of the class to operate against
+		# - klass:				The actual class
+		def initialize(kind, klass_name, klass)
+			@kind = kind
+			@klass_name = klass_name
+			@klass = klass
+		end
+	end
+end

data/lib/odata_ruby/query_builder.rb

@@ -0,0 +1,63 @@
+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.
+#
+# For example, given the following code snippet:
+# 		svc = OData::Service.new "http://127.0.0.1:8888/SampleService/Entities.svc"
+# 		svc.Categories
+# The *Categories* method would return a QueryBuilder 
+class QueryBuilder
+	# Creates a new instance of the QueryBuilder class
+	#
+	# ==== Required Attributes
+	# - root: The root entity collection to query against
+	def initialize(root)
+		@root = root.to_s
+		@expands = []
+		@filters = []
+	end
+	
+	# Used to eagerly-load data for nested objects, for example, obtaining a Category for a Product within one call to the server
+	# ==== Required Attributes
+	# - path: The 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 filter data being returned
+	# ==== Required Attributes
+	# - filter: The path of the entity to expand relative to the root
+	#
+	# ==== Example	
+	# 	svc.Products.filter("Name eq 'Product 2'")
+	# 	prod = svc.execute
+	def filter(filter)
+		@filters << CGI.escape(filter)
+		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
+		query_options = []
+		query_options << "$expand=#{@expands.join(',')}" unless @expands.empty?
+		query_options << "$filter=#{@filters.join('+and+')}" unless @filters.empty?
+		if !query_options.empty?
+			q << "?"
+			q << query_options.join('&')	
+		end
+		return q	
+	end
+end
+
+end # Module

data/lib/odata_ruby/service.rb

@@ -0,0 +1,207 @@
+module OData
+	
+class Service
+	attr_reader :classes
+	# Creates a new instance of the Service class
+	#
+	# ==== Required Attributes
+	# - service_uri: The root URI of the OData service
+	def initialize(service_uri)		
+		@uri = service_uri
+		@collections = get_collections
+		build_classes
+	end
+	
+	# Handles the dynamic AddTo<EntityName> methods as well as the collections on the service
+	def method_missing(name, *args)
+		# Queries
+		if @collections.include?(name.to_s)
+			root = "/#{name.to_s.camelize}"
+			root << "(#{args.join(',')})" unless args.empty?
+			@query = QueryBuilder.new(root)
+			return @query
+		# Adds	
+		elsif name.to_s =~ /^AddTo(.*)/
+			type = $1
+			if @collections.include?(type)
+				@save_operation = Operation.new("Add", $1, args[0])
+			else
+				super
+			end
+		else
+			super
+		end
+
+	end
+
+	# Queues an object for deletion.  To actually remove it from the server, you must call save_changes as well.
+	#
+	# ==== Required Attributes
+	# - obj: The object to mark for deletion
+	#
+	# Note: This method will throw an exception if the +obj+ isn't a tracked entity
+	def delete_object(obj)
+		type = obj.class.to_s
+		if obj.respond_to?(:__metadata) && !obj.send(:__metadata).nil? 
+			@save_operation = Operation.new("Delete", type, obj)
+		else
+			raise "You cannot delete a non-tracked entity"
+		end
+	end
+	
+	# Queues an object for update.  To actually update it on the server, you must call save_changes as well.
+	# 
+	# ==== Required Attributes
+	# - obj: The object to queue for update
+	#
+	# Note: This method will throw an exception if the +obj+ isn't a tracked entity	
+	def update_object(obj)
+		type = obj.class.to_s
+		if obj.respond_to?(:__metadata) && !obj.send(:__metadata).nil? 
+			@save_operation = Operation.new("Update", type, obj)
+		else
+			raise "You cannot update a non-tracked entity"
+		end		
+	end
+	
+	# Performs save operations (Create/Update/Delete) against the server
+	def save_changes
+		return nil if @save_operation.nil?
+
+		result = nil
+
+		if @save_operation.kind == "Add"
+			save_uri = "#{@uri}/#{@save_operation.klass_name}"
+			json_klass = @save_operation.klass.to_json
+			post_result = RestClient.post save_uri, json_klass, :content_type => :json
+			result = build_classes_from_result(post_result)
+		elsif @save_operation.kind == "Update"
+			update_uri = @save_operation.klass.send(:__metadata)[:uri]
+			json_klass = @save_operation.klass.to_json
+			update_result = RestClient.put update_uri, json_klass, :content_type => :json
+			return (update_result.code == 204)
+		elsif @save_operation.kind == "Delete"
+			delete_uri = @save_operation.klass.send(:__metadata)[:uri]
+			delete_result = RestClient.delete delete_uri
+			return (delete_result.code == 204) 
+		end
+
+		@save_operation = nil # Clear out the last operation
+		return result
+	end
+
+	# Performs query operations (Read) against the server
+	def execute
+		result = RestClient.get build_query_uri
+		build_classes_from_result(result)
+	end
+	
+	# Overridden to identify methods handled by method_missing  
+	def respond_to?(method)
+		if @collections.include?(method.to_s)
+			return true
+		# Adds	
+		elsif method.to_s =~ /^AddTo(.*)/
+			type = $1
+			if @collections.include?(type)
+				return true
+			else
+				super
+			end
+		else
+			super
+		end
+	end
+	
+	private 
+	def get_collections
+		doc = Nokogiri::XML(open(@uri))
+		collections = doc.xpath("//app:collection", "app" => "http://www.w3.org/2007/app")
+		collections.collect { |c| c["href"] }
+	end	
+	def build_classes
+		@classes = Hash.new
+		doc = Nokogiri::XML(open("#{@uri}/$metadata"))
+
+		# Get the edm namespace
+		edm_ns = doc.xpath("edmx:Edmx/edmx:DataServices/*", "edmx" => "http://schemas.microsoft.com/ado/2007/06/edmx").first.namespaces['xmlns'].to_s
+
+		entity_types = doc.xpath("//edm:EntityType", "edm" => edm_ns)
+		entity_types.each do |e|
+			name = e['Name']
+			props = e.xpath(".//edm:Property", "edm" => edm_ns)
+			methods = props.collect { |p| p['Name'] } # Standard Properties
+			nprops =  e.xpath(".//edm:NavigationProperty", "edm" => edm_ns)			
+			nav_props = nprops.collect { |p| p['Name'] } # Standard Properties
+			@classes[name] = ClassBuilder.new(name, methods, nav_props).build unless @classes.keys.include?(name)
+		end
+	end
+	def build_classes_from_result(result)
+		doc = Nokogiri::XML(result)
+		entries = doc.xpath("//atom:entry[not(ancestor::atom:entry)]", "atom" => "http://www.w3.org/2005/Atom")
+		return entry_to_class(entries[0]) if entries.length == 1
+		
+		results = []
+		entries.each do |entry|
+			results << entry_to_class(entry)
+		end
+		return results
+	end
+	def entry_to_class(entry)
+		# Retrieve the class name from the fully qualified name (the last string after the last dot)
+		klass_name = entry.xpath("./atom:category/@term", "atom" => "http://www.w3.org/2005/Atom").to_s.split('.')[-1]
+		return nil if klass_name.empty?
+
+		properties = entry.xpath(".//m:properties/*", { "m" => "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" })
+				
+		klass = @classes[klass_name].new
+		
+		# Fill metadata
+		meta_id = entry.xpath("./atom:id", "atom" => "http://www.w3.org/2005/Atom")[0].content
+		klass.send :__metadata=, { :uri => meta_id }
+
+		# Fill properties
+		for prop in properties
+			prop_name = prop.name
+			# puts "#{prop_name} - #{prop.content}"
+			klass.send "#{prop_name}=", prop.content 
+		end
+		
+		inline_links = entry.xpath("./atom:link[m:inline]", { "m" => "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata", "atom" => "http://www.w3.org/2005/Atom" })
+		
+		for	link in inline_links
+			inline_entries = link.xpath(".//atom:entry", "atom" => "http://www.w3.org/2005/Atom")
+			
+			if inline_entries.length == 1
+				property_name = link.attributes['title'].to_s
+				
+				build_inline_class(klass, inline_entries[0], property_name)
+      else
+        # TODO: Test handling multiple children
+				for inline_entry in inline_entries
+					property_name = link.xpath("atom:link[@rel='edit']/@title", "atom" => "http://www.w3.org/2005/Atom")
+					
+					# Build the class
+					inline_klass = entry_to_class(inline_entry)
+					
+					# Add the property
+					klass.send "#{property_name}=", inline_klass
+				end
+			end
+		end
+		
+		return klass
+	end
+	def build_query_uri
+		"#{@uri}#{@query.query}"
+	end
+	def build_inline_class(klass, entry, property_name)
+		# Build the class
+		inline_klass = entry_to_class(entry)
+	
+		# Add the property
+		klass.send "#{property_name}=", inline_klass
+	end
+end
+
+end # module OData

data/lib/odata_ruby.rb

@@ -0,0 +1,15 @@
+lib =  File.dirname(__FILE__)
+$: << lib + '/odata_ruby/'
+
+require 'rubygems'
+require 'active_support' 									# Used for serializtion to JSON
+require 'active_support/inflector'
+require 'cgi'
+require 'open-uri'
+require 'rest_client'
+require 'nokogiri'
+
+require lib + '/odata_ruby/query_builder'
+require lib + '/odata_ruby/class_builder'
+require lib + '/odata_ruby/operation'
+require lib + '/odata_ruby/service'

data/ruby_odata.gemspec

@@ -0,0 +1,94 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby_odata}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Damien White"]
+  s.date = %q{2010-06-11}
+  s.description = %q{An OData Client Library for Ruby.  Use this to interact with OData services}
+  s.email = %q{damien.white@visoftinc.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "config/cucumber.yml",
+     "doc/classes/OData.html",
+     "doc/classes/OData/ClassBuilder.html",
+     "doc/classes/OData/Operation.html",
+     "doc/classes/OData/QueryBuilder.html",
+     "doc/classes/OData/Service.html",
+     "doc/created.rid",
+     "doc/files/README_rdoc.html",
+     "doc/files/lib/odata_ruby/class_builder_rb.html",
+     "doc/files/lib/odata_ruby/operation_rb.html",
+     "doc/files/lib/odata_ruby/query_builder_rb.html",
+     "doc/files/lib/odata_ruby/service_rb.html",
+     "doc/files/lib/odata_ruby_rb.html",
+     "doc/fr_class_index.html",
+     "doc/fr_file_index.html",
+     "doc/fr_method_index.html",
+     "doc/index.html",
+     "doc/rdoc-style.css",
+     "features/service.feature",
+     "features/service_manage.feature",
+     "features/step_definitions/service_steps.rb",
+     "features/support/env.rb",
+     "features/support/hooks.rb",
+     "lib/odata_ruby.rb",
+     "lib/odata_ruby/class_builder.rb",
+     "lib/odata_ruby/operation.rb",
+     "lib/odata_ruby/query_builder.rb",
+     "lib/odata_ruby/service.rb",
+     "ruby_odata.gemspec",
+     "test/Cassini x64.bat",
+     "test/Cassini x86.bat",
+     "test/SampleService/App_Code/Entities.cs",
+     "test/SampleService/App_Code/Model.Designer.cs",
+     "test/SampleService/App_Code/Model.edmx",
+     "test/SampleService/App_Data/_TestDB.mdf",
+     "test/SampleService/App_Data/_TestDB_Log.ldf",
+     "test/SampleService/Entities.svc",
+     "test/SampleService/web.config",
+     "test/blueprints.rb"
+  ]
+  s.homepage = %q{http://github.com/visoft/ruby_odata}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{ruby-odata}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby consumer of OData services.}
+  s.test_files = [
+    "test/blueprints.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.5"])
+      s.add_runtime_dependency(%q<rest-client>, [">= 1.5.1"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.2"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+      s.add_dependency(%q<rest-client>, [">= 1.5.1"])
+      s.add_dependency(%q<nokogiri>, [">= 1.4.2"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.3.5"])
+    s.add_dependency(%q<rest-client>, [">= 1.5.1"])
+    s.add_dependency(%q<nokogiri>, [">= 1.4.2"])
+  end
+end
+

data/test/Cassini x64.bat

@@ -0,0 +1 @@
+"%ProgramFiles(x86)%\Common Files\microsoft shared\DevServer\10.0\WebDev.WebServer40.EXE" /port:8888 /path:"%~dp0SampleService" /vpath:"/SampleService"

data/test/Cassini x86.bat

@@ -0,0 +1 @@
+"%ProgramFiles%\Common Files\microsoft shared\DevServer\10.0\WebDev.WebServer40.EXE" /port:8888 /path:"%~dp0SampleService" /vpath:"/SampleService"

data/test/SampleService/App_Code/Entities.cs

@@ -0,0 +1,39 @@
+using System.Data.Services;
+using System.Data.Services.Common;
+using System.ServiceModel.Web;
+using System.Web;
+using Model;
+
+public class Entities : DataService< ModelContainer >
+{
+    // This method is called only once to initialize service-wide policies.
+    public static void InitializeService(DataServiceConfiguration config)
+    {
+        config.SetEntitySetAccessRule("*", EntitySetRights.All);
+        config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
+        config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
+    }
+
+    /// <summary>
+    /// Cleans the database for testing.
+    /// </summary>
+    [WebInvoke]
+    public void CleanDatabaseForTesting()
+    {
+        var context = new ModelContainer();
+        context.ExecuteStoreCommand("ALTER TABLE [dbo].[Products] DROP CONSTRAINT [FK_CategoryProduct]");
+        context.ExecuteStoreCommand("TRUNCATE TABLE [dbo].[Categories]; TRUNCATE TABLE [dbo].[Products]");
+        context.ExecuteStoreCommand("ALTER TABLE [dbo].[Products] ADD CONSTRAINT [FK_CategoryProduct] FOREIGN KEY ([Category_Id]) REFERENCES [dbo].[Categories]([Id])");
+
+    }
+
+    protected override void OnStartProcessingRequest(ProcessRequestArgs args)
+    {
+        base.OnStartProcessingRequest(args);
+        if (args.RequestUri.AbsoluteUri.ToLower().EndsWith("cleandatabasefortesting"))
+        {
+            if (HttpContext.Current.Request.UserHostAddress != "127.0.0.1")
+                throw new DataServiceException(401, "Access Denied");
+        }
+    }
+}