odata_server 0.0.1

data/lib/o_data/abstract_query/segment.rb

@@ -0,0 +1,43 @@
+module OData
+  module AbstractQuery
+    class Segment
+      attr_reader :query, :value
+      
+      def self.parse!(query, str)
+        nil
+      end
+      
+      def self.segment_name
+        name.to_s.demodulize.sub(/Segment$/, '')
+      end
+      
+      def initialize(query, value)
+        @query = query
+        @value = value
+        
+        raise Errors::InvalidSegmentContext.new(@query, self) unless can_follow?(@query.segments.last)
+      end
+      
+      def self.can_follow?(anOtherSegment)
+        # self (Segment class) can_follow? anOtherSegment (instance of Segment class)
+        false
+      end
+      
+      def can_follow?(anOtherSegment)
+        self.class.can_follow?(anOtherSegment)
+      end
+      
+      def execute!(acc)
+        acc
+      end
+      
+      def inspect
+        "#<< #{@query.schema.namespace.to_s}(#{self.class.segment_name}: #{self.value.inspect}) >>"
+      end
+      
+      def valid?(results)
+        !results.blank?
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/segments/collection_segment.rb

@@ -0,0 +1,24 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class CollectionSegment < EntityTypeAndKeyValuesSegment
+        def self.parse!(query, str)
+          return nil unless query.segments.empty?
+          schema_object_name, key_values, keys = extract_schema_object_name_and_key_values_and_keys(str)
+          return nil if schema_object_name.blank?
+
+          entity_type = query.schema.find_entity_type(:name => schema_object_name.singularize)
+          return nil if entity_type.blank?
+
+          sanitized_key_values = sanitize_key_values_and_keys_for!(query, entity_type, key_values, keys)
+
+          query.Segment(self, entity_type, sanitized_key_values)
+        end
+        
+        def self.can_follow?(anOtherSegment)
+          anOtherSegment.blank?
+        end
+      end # CollectionSegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/count_segment.rb

@@ -0,0 +1,38 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class CountSegment < OData::AbstractQuery::Segment
+        def self.parse!(query, str)
+          return nil unless str.to_s == segment_name
+
+          query.Segment(self)
+        end
+
+        def self.segment_name
+          "$count"
+        end
+
+        def initialize(query)
+          super(query, self.class.segment_name)
+        end
+
+        def self.can_follow?(anOtherSegment)
+          if anOtherSegment.is_a?(Class)
+            anOtherSegment == CollectionSegment || anOtherSegment == NavigationPropertySegment
+          else
+            (anOtherSegment.is_a?(CollectionSegment) || anOtherSegment.is_a?(NavigationPropertySegment)) && anOtherSegment.countable?
+          end
+        end
+
+        def execute!(acc)
+          return acc.length if acc.respond_to?(:length)
+          1
+        end
+
+        def valid?(results)
+          results.is_a?(Fixnum)
+        end
+      end # CountSegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/entity_type_and_key_values_segment.rb

@@ -0,0 +1,116 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class EntityTypeAndKeyValuesSegment < EntityTypeSegment
+        def self.remove_quotes(str)
+          str.to_s.sub(/^\'(.*?)\'$/, '\1')
+        end
+
+        def self.extract_schema_object_name_and_key_values_and_keys(str)
+          if md1 = str.to_s.match(/^([^\(]+)(?:\(([^\)]+)\)|\(\s*\))?$/)
+            schema_object_name = md1[1]
+            key_values = {}
+            keys = []
+
+            if key_values_string = md1[2]
+              key_values_string.split(/\s*,\s*/).each do |key_value_pair|
+                key, value = key_value_pair.split('=', 2)
+
+                if value
+                  key_values[key.to_sym] = remove_quotes(value)
+                else
+                  keys << remove_quotes(key)
+                end
+              end
+            end
+
+            [schema_object_name, key_values, keys]
+          else
+            nil
+          end
+        end
+
+        def self.sanitize_key_values_and_keys_for!(query, entity_type, key_values = {}, keys = [])
+          key_property_name = entity_type.key_property.name
+
+          sanitized_key_values = key_values.inject({}) { |acc, key_value_pair|
+            key, value = key_value_pair
+
+            property = entity_type.properties.find { |p| p.name == key.to_s }
+            raise OData::AbstractQuery::Errors::PropertyNotFound.new(query, key) if property.blank?
+            
+            raise OData::AbstractQuery::Errors::AbstractQueryKeyValueException.new(query, key, value) unless acc[key.to_sym].blank?
+
+            acc[property.name.to_sym] = value
+            acc
+          }
+
+          keys.inject(sanitized_key_values) { |acc, key_value| 
+            raise OData::AbstractQuery::Errors::AbstractQueryKeyValueException.new(query, key_property_name, key_value) unless acc[key_property_name.to_sym].blank?
+            
+            acc[key_property_name.to_sym] = key_value
+            acc
+          }
+        end
+
+        attr_reader :key_values
+
+        def initialize(query, entity_type, key_values = {})
+          @key_values = key_values
+
+          super(query, entity_type)
+        end
+
+        def countable?
+          !key?
+        end
+
+        def execute!(acc)
+          return [] if self.entity_type.blank?
+
+          if key?
+            self.entity_type.find_one(key_property_value)
+          else
+            self.entity_type.find_all(@key_values)
+          end
+        end
+
+        def key?
+          !self.entity_type.blank? && self.class.key?(self.entity_type, @key_values)
+        end
+
+        def key_property_value
+          return nil if self.entity_type.blank?
+
+          self.class.key_property_value_for(self.entity_type, @key_values)
+        end
+
+        def value
+          if @key_values.blank?
+            super
+          elsif key?
+            super + '(' + key_property_value.to_s + ')'
+          else
+            super + '(' + @key_values.collect { |key, value| "#{key}=#{value}" }.join(',') + ')'
+          end
+        end
+
+        def self.key?(entity_type, key_values = {})
+          !!key_property_value_for(entity_type, key_values)
+        end
+
+        def self.key_property_value_for(entity_type, key_values = {})
+          return nil if entity_type.blank?
+
+          return nil if key_values.blank?
+          return nil unless key_values.size == 1
+
+          key_property = entity_type.key_property
+          return nil if key_property.blank?
+
+          key_values[key_property.name.to_sym]
+        end
+      end # EntityTypeAndKeyValuesSegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/entity_type_segment.rb

@@ -0,0 +1,31 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class EntityTypeSegment < OData::AbstractQuery::Segment
+        include OData::AbstractQuery::Countable
+
+        attr_reader :entity_type
+
+        def initialize(query, entity_type, value = nil)
+          @entity_type = entity_type
+
+          super(query, value || (@entity_type.is_a?(OData::AbstractSchema::EntityType) ? @entity_type.plural_name : @entity_type))
+        end
+
+        def self.can_follow?(anOtherSegment)
+          false
+        end
+
+        def execute!(acc)
+          return [] if @entity_type.blank?
+
+          @entity_type.find_all
+        end
+
+        def valid?(results)
+          countable? ? results.is_a?(Array) : !results.blank?
+        end
+      end # EntityTypeSegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/links_segment.rb

@@ -0,0 +1,49 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class LinksSegment < OData::AbstractQuery::Segment
+        include OData::AbstractQuery::Countable
+
+        def self.parse!(query, str)
+          return nil unless str.to_s == segment_name
+
+          query.Segment(self)
+        end
+
+        def self.segment_name
+          "$links"
+        end
+        
+        def self.countable?
+          true
+        end
+
+        def initialize(query)
+          super(query, self.class.segment_name)
+        end
+
+        def self.can_follow?(anOtherSegment)
+          if anOtherSegment.is_a?(Class)
+            anOtherSegment == CollectionSegment || anOtherSegment == NavigationPropertySegment
+          else
+            (anOtherSegment.is_a?(CollectionSegment) || anOtherSegment.is_a?(NavigationPropertySegment)) # && anOtherSegment.countable?
+          end
+        end
+
+        def execute!(acc)
+          [acc].flatten.compact.collect { |one|
+            if entity_type = self.query.schema.entity_types.find { |et| et.name == one.class.name }
+              [one, entity_type.plural_name + '(' + entity_type.primary_key_for(one).to_s + ')']
+            else
+              [one, nil]
+            end
+          }
+        end
+
+        def valid?(results)
+          results.all? { |pair| !pair[1].blank? }
+        end
+      end # LinksSegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/navigation_property_segment.rb

@@ -0,0 +1,82 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class NavigationPropertySegment < EntityTypeAndKeyValuesSegment
+        def self.parse!(query, str)
+          return nil if query.segments.empty?
+          return nil unless query.segments.last.respond_to?(:entity_type)
+          entity_type = query.segments.last.entity_type
+          return nil if entity_type.blank?
+
+          schema_object_name, key_values, keys = extract_schema_object_name_and_key_values_and_keys(str)
+          return nil if schema_object_name.blank?
+
+          navigation_property = entity_type.navigation_properties.find { |np| np.name == schema_object_name }
+          return nil if navigation_property.blank?
+
+          if navigation_property.to_end.polymorphic?
+            raise OData::AbstractQuery::Errors::AbstractQueryKeyValueException.new(query, key_values.keys.first, key_values.values.first) unless key_values.empty?
+            raise OData::AbstractQuery::Errors::AbstractQueryKeyValueException.new(query, '$polymorphic#Key', keys.first) unless keys.empty?
+
+            query.Segment(self, entity_type, navigation_property.to_end.return_type, navigation_property, {})
+          else
+            sanitized_key_values = sanitize_key_values_and_keys_for!(query, navigation_property.to_end.entity_type, key_values, keys)
+            
+            unless sanitized_key_values.empty?
+              raise OData::AbstractQuery::Errors::AbstractQueryKeyValueException.new(query, sanitized_key_values.keys.first, sanitized_key_values.values.first) unless navigation_property.to_end.multiple?
+            end
+
+            query.Segment(self, entity_type, navigation_property.to_end.entity_type, navigation_property, sanitized_key_values)
+          end
+        end
+
+        alias_method :to_entity_type, :entity_type
+
+        attr_reader :navigation_property
+
+        def initialize(query, from_entity_type, to_entity_type, navigation_property, key_values = {})
+          @from_entity_type = from_entity_type
+          @navigation_property = navigation_property
+
+          super(query, to_entity_type, key_values)
+        end
+
+        def self.can_follow?(anOtherSegment)
+          if anOtherSegment.is_a?(Class)
+            anOtherSegment == CollectionSegment || anOtherSegment == NavigationPropertySegment
+          else
+            (anOtherSegment.is_a?(CollectionSegment) || anOtherSegment.is_a?(NavigationPropertySegment)) && !anOtherSegment.countable?
+          end
+        end      
+
+        def countable?
+          multiple? && super
+        end
+
+        def execute!(acc)
+          [acc].flatten.compact.collect { |one|
+            if key?
+              @navigation_property.find_one(one, key_property_value)
+            else
+              @navigation_property.find_all(one, @key_values)
+            end
+          }.first
+        end
+
+        def multiple?
+          @navigation_property.to_end.multiple?
+        end
+
+        def value
+          if self.key_values.blank? || !multiple?
+            @navigation_property.name
+          elsif key?
+            @navigation_property.name + '(' + key_property_value.to_s + ')'
+          else
+            @navigation_property.name + '(' + self.key_values.collect { |key, value| "#{key}=#{value}" }.join(',') + ')'
+          end
+        end
+      end # NavigationPropertySegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/property_segment.rb

@@ -0,0 +1,50 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class PropertySegment < EntityTypeSegment
+        attr_reader :property
+
+        def self.parse!(query, str)
+          return nil if query.segments.empty?
+          return nil unless query.segments.last.respond_to?(:entity_type)
+          entity_type = query.segments.last.entity_type
+          return nil if entity_type.nil?
+          property = entity_type.properties.find { |p| p.name == str }
+          return nil if property.blank?
+
+          query.Segment(self, entity_type, property)
+        end
+
+        def initialize(query, entity_type, property)
+          @property = property
+
+          super(query, entity_type, @property.name)
+        end
+
+        def self.can_follow?(anOtherSegment)
+          if anOtherSegment.is_a?(Class)
+            anOtherSegment == CollectionSegment || anOtherSegment == NavigationPropertySegment
+          else
+            (anOtherSegment.is_a?(CollectionSegment) || anOtherSegment.is_a?(NavigationPropertySegment)) && !anOtherSegment.countable?
+          end
+        end
+
+        def countable?
+          false
+        end
+
+        def execute!(acc)
+          # [acc].flatten.compact.collect { |one|
+          #   [one, @property.value_for(one)]
+          # }
+          { @property => @property.value_for([acc].flatten.compact.first) }
+        end
+
+        def valid?(results)
+          # results.is_a?(Array)
+          !results.blank?
+        end
+      end # PropertySegment
+    end # Segments
+  end # AbstractQuery
+end # OData

data/lib/o_data/abstract_query/segments/value_segment.rb

@@ -0,0 +1,40 @@
+module OData
+  module AbstractQuery
+    module Segments
+      class ValueSegment < OData::AbstractQuery::Segment
+        def self.parse!(query, str)
+          return nil unless str.to_s == segment_name
+
+          query.Segment(self)
+        end
+
+        def self.segment_name
+          "$value"
+        end
+
+        def initialize(query)
+          super(query, self.class.segment_name)
+        end
+
+        def self.can_follow?(anOtherSegment)
+          if anOtherSegment.is_a?(Class)
+            anOtherSegment == PropertySegment
+          else
+            anOtherSegment.is_a?(PropertySegment)
+          end
+        end
+
+        def execute!(acc)
+          # acc
+          acc.values.first
+        end
+
+        def valid?(results)
+          # # results.is_a?(Array)
+          # !results.blank?
+          true
+        end
+      end # ValueSegment
+    end # Segments
+  end # AbstractQuery
+end # OData