odata_server 0.0.1

data/lib/o_data/active_record_schema/association.rb

@@ -0,0 +1,130 @@
+module OData
+  module ActiveRecordSchema
+    class Association < OData::AbstractSchema::Association
+      def self.name_for(reflection)
+        EntityType.name_for(reflection.active_record) + '#' + reflection.name.to_s
+      end
+      
+      def self.nullable?(active_record, association_columns)
+        association_columns.all? { |column_name|
+          column = active_record.columns.find { |c| c.name == column_name }
+          column.blank? ? true : column.null
+        }
+      end
+      
+      def self.active_record_for_from_end(reflection)
+        reflection.active_record
+      end
+      
+      def self.active_record_for_to_end(reflection)
+        return nil if reflection.options[:polymorphic]
+        begin
+            reflection.class_name.constantize
+        rescue => ex
+          raise "Failed to handle class <#{reflection.active_record}> #{reflection.macro} #{reflection.name}"
+        end
+      end
+
+      # def self.foreign_keys_for(reflection)
+      #   [reflection.options[:foreign_key] || reflection.association_foreign_key, reflection.options[:foreign_type]].compact
+      # end
+      
+      def self.polymorphic_column_name(reflection, column_name)
+        # self.polymorphic_namespace_name.to_s + '.' + (reflection.options[:as] ? reflection.options[:as].to_s.classify : reflection.class_name.to_s) + '#' + column_name.to_s
+        self.polymorphic_namespace_name.to_s + '#' + column_name.to_s
+      end
+      
+      def self.column_names_for_from_end(reflection)
+        out = []
+        
+        case reflection.macro
+        when :belongs_to
+          out << reflection.primary_key_name
+          out << reflection.options[:foreign_type] if reflection.options[:polymorphic]
+        else
+          out << EntityType.primary_key_for(reflection.active_record)
+          out << polymorphic_column_name(reflection, 'ReturnType') if reflection.options[:as]
+        end
+        
+        out
+      end
+      
+      def self.column_names_for_to_end(reflection)
+        out = []
+        
+        case reflection.macro
+        when :belongs_to
+          if reflection.options[:polymorphic]
+            out << polymorphic_column_name(reflection, 'Key')
+            out << polymorphic_column_name(reflection, 'ReturnType')
+          else
+            out << EntityType.primary_key_for(reflection.class_name.constantize)
+          end
+        else
+          out << reflection.primary_key_name
+          
+          if reflection.options[:as]
+            out << reflection.options[:as].to_s + '_type'
+          end
+        end
+        
+        out
+      end
+      
+      def self.from_end_options_for(schema, reflection)
+        active_record = active_record_for_from_end(reflection)
+        
+        entity_type = schema.find_entity_type(:active_record => active_record)
+        raise OData::AbstractQuery::Errors::EntityTypeNotFound.new(nil, active_record.class_name) if entity_type.blank?
+        
+        polymorphic = false
+        
+        # TODO: detect 'nullable' for FromEnd of Association
+        nullable = false
+        
+        multiple = reflection.macro == :has_and_belongs_to_many
+        
+        name = entity_type.name
+        name = name.pluralize if multiple
+        
+        { :name => name, :entity_type => entity_type, :return_type => entity_type.qualified_name, :multiple => multiple, :nullable => nullable, :polymorphic => polymorphic }
+      end
+      
+      def self.to_end_options_for(schema, reflection)
+        Rails.logger.info("Processing #{reflection.active_record}")
+        active_record = active_record_for_to_end(reflection)
+        entity_type = schema.find_entity_type(:active_record => active_record)
+        
+        polymorphic = reflection.options[:polymorphic] # || reflection.options[:as]
+
+        multiple = [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+        
+        nullable = begin
+          case reflection.macro
+          when :belongs_to
+            nullable?(active_record_for_from_end(reflection), column_names_for_from_end(reflection))
+          else
+            true
+          end
+        end
+        
+        name = EntityType.name_for(reflection.class_name)
+        name = name.pluralize if multiple
+        
+        unless active_record.blank? || entity_type.blank?
+          { :name => name, :entity_type => entity_type, :return_type => entity_type.qualified_name, :multiple => multiple, :nullable => nullable, :polymorphic => polymorphic }
+        else
+          { :name => name, :return_type => self.polymorphic_namespace_name, :multiple => multiple, :nullable => nullable, :polymorphic => polymorphic }
+        end
+      end
+      
+      attr_reader :reflection
+      
+      def initialize(schema, reflection)
+        super(schema, self.class.name_for(reflection), self.class.from_end_options_for(schema, reflection), self.class.to_end_options_for(schema, reflection))
+        
+        @reflection = reflection
+      end
+    end
+  end
+end

data/lib/o_data/active_record_schema/base.rb

@@ -0,0 +1,37 @@
+module OData
+  module ActiveRecordSchema
+    class Base < OData::AbstractSchema::Base
+      def find_entity_type(options = {})
+        if options[:active_record]
+          self.entity_types.find { |et| et.name == EntityType.name_for(options[:active_record]) }
+        else
+          super(options)
+        end
+      end
+      
+      def initialize(*args)
+        super(*args)
+        
+        Dir.glob(RAILS_ROOT + '/app/models/*.rb').each { |file| require file }
+        
+        Object.subclasses_of(ActiveRecord::Base).collect { |active_record|
+          self.EntityType(active_record, :reflect_on_associations => false)
+        }.collect { |entity_type| 
+          entity_type.active_record.reflect_on_all_associations.each do |reflection|
+            entity_type.NavigationProperty(reflection)
+          end
+        }
+      end
+      
+      def Association(*args)
+        Association.new(self, *args)
+      end
+
+      def EntityType(*args)
+        entity_type = EntityType.new(self, *args)
+        self.entity_types << entity_type
+        entity_type
+      end
+    end
+  end
+end

data/lib/o_data/active_record_schema/entity_type.rb

@@ -0,0 +1,128 @@
+module OData
+  module ActiveRecordSchema
+    class EntityType < OData::AbstractSchema::EntityType      
+      def self.name_for(active_record_or_str)
+        name = active_record_or_str.is_a?(ActiveRecord::Base) ? active_record_or_str.name : active_record_or_str.to_s
+        name.gsub('::', '')
+      end
+      
+      def self.primary_key_for(active_record)
+        active_record.primary_key
+      end
+      
+      attr_reader :active_record
+      
+      def initialize(schema, active_record, options = {})
+        super(schema, self.class.name_for(active_record))
+        
+        options.reverse_merge!(:reflect_on_associations => true)
+        
+        @active_record = active_record
+
+        key_property_name = self.class.primary_key_for(@active_record).to_s
+        
+        @active_record.columns.each do |column_adapter|
+          property = self.Property(column_adapter)
+          
+          if key_property_name == property.name
+            self.key_property = property
+          end
+        end
+        
+        OData::AbstractSchema::Serializable.atom_element_names.each do |atom_element_name|
+          o_data_active_record_method_name = :"o_data_atom_#{atom_element_name}"
+          o_data_entity_type_property_name = :"atom_#{atom_element_name}_property"
+          
+          if @active_record.respond_to?(o_data_active_record_method_name)
+            result = @active_record.send(o_data_active_record_method_name)
+            next unless result.is_a?(Symbol)
+            
+            property = self.properties.find { |p| p.name == result.to_s }
+            next if property.blank?
+              
+            self.send(:"#{o_data_entity_type_property_name}=", property)
+          elsif !@active_record.instance_methods.include?(o_data_active_record_method_name.to_s) && @active_record.column_names.include?(atom_element_name.to_s)
+            property = self.properties.find { |p| p.name == atom_element_name.to_s }
+            next if property.blank?
+
+            self.send(:"#{o_data_entity_type_property_name}=", property)
+          end
+        end
+        
+        if options[:reflect_on_associations]        
+          @active_record.reflect_on_all_associations.each do |reflection|
+            self.NavigationProperty(reflection)
+          end
+        end
+      end
+
+      def Property(*args)
+        property = Property.new(self.schema, self, *args)
+        self.properties << property
+        property
+      end
+
+      def NavigationProperty(*args)
+        navigation_property = NavigationProperty.new(self.schema, self, *args)
+        self.navigation_properties << navigation_property
+        navigation_property
+      end
+
+      def find_all(key_values = {})
+        if @active_record.respond_to?(:with_permissions_to)
+          @active_record.with_permissions_to(:read).find(:all, :conditions => conditions_for_find(key_values))
+        else
+          @active_record.find(:all, :conditions => conditions_for_find(key_values))
+        end
+      end
+      
+      def find_one(key_value)
+        return nil if self.key_property.blank?
+        if @active_record.respond_to?(:with_permissions_to)
+          @active_record.with_permissions_to(:read).find(key_value)
+        else
+          @active_record.find(key_value)
+        end
+      end
+      
+      def conditions_for_find(key_values = {})
+        self.class.conditions_for_find(self, key_values)
+      end
+      
+      def self.conditions_for_find(entity_type, key_values = {})
+        return "1=0" unless entity_type.is_a?(OData::ActiveRecordSchema::EntityType)
+        return "1=1" if key_values.blank?
+        
+        key_values.collect { |pair|
+          property_or_str, value = pair
+          
+          property = begin
+            if property_or_str.is_a?(Property)
+              property_or_str
+            else
+              property = entity_type.properties.find { |p| p.name == property_or_str.to_s }
+              raise OData::AbstractQuery::Errors::PropertyNotFound.new(nil, property_or_str) if property.blank?
+            end
+          end
+          
+          [property, value]
+        }.reject { |pair|
+          pair.first.blank?
+        }.inject({}) { |acc, pair|
+          property, value = pair
+          
+          acc[property.column_adapter.name.to_sym] = value
+          acc
+        }
+      end
+      
+      def self.href_for(one)
+        one.class.name.pluralize + '(' + one.send(one.class.send(:primary_key)).to_s + ')'
+      end
+      
+      def href_for(one)
+        self.class.href_for(one)
+      end
+    end
+  end
+end

data/lib/o_data/active_record_schema/navigation_property.rb

@@ -0,0 +1,45 @@
+module OData
+  module ActiveRecordSchema
+    class NavigationProperty < OData::AbstractSchema::NavigationProperty
+      def self.name_for(reflection)
+        reflection.name.to_s
+      end
+      
+      def self.association_for(schema, reflection)
+        schema.Association(reflection)
+      end
+
+      def initialize(schema, entity_type, reflection)
+        super(schema, entity_type, self.class.name_for(reflection), self.class.association_for(schema, reflection), :source => true)
+      end
+
+      def method_name
+        self.association.reflection.name.to_sym
+      end
+      
+      def find_all(one, key_values = {})
+        results = one.send(method_name)
+        unless key_values.blank?
+          if results.respond_to?(:find)
+            results = results.find(:all, :conditions => self.entity_type.conditions_for_find(key_values)) 
+          else
+            # TODO: raise exception if key_values supplied for non-finder method
+          end
+        end
+        results
+      end
+      
+      def find_one(one, key_value = nil)
+        results = one.send(method_name)
+        unless key_value.blank?
+          if results.respond_to?(:find)
+            results = results.find(key_value)
+          else
+            # TODO: raise exception if key_value supplied for non-finder method
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/o_data/active_record_schema/property.rb

@@ -0,0 +1,45 @@
+module OData
+  module ActiveRecordSchema
+    class Property < OData::AbstractSchema::Property
+      cattr_reader :column_adapter_return_types
+      @@column_adapter_return_types = {
+        :binary    => 'Edm.Binary',
+        :boolean   => 'Edm.Boolean',
+        :byte      => 'Edm.Byte',
+        :date      => 'Edm.Date',
+        :datetime  => 'Edm.DateTime',
+        :float     => 'Edm.Decimal',
+        :integer   => 'Edm.Int32',
+        :string    => 'Edm.String',
+        :text      => 'Edm.String',
+        :timestamp => 'Edm.DateTime',
+        :time      => 'Edm.Time'
+      }.freeze
+      
+      def self.return_type_for(column_adapter)
+        @@column_adapter_return_types[column_adapter.type]
+      end
+      
+      def self.name_for(column_adapter)
+        column_adapter.name.to_s
+      end
+      
+      def self.nullable?(column_adapter)
+        column_adapter.null
+      end
+      
+      attr_reader :column_adapter
+      
+      def initialize(schema, entity_type, column_adapter)
+        super(schema, entity_type, self.class.name_for(column_adapter), self.class.return_type_for(column_adapter), self.class.nullable?(column_adapter))
+        
+        @column_adapter = column_adapter
+      end
+      
+      def value_for(one)
+        v = one.send(@column_adapter.name.to_sym)
+        v.respond_to?(:iso8601) ? v.send(:iso8601) : v
+      end
+    end
+  end
+end

data/lib/o_data/active_record_schema/serializable.rb

@@ -0,0 +1,36 @@
+module OData
+	module ActiveRecordSchema
+	  module Serializable
+      # def self.atom_method_names
+      #   OData::AbstractSchema::Serializable.atom_element_names.collect { |atom_element_name| "o_data_atom_#{atom_element_name}_column" }
+      # end
+	  end
+	end
+end
+
+OData::AbstractSchema::Serializable.atom_element_names.each do |atom_element_name|
+  o_data_active_record_method_name = :"o_data_atom_#{atom_element_name}"
+  o_data_entity_type_method_name = :"atom_#{atom_element_name}_for"
+  
+  OData::ActiveRecordSchema::EntityType.instance_eval do
+    define_method(o_data_entity_type_method_name) do |one|
+      if one.class.respond_to?(o_data_active_record_method_name)
+        result = one.class.send(o_data_active_record_method_name)
+        
+        if result.is_a?(Symbol)
+          one.send(result)
+        elsif result.is_a?(Proc)
+          result.call(one)
+        else
+          result
+        end
+      elsif one.respond_to?(o_data_active_record_method_name)
+        one.send(o_data_active_record_method_name)
+      elsif one.respond_to?(atom_element_name)
+        one.send(atom_element_name)
+      else
+        super(one)
+      end
+    end
+  end
+end

data/lib/odata_server.rb

@@ -0,0 +1,12 @@
+module OData
+  class ODataException < StandardError
+    def to_s
+      "An unknown #{self.class.name.demodulize.to_s} has occured."
+    end
+  end
+end
+
+require "o_data/abstract_schema"
+require "o_data/abstract_query"
+
+require "o_data/active_record_schema"

data/public/clientaccesspolicy.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<access-policy>
+  <cross-domain-access>
+    <policy>
+      <allow-from http-request-headers="*">
+        <domain uri="*"/>
+      </allow-from>
+      <grant-to>
+        <resource path="/" include-subpaths="true"/>
+      </grant-to>
+    </policy>
+  </cross-domain-access>
+</access-policy>