odata_server 0.0.1

data/app/views/o_data/metadata.xml.builder

@@ -0,0 +1,62 @@
+xml.instruct!
+xml.edmx(:Edmx, :Version => "1.0", "xmlns:edmx" => "http://schemas.microsoft.com/ado/2007/06/edmx", "xml:base" => o_data_metadata_url, "xml:id" => "") do
+  xml.edmx(:DataServices, "m:DataServiceVersion" => "2.0", "xmlns:m" => "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata") do
+    xml.tag!(:Schema, :Namespace => ODataController.schema.namespace, "xmlns:d" => "http://schemas.microsoft.com/ado/2007/08/dataservices", "xmlns" => "http://schemas.microsoft.com/ado/2007/05/edm", "xml:id" => "Schema") do
+      ODataController.schema.entity_types.sort_by(&:qualified_name).each do |entity_type|
+        xml.tag!(:EntityType, :Name => entity_type.name) do
+          unless entity_type.key_property.blank?
+            xml.tag!(:Key) do
+              xml.tag!(:PropertyRef, :Name => entity_type.key_property.name)
+            end
+          end
+          
+          entity_type.properties.each do |property|
+            property_attrs = { :Name => property.name, :Type => property.return_type, :Nullable => property.nullable? }
+
+            property_attrs.merge!("m:FC_TargetPath" => "SyndicationTitle", "m:FC_ContentKind" => "text", "m:FC_KeepInContent" => "true") if property == entity_type.atom_title_property
+            property_attrs.merge!("m:FC_TargetPath" => "SyndicationSummary", "m:FC_ContentKind" => "text", "m:FC_KeepInContent" => "false") if property == entity_type.atom_summary_property
+            property_attrs.merge!("m:FC_TargetPath" => "SyndicationUpdated", "m:FC_ContentKind" => "text", "m:FC_KeepInContent" => "true") if property == entity_type.atom_updated_at_property
+            
+            xml.tag!(:Property, property_attrs)
+          end
+          
+          entity_type.navigation_properties.sort_by(&:qualified_name).each do |navigation_property|
+            xml.tag!(:NavigationProperty, :Name => navigation_property.name, :Relationship => navigation_property.association.qualified_name, :FromRole => navigation_property.from_end.name, :ToRole => navigation_property.to_end.name)
+          end
+        end
+      end
+      
+      ODataController.schema.associations.sort_by(&:qualified_name).each do |association|
+        xml.tag!(:Association, :Name => association.name) do
+          xml.tag!(:End, :Role => association.from_end.name, :Type => association.from_end.return_type, :Multiplicity => association.from_end.to_multiplicity)
+          xml.tag!(:End, :Role => association.to_end.name, :Type => association.to_end.return_type, :Multiplicity => association.to_end.to_multiplicity)
+          xml.tag!(:ReferentialConstraint) do
+            xml.tag!(:Dependent, :Role => association.from_end.name) do
+              OData::ActiveRecordSchema::Association.column_names_for_from_end(association.reflection).each do |column_name|
+                xml.tag!(:PropertyRef, :Name => column_name)
+              end
+            end
+            xml.tag!(:Principal, :Role => association.to_end.name) do
+              OData::ActiveRecordSchema::Association.column_names_for_to_end(association.reflection).each do |column_name|
+                xml.tag!(:PropertyRef, :Name => column_name)
+              end
+            end
+          end
+        end
+      end
+      
+      xml.tag!(:EntityContainer, :Name => ODataController.schema.namespace, "m:IsDefaultEntityContainer" => true) do
+        ODataController.schema.entity_types.sort_by(&:qualified_name).each do |entity_type|
+          xml.tag!(:EntitySet, :Name => entity_type.plural_name, :EntityType => entity_type.qualified_name)
+        end
+        
+        ODataController.schema.associations.sort_by(&:qualified_name).each do |association|
+          xml.tag!(:AssociationSet, :Name => association.name, :Association => association.qualified_name) do
+            xml.tag!(:End, :EntitySet => association.from_end.entity_type.plural_name, :Role => association.from_end.name)
+            xml.tag!(:End, :EntitySet => association.reflection.options[:polymorphic] ? association.to_end.return_type : association.to_end.entity_type.plural_name, :Role => association.to_end.name)
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/o_data/resource.atom.builder

@@ -0,0 +1,8 @@
+xml.instruct!
+
+if @countable
+  o_data_atom_feed(xml, @query, @results, :expand => @expand_navigation_property_paths)
+else
+  first_result = [@results].flatten.compact.first
+  o_data_atom_entry(xml, @query, first_result, :expand => @expand_navigation_property_paths)
+end

data/app/views/o_data/resource.json.erb

@@ -0,0 +1 @@
+<%= if @countable then o_data_json_feed(@query, @results, :expand => @expand_navigation_property_paths).to_json else o_data_json_entry(@query, [@results].flatten.compact.first, :d => true, :expand => @expand_navigation_property_paths).to_json end %>

data/app/views/o_data/service.xml.builder

@@ -0,0 +1,11 @@
+xml.instruct!
+xml.tag!(:service, "xmlns:atom" => "http://www.w3.org/2005/Atom", "xmlns" => "http://www.w3.org/2007/app", "xml:base" => o_data_service_url) do
+  xml.tag!(:workspace) do
+    xml.atom(:title, ODataController.schema.namespace)
+    ODataController.schema.entity_types.collect(&:plural_name).sort.each do |plural_name|
+      xml.tag!(:collection, :href => plural_name) do
+        xml.atom(:title, plural_name)
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,11 @@
+ActionController::Routing::Routes.draw do |map|
+  map.with_options(:controller => "o_data") do |o_data|
+    o_data.o_data_service  "/OData/OData.svc",                                     :action => "service"
+    o_data.o_data_metadata "/OData/OData.svc/$metadata",                           :action => "metadata"
+    o_data.o_data_resource "/OData/OData.svc/*#{ODataController.path_param.to_s}", :action => "resource"
+    
+    o_data.connect "/OData",                                     :action => "redirect_to_service"
+    o_data.connect "/OData/$metadata",                           :action => "redirect_to_metadata"
+    o_data.connect "/OData/*#{ODataController.path_param.to_s}", :action => "redirect_to_resource"
+  end
+end

data/init.rb

@@ -0,0 +1,3 @@
+# Include hook code here
+
+require "o_data"

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/o_data/abstract_query.rb

@@ -0,0 +1,27 @@
+require "o_data/abstract_query/errors"
+require "o_data/abstract_query/countable"
+require "o_data/abstract_query/base"
+require "o_data/abstract_query/segment"
+require "o_data/abstract_query/option"
+
+require "o_data/abstract_query/segments/entity_type_segment"
+require "o_data/abstract_query/segments/entity_type_and_key_values_segment"
+
+require "o_data/abstract_query/segments/collection_segment"
+require "o_data/abstract_query/segments/navigation_property_segment"
+require "o_data/abstract_query/segments/property_segment"
+require "o_data/abstract_query/segments/value_segment"
+require "o_data/abstract_query/segments/links_segment"
+require "o_data/abstract_query/segments/count_segment"
+
+require "o_data/abstract_query/options/enumerated_option"
+
+require "o_data/abstract_query/options/format_option"
+require "o_data/abstract_query/options/inlinecount_option"
+require "o_data/abstract_query/options/top_option"
+require "o_data/abstract_query/options/skip_option"
+require "o_data/abstract_query/options/orderby_option"
+require "o_data/abstract_query/options/select_option"
+require "o_data/abstract_query/options/expand_option"
+
+require "o_data/abstract_query/parser"

data/lib/o_data/abstract_query/base.rb

@@ -0,0 +1,133 @@
+module OData
+  module AbstractQuery
+    class Base
+      attr_reader :schema
+      attr_reader :segments, :options
+      
+      def initialize(schema, segments = [], options = [])
+        @schema = schema
+        
+        @segments = segments
+        @options = options
+      end
+      
+      def inspect
+        "#<< #{@schema.namespace.to_s}(#{self.to_uri.inspect}) >>"
+      end
+      
+      def Segment(*args)
+        segment_class = begin
+          if args.first.is_a?(Symbol) || args.first.is_a?(String)
+            "OData::AbstractQuery::Segments::#{args.shift.to_s}Segment".constantize
+          else
+            args.shift
+          end
+        end
+        
+        segment = segment_class.new(self, *args)
+        
+        @segments << segment
+        segment
+      end
+      
+      def Option(*args)
+        option_class = begin
+          if args.first.is_a?(Symbol) || args.first.is_a?(String)
+            "OData::AbstractQuery::Options::#{args.shift.to_s}Option".constantize
+          else
+            args.shift
+          end
+        end
+        
+        option = option_class.new(self, *args)
+        
+        @options << option
+        option
+      end
+      
+      def resource_path
+        @segments.collect(&:value).join('/')
+      end
+      
+      def query_string
+        @options.collect { |o| "#{o.key.to_s}=#{o.value.to_s}" }.join('&')
+      end
+      
+      def to_uri
+        [resource_path, query_string].reject(&:blank?).join('?')
+      end
+      
+      def execute!
+        _execute!
+      end
+      
+      # def entity_type
+      #   return nil if @segments.empty?
+      #   return nil unless @segments.last.respond_to?(:entity_type)
+      #   @segments.last.entity_type
+      # end
+      
+      protected
+      
+      def _execute!
+        _segments = [@segments].flatten.compact
+        results = __execute!([], nil, _segments.shift, _segments)
+        
+        results = with_skip_and_top_options(with_orderby_option(results))
+        
+        results
+      end
+      
+      def __execute!(seen, acc, head, rest)
+        return acc if head.blank?
+        raise Errors::InvalidSegmentContext.new(self, head) unless seen.empty? || head.can_follow?(seen.last)
+        
+        results = head.execute!(acc)
+        raise Errors::ExecutionOfSegmentFailedValidation.new(self, head) unless head.valid?(results)
+
+        seen << head
+        __execute!(seen, results, rest.shift, rest)
+      end
+      
+      private
+      
+      def with_orderby_option(results)
+        orderby_option = @options.find { |o| o.option_name == Options::OrderbyOption.option_name }
+        
+        orderby = orderby_option.blank? ? nil : orderby_option.pairs
+        
+        if orderby && (entity_type = orderby_option.entity_type)
+          results = entity_type.sort(results, orderby)
+        else
+          results
+        end
+      end
+      
+      def with_skip_and_top_options(results)
+        skip_option = @options.find { |o| o.option_name == Options::SkipOption.option_name }
+        top_option = @options.find { |o| o.option_name == Options::TopOption.option_name }
+        
+        skip = skip_option.blank? ? nil : skip_option.value.to_i
+        top = top_option.blank? ? nil : top_option.value.to_i
+        
+        if skip && top
+          results = results.slice(skip, top)
+        elsif skip
+          results = results.slice(skip..-1)
+        elsif top
+          results = results.slice(0, top)
+        else
+          results
+        end
+      end
+    end
+  end
+  
+  module AbstractSchema
+    class Base
+      def Query(*args)
+        OData::AbstractQuery::Base.new(self, *args)
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/countable.rb

@@ -0,0 +1,22 @@
+module OData
+  module AbstractQuery
+    module Countable
+      def self.included(base)
+        base.send(:extend, SingletonMethods)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module SingletonMethods
+        def countable?
+          false
+        end
+      end
+      
+      module InstanceMethods
+        def countable?
+          self.class.countable?
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/errors.rb

@@ -0,0 +1,117 @@
+module OData
+  module AbstractQuery
+    module Errors
+      class AbstractQueryException < OData::ODataException
+        attr_reader :query
+        
+        def initialize(query)
+          @query = query
+        end
+        
+        def to_s
+          "An unknown error has occured."
+        end
+      end
+      
+      class ParseQuerySegmentException < AbstractQueryException
+        attr_reader :str
+        
+        def initialize(query, str)
+          super(query)
+          @str = str
+        end
+        
+        def to_s
+          "Resource not found for the segment '#{@str.to_s}'."
+        end
+      end
+      
+      class EntityTypeNotFound < ParseQuerySegmentException
+        def to_s
+          "EntityType not found for the segment '#{self.str.to_s}'"
+        end
+      end
+      
+      class PropertyNotFound < ParseQuerySegmentException
+        def to_s
+          "Property not found for the segment '#{self.str.to_s}'"
+        end
+      end
+      
+      class NavigationPropertyNotFound < ParseQuerySegmentException
+        def to_s
+          "NavigationProperty not found for the segment '#{self.str.to_s}'"
+        end
+      end
+      
+      class AbstractQuerySegmentException < AbstractQueryException
+        attr_reader :segment
+        
+        def initialize(query, segment)
+          super(query)
+          
+          @segment = segment
+        end
+      end
+      
+      class ExecutionOfSegmentFailedValidation < AbstractQuerySegmentException
+        def to_s
+          "Execution of the segment '#{@segment.value}' did not return a valid result."
+        end
+      end
+      
+      class InvalidSegmentContext < AbstractQuerySegmentException
+        def to_s
+          "Invalid context for the segment '#{@segment.value}'."
+        end
+      end
+      
+      class AbstractQueryKeyValueException < AbstractQueryException
+        attr_reader :key, :value
+        
+        def initialize(query, key, value)
+          super(query)
+          
+          @key = key
+          @value = value
+        end
+        
+        def to_s
+          "An unknown error has occured for the query option '#{@key.to_s}'."
+        end
+      end
+      
+      class InvalidReservedOptionName < AbstractQueryKeyValueException
+        def to_s
+          "The query parameter '#{self.key.to_s}' begins with a system-reserved '$' character but is not recognized."
+        end
+      end
+      
+      class AbstractQueryOptionException < AbstractQueryException
+        attr_reader :option
+        
+        def initialize(query, option)
+          super(query)
+          
+          @option = option
+        end
+        
+        def to_s
+          "Invalid '#{@option.option_name.to_s}' query option."
+        end
+      end
+      
+      class InvalidOptionContext < AbstractQueryOptionException
+        def to_s
+          "Invalid context for the query option '#{self.option.option_name.to_s}'."
+        end
+      end
+      
+      class InvalidOptionValue < AbstractQueryOptionException
+        def to_s
+          "Invalid value for '#{self.option.option_name.to_s}' query option#{" - the only acceptable values are #{self.option.valid_values.collect { |v| v.to_s.inspect }.to_sentence}" if self.option.respond_to?(:valid_values)}."
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/option.rb

@@ -0,0 +1,58 @@
+module OData
+  module AbstractQuery
+    class BasicOption
+      def self.option_name(option)
+        nil
+      end
+      
+      def option_name
+        @key
+      end
+      
+      attr_reader :query, :key, :value
+      
+      def initialize(query, key, value = nil)
+        @query = query
+        @key = key
+        @value = value
+      end
+      
+      def inspect
+        "#<< #{@query.schema.namespace.to_s}(#{@key.to_s}=#{@value.to_s}) >>"
+      end
+    end
+    
+    class Option < BasicOption
+      def self.option_name
+        name.to_s.demodulize.sub(/Option$/, '')
+      end
+      
+      def option_name
+        self.class.option_name
+      end
+      
+      def initialize(query, key, value = nil)
+        super(query, key, value)
+        
+        raise Errors::InvalidOptionContext.new(self.query, self) unless applies_to?
+        raise Errors::InvalidOptionValue.new(self.query, self) unless valid?
+      end
+      
+      def self.applies_to?(query)
+        false
+      end
+      
+      def self.parse!(query, key, value = nil)
+        nil
+      end
+      
+      def applies_to?
+        self.class.applies_to?(self.query)
+      end
+      
+      def valid?
+        true
+      end
+    end
+  end
+end