odata_server 0.0.1

data/lib/o_data/abstract_schema.rb

@@ -0,0 +1,9 @@
+require "o_data/abstract_schema/base"
+require "o_data/abstract_schema/schema_object"
+require "o_data/abstract_schema/entity_type"
+require "o_data/abstract_schema/comparable"
+require "o_data/abstract_schema/serializable"
+require "o_data/abstract_schema/property"
+require "o_data/abstract_schema/navigation_property"
+require "o_data/abstract_schema/association"
+require "o_data/abstract_schema/end"

data/lib/o_data/abstract_schema/association.rb

@@ -0,0 +1,29 @@
+module OData
+  module AbstractSchema
+    class Association < SchemaObject
+      cattr_reader :polymorphic_namespace_name
+      @@polymorphic_namespace_name = '$polymorphic'
+      
+      attr_accessor :from_end, :to_end
+    
+      def initialize(schema, name, from_end_options = {}, to_end_options = {})
+        super(schema, name)
+      
+        self.FromEnd(from_end_options.delete(:entity_type), from_end_options.delete(:return_type), from_end_options.delete(:name), from_end_options)
+        self.ToEnd(to_end_options.delete(:entity_type), to_end_options.delete(:return_type), to_end_options.delete(:name), to_end_options)
+      end
+      
+      def FromEnd(*args)
+        @from_end = End.new(self.schema, self, *args)
+      end
+      
+      def ToEnd(*args)
+        @to_end = End.new(self.schema, self, *args)
+      end
+      
+      def inspect
+        "#<< #{qualified_name.to_s}(#{[@from_end, @to_end].flatten.collect { |e| "#{e.name.to_s}: #{e.return_type.to_s}" }.join(", ")}) >>"
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/base.rb

@@ -0,0 +1,48 @@
+module OData
+  module AbstractSchema
+    class Base
+      attr_accessor :namespace
+      attr_accessor :entity_types
+
+      def initialize(namespace = "OData")
+        @namespace = namespace
+
+        @entity_types = []
+      end
+
+      def Association(*args)
+        Association.new(self, *args)
+      end
+
+      def EntityType(*args)
+        entity_type = EntityType.new(self, *args)
+        @entity_types << entity_type
+        entity_type
+      end
+
+      def associations
+        @entity_types.collect(&:navigation_properties).flatten.collect(&:association).uniq
+      end
+      
+      def find_entity_type(options = {})
+        if options[:name]
+          self.entity_types.find { |et| et.name == options[:name].to_s }
+        else
+          nil
+        end
+      end
+
+      def qualify(str)
+        namespace.to_s + '.' + str.to_s
+      end
+
+      def inspect
+        "#<< #{namespace.to_s}(#{@entity_types.collect(&:name).join(', ')}) >>"
+      end
+      
+      def to_json
+        { "d" => { "EntitySets" => @entity_types.collect(&:plural_name).sort } }.to_json
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/comparable.rb

@@ -0,0 +1,42 @@
+module OData
+  module AbstractSchema
+    module Comparable
+      def compare(a, b, property_order_pairs = [])
+        _pairs = [] + property_order_pairs
+        _compare(a, b, _pairs.shift, _pairs)
+      end
+
+      def sort(many, property_order_pairs = [])
+        [many].compact.flatten.sort { |a, b| compare(a, b, property_order_pairs) }
+      end
+      
+      protected
+      
+      def _compare(a, b, head, rest)
+        return 0 if head.blank?
+
+        property, asc_or_desc = head
+        asc_or_desc ||= :asc
+
+        if b.blank?
+          (asc_or_desc == :asc) ? 1 : -1
+        else
+          a_value = property.value_for(a)
+          b_value = property.value_for(b)
+
+          if a_value.blank?
+            (asc_or_desc == :asc) ? -1 : 1
+          elsif b_value.blank?
+            (asc_or_desc == :asc) ? 1 : -1
+          elsif (c = a_value <=> b_value) != 0
+            (asc_or_desc == :asc) ? c : c * -1
+          else
+            _compare(a, b, rest.shift, rest)
+          end
+        end
+      end
+    end # Comparable
+  end # AbstractSchema
+end # OData
+
+OData::AbstractSchema::EntityType.send(:include, OData::AbstractSchema::Comparable)

data/lib/o_data/abstract_schema/end.rb

@@ -0,0 +1,50 @@
+module OData
+  module AbstractSchema
+    class End < SchemaObject
+      cattr_reader :end_option_names
+      @@end_option_names = %w{nullable multiple polymorphic}
+      
+      @@end_option_names.each do |option_name|
+        define_method(:"#{option_name.to_s}?") do
+          !!self.options[option_name.to_sym]
+        end
+      end
+
+      attr_reader :association
+      attr_reader :entity_type, :return_type
+      attr_accessor :options
+
+      def initialize(schema, association, entity_type, return_type, name, options = {})
+        super(schema, name)
+        
+        @association = association
+        @entity_type = entity_type
+        @return_type = return_type
+        
+        unless @entity_type.nil?
+          @return_type ||= @entity_type.qualified_name
+        end
+
+        @options = {}
+        options.keys.select { |key| @@end_option_names.include?(key.to_s) }.each do |key|
+          @options[key.to_sym] = options[key]
+        end
+      end
+      
+      # def return_type
+      #   @options[:multiple] ? 'Collection(' + @return_type.to_s + ')' : @return_type.to_s
+      # end
+
+      def to_multiplicity
+        m = (@options[:nullable] ? '0' : '1') + '..' + (@options[:multiple] ? '*' : '1')
+        m = '1' if m == '1..1'
+        m = '*' if m == '0..*'
+        m
+      end
+      
+      def inspect
+        "#<< #{qualified_name.to_s}(return_type: #{@return_type.to_s}, to_multiplicity: #{to_multiplicity.to_s}) >>"
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/entity_type.rb

@@ -0,0 +1,64 @@
+module OData
+  module AbstractSchema
+    class EntityType < SchemaObject
+      attr_accessor :properties
+
+      attr_accessor :navigation_properties
+
+      def initialize(schema, name)
+        super(schema, name)
+
+        @properties = []
+        @key_property = nil
+
+        @navigation_properties = []
+      end
+      
+      attr_reader :key_property
+
+      def key_property=(property)
+        return nil unless property.is_a?(Property)
+        return nil unless @properties.include?(property)
+        @key_property = property
+      end
+
+      def Property(*args)
+        property = Property.new(self.schema, self, *args)
+        @properties << property
+        property
+      end
+
+      def NavigationProperty(*args)
+        navigation_property = NavigationProperty.new(self.schema, self, *args)
+        @navigation_properties << navigation_property
+        navigation_property
+      end
+
+      def find_all(key_values = {})
+        []
+      end
+      
+      def find_one(key_value)
+        return nil if @key_property.blank?
+        find_all(@key_property => key_value).first
+      end
+      
+      def exists?(key_value)
+        !!find_one(key_value)
+      end
+      
+      def href_for(one)
+        collection_name + '(' + primary_key_for(one) + ')'
+      end
+
+      def primary_key_for(one)
+        return nil if @key_property.blank?
+        @key_property.value_for(one)
+      end
+      
+      def inspect
+        "#<< #{qualified_name.to_s}(#{[@properties, @navigation_properties].flatten.collect { |p| "#{p.name.to_s}: #{p.return_type.to_s}" }.join(', ')}) >>"
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/navigation_property.rb

@@ -0,0 +1,37 @@
+module OData
+  module AbstractSchema
+    class NavigationProperty < SchemaObject
+      attr_reader :entity_type
+      attr_accessor :association, :from_end, :to_end
+      
+      def initialize(schema, entity_type, name, association, options = {})
+        super(schema, name)
+
+        @entity_type = entity_type
+        @association = association
+
+        options.reverse_merge!(:source => true)
+
+        if options[:source]
+          @from_end = @association.from_end
+          @to_end = @association.to_end
+        else
+          @to_end = @association.to_end
+          @from_end = @association.from_end
+        end
+      end
+      
+      def return_type
+        @to_end.return_type
+      end
+      
+      def find_all(one, key_values = {})
+        nil
+      end
+      
+      def find_one(one, key_value = nil)
+        nil
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/property.rb

@@ -0,0 +1,35 @@
+module OData
+  module AbstractSchema
+    class Property < SchemaObject
+      cattr_reader :edm_null
+      @@edm_null = 'Edm.Null'.freeze
+      
+      attr_reader :entity_type
+      attr_accessor :return_type, :nullable
+
+      def initialize(schema, entity_type, name, return_type = @@edm_null, nullable = true)
+        super(schema, name)
+
+        @entity_type = entity_type
+        @return_type = return_type
+        @nullable = nullable
+      end
+
+      def nullable?
+        !!@nullable
+      end
+
+      def value_for(one)
+        nil
+      end
+      
+      def qualified_name
+        @entity_type.qualified_name.to_s + '#' + self.name
+      end
+      
+      def inspect
+        "#<< {qualified_name.to_s}(return_type: #{@return_type.to_s}, nullable: #{nullable?}) >>"
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/schema_object.rb

@@ -0,0 +1,37 @@
+module OData
+  module AbstractSchema
+    class SchemaObject
+      attr_reader :schema
+      attr_accessor :name
+
+      def initialize(schema, name)
+        @schema = schema
+        @name = name
+      end
+
+      def qualified_name
+        @schema.qualify(@name)
+      end
+
+      include Comparable
+
+      def <=>(other)
+        return qualified_name <=> other.qualified_name if other.is_a?(OData::SchemaObject)
+        return -1 if other.blank?
+        1
+      end
+
+      def singular_name
+        name.to_s.singularize
+      end
+
+      def plural_name
+        name.to_s.pluralize
+      end
+
+      def inspect
+        "#<< #{@schema.namespace}(<< #{@name.inspect}: #{self.class.name.to_s} >>) >>"
+      end
+    end
+  end
+end

data/lib/o_data/abstract_schema/serializable.rb

@@ -0,0 +1,79 @@
+module OData
+  module AbstractSchema
+    module Serializable
+      def self.atom_element_names
+        %w{title summary updated_at}
+      end
+      
+      module SchemaInstanceMethods
+        def atom_title_for(one)
+          entity_type = find_entity_type(:active_record => one.class)
+          return nil if entity_type.blank?
+          
+          entity_type.atom_title_for(one)
+        end
+        
+        def atom_summary_for(one)
+          entity_type = find_entity_type(:active_record => one.class)
+          return nil if entity_type.blank?
+          
+          entity_type.atom_summary_for(one)
+        end
+        
+        def atom_updated_at_for(one)
+          entity_type = find_entity_type(:active_record => one.class)
+          return nil if entity_type.blank?
+          
+          entity_type.atom_updated_at_for(one)
+        end
+      end
+      
+      module EntityTypeInstanceMethods
+        def self.included(base)
+          base.instance_eval do
+            attr_reader *OData::AbstractSchema::Serializable.atom_element_names.collect { |atom_element_name| :"atom_#{atom_element_name}_property" }
+          end
+        end
+        
+        def atom_title_for(one)
+          return href_for(one) if self.atom_title_property.blank?
+          self.atom_title_property.value_for(one)
+        end
+        
+        def atom_summary_for(one)
+          return nil if self.atom_summary_property.blank?
+          self.atom_summary_property.value_for(one)
+        end
+        
+        def atom_updated_at_for(one)
+          return nil if self.atom_updated_at_property.blank?
+          self.atom_updated_at_property.value_for(one)
+        end
+        
+        def atom_title_property=(property)
+          return nil unless property.is_a?(Property)
+          return nil unless property.return_type.to_s == 'Edm.String'
+          return nil unless self.properties.find { |p| p.name == property.name }
+          @atom_title_property = property
+        end
+        
+        def atom_summary_property=(property)
+          return nil unless property.is_a?(Property)
+          return nil unless property.return_type.to_s == 'Edm.String'
+          return nil unless self.properties.find { |p| p.name == property.name }
+          @atom_summary_property = property
+        end
+        
+        def atom_updated_at_property=(property)
+          return nil unless property.is_a?(Property)
+          return nil unless %w{Edm.Date Edm.DateTime Edm.Time}.include?(property.return_type.to_s)
+          return nil unless self.properties.find { |p| p.name == property.name }
+          @atom_updated_at_property = property
+        end
+      end
+    end
+  end
+end
+
+OData::AbstractSchema::Base.send(:include, OData::AbstractSchema::Serializable::SchemaInstanceMethods)
+OData::AbstractSchema::EntityType.send(:include, OData::AbstractSchema::Serializable::EntityTypeInstanceMethods)

data/lib/o_data/active_record_schema.rb

@@ -0,0 +1,8 @@
+require "active_record"
+
+require "o_data/active_record_schema/entity_type"
+require "o_data/active_record_schema/serializable"
+require "o_data/active_record_schema/property"
+require "o_data/active_record_schema/navigation_property"
+require "o_data/active_record_schema/association"
+require "o_data/active_record_schema/base"