odata_server 0.0.1

data/lib/o_data/abstract_query/options/enumerated_option.rb

@@ -0,0 +1,39 @@
+module OData
+  module AbstractQuery
+    module Options
+      class EnumeratedOption < OData::AbstractQuery::Option
+        def self.valid_values
+          %w{}
+        end
+
+        def valid_values
+          self.class.valid_values
+        end
+
+        def initialize(query, key, value = nil)
+          super(query, key, value)
+        end
+        
+        # def self.applies_to?(query)
+        #   false
+        # end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          return nil if valid_values.empty?
+          
+          if value.blank?
+            query.Option(self, key, valid_values.first)
+          else
+            query.Option(self, key, value)
+          end
+        end
+
+        def valid?
+          return false if self.value.blank? || self.valid_values.empty?
+          self.valid_values.collect(&:to_s).include?(self.value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/expand_option.rb

@@ -0,0 +1,81 @@
+module OData
+  module AbstractQuery
+    module Options
+      class ExpandOption < OData::AbstractQuery::Option
+        def self.option_name
+          '$expand'
+        end
+
+        attr_reader :navigation_property_paths, :navigation_property_paths_str
+
+        # TODO: remove navigation_property_paths_str
+        def initialize(query, navigation_property_paths = {}, navigation_property_paths_str = nil)
+          @navigation_property_paths = navigation_property_paths
+          @navigation_property_paths_str = navigation_property_paths_str
+          
+          super(query, self.class.option_name)
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          (query.segments.last.is_a?(OData::AbstractQuery::Segments::CollectionSegment) || query.segments.last.is_a?(OData::AbstractQuery::Segments::NavigationPropertySegment))
+        end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          
+          if query.segments.last.respond_to?(:navigation_property)
+            navigation_property = query.segments.last.navigation_property
+            
+            raise OData::AbstractQuery::Errors::InvalidOptionValue.new(query, self.option_name) if navigation_property.to_end.polymorphic?
+          end
+          
+          if query.segments.last.respond_to?(:entity_type)
+            entity_type = query.segments.last.entity_type
+            
+            navigation_property_paths = value.to_s.split(/\s*,\s*/).inject({}) { |acc, path| 
+              segments = path.split('/')
+              reflect_on_navigation_property_path(query, acc, entity_type, segments.shift, segments)
+              acc
+            }
+            
+            query.Option(self, navigation_property_paths, value.to_s)
+          else
+            raise OData::AbstractQuery::Errors::InvalidOptionContext.new(query, self.option_name) unless value.blank?
+          end
+        end
+
+        def valid?
+          # TODO: replace with validation
+          true
+        end
+        
+        def value
+          "'" + @navigation_property_paths_str.gsub(/\s+/, '') + "'"
+        end
+        
+        protected
+        
+        def self.reflect_on_navigation_property_path(query, acc, entity_type, head, rest)
+          if head.blank?
+            acc
+          elsif entity_type.blank?
+            raise OData::AbstractQuery::Errors::NavigationPropertyNotFound.new(nil, head)
+          elsif navigation_property = entity_type.navigation_properties.find { |np| np.name == head }    
+            acc[navigation_property] ||= {}
+            
+            if navigation_property.to_end.polymorphic?
+              raise OData::AbstractQuery::Errors::InvalidOptionValue.new(query, head) unless rest.empty?
+            else
+              reflect_on_navigation_property_path(query, acc[navigation_property], navigation_property.to_end.entity_type, rest.shift, rest)
+            end
+            
+            acc
+          else
+            raise OData::AbstractQuery::Errors::NavigationPropertyNotFound.new(nil, head)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/format_option.rb

@@ -0,0 +1,19 @@
+module OData
+  module AbstractQuery
+    module Options
+      class FormatOption < EnumeratedOption
+        def self.option_name
+          '$format'
+        end
+        
+        def self.valid_values
+          %w{atom json}
+        end
+        
+        def self.applies_to?(query)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/inlinecount_option.rb

@@ -0,0 +1,20 @@
+module OData
+  module AbstractQuery
+    module Options
+      class InlinecountOption < EnumeratedOption
+        def self.option_name
+          '$inlinecount'
+        end
+        
+        def self.valid_values
+          %w{none allpages}
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          query.segments.last.is_a?(OData::AbstractQuery::Segments::CollectionSegment) || query.segments.last.is_a?(OData::AbstractQuery::Segments::NavigationPropertySegment)
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/orderby_option.rb

@@ -0,0 +1,79 @@
+module OData
+  module AbstractQuery
+    module Options
+      class OrderbyOption < OData::AbstractQuery::Option
+        def self.option_name
+          '$orderby'
+        end
+
+        attr_reader :pairs
+
+        def initialize(query, pairs = [])
+          @pairs = pairs
+          
+          super(query, self.class.option_name)
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          (query.segments.last.is_a?(OData::AbstractQuery::Segments::CollectionSegment) || query.segments.last.is_a?(OData::AbstractQuery::Segments::NavigationPropertySegment))
+        end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          
+          if query.segments.last.respond_to?(:navigation_property)
+            navigation_property = query.segments.last.navigation_property
+            
+            raise OData::AbstractQuery::Errors::InvalidOptionValue.new(query, self.option_name) if navigation_property.to_end.polymorphic?
+          end
+          
+          raise OData::AbstractQuery::Errors::InvalidOptionContext.new(query, self) unless query.segments.last.respond_to?(:countable?) && query.segments.last.countable?
+          
+          if query.segments.last.respond_to?(:entity_type)
+            entity_type = query.segments.last.entity_type
+            
+            pairs = value.to_s.split(/\s*,\s*/).collect { |path|
+              if md = path.match(/^([A-Za-z_]+(?:\/[A-Za-z_]+)*)(?:\s+(asc|desc))?$/)
+                property_name = md[1]
+                order = md[2].blank? ? :asc : md[2].to_sym
+
+                property = entity_type.properties.find { |p| p.name == property_name }
+                raise OData::AbstractQuery::Errors::PropertyNotFound.new(query, property_name) if property.blank?
+
+                [property, order]
+              else
+                raise OData::AbstractQuery::Errors::PropertyNotFound.new(query, path)
+              end
+            }
+            
+            query.Option(self, pairs.empty? ? [[entity_type.key_property, :asc]] : pairs)
+          else
+            raise OData::AbstractQuery::Errors::InvalidOptionContext.new(query, self.option_name) unless value.blank?
+          end
+        end
+        
+        def entity_type
+          return nil if self.query.segments.empty?
+          return nil unless self.query.segments.last.respond_to?(:entity_type)
+          @entity_type ||= self.query.segments.last.entity_type
+        end
+
+        def valid?
+          entity_type = self.entity_type
+          return false if entity_type.blank?
+          
+          @pairs.is_a?(Array) && @pairs.all? { |pair|
+            property, value = pair
+            
+            property.is_a?(OData::AbstractSchema::Property) && !!entity_type.properties.find { |p| p.name == property.name }
+          }
+        end
+        
+        def value
+          "'" + @pairs.collect { |p| "#{p.first.name} #{p.last}" }.join(',') + "'"
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/select_option.rb

@@ -0,0 +1,74 @@
+module OData
+  module AbstractQuery
+    module Options
+      class SelectOption < OData::AbstractQuery::Option
+        def self.option_name
+          '$select'
+        end
+
+        attr_reader :properties
+
+        def initialize(query, properties = [])
+          @properties = properties
+          
+          super(query, self.class.option_name)
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          (query.segments.last.is_a?(OData::AbstractQuery::Segments::CollectionSegment) || query.segments.last.is_a?(OData::AbstractQuery::Segments::NavigationPropertySegment))
+        end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          
+          if query.segments.last.respond_to?(:navigation_property)
+            navigation_property = query.segments.last.navigation_property
+            
+            raise OData::AbstractQuery::Errors::InvalidOptionValue.new(query, self.option_name) if navigation_property.to_end.polymorphic?
+          end
+          
+          if query.segments.last.respond_to?(:entity_type)
+            entity_type = query.segments.last.entity_type
+            
+            properties = value.to_s.strip == "*" ? entity_type.properties : value.to_s.split(/\s*,\s*/).collect { |path|
+              if md = path.match(/^([A-Za-z_]+)$/)
+                property_name = md[1]
+                
+                property = entity_type.properties.find { |p| p.name == property_name }
+                raise OData::AbstractQuery::Errors::PropertyNotFound.new(query, property_name) if property.blank?
+
+                property
+              else
+                raise OData::AbstractQuery::Errors::PropertyNotFound.new(query, path)
+              end
+            }
+            
+            query.Option(self, properties)
+          else
+            raise OData::AbstractQuery::Errors::InvalidOptionContext.new(query, self.option_name) unless value.blank?
+          end
+        end
+        
+        def entity_type
+          return nil if self.query.segments.empty?
+          return nil unless self.query.segments.last.respond_to?(:entity_type)
+          @entity_type ||= self.query.segments.last.entity_type
+        end
+
+        def valid?
+          entity_type = self.entity_type
+          return false if entity_type.blank?
+          
+          @properties.is_a?(Array) && @properties.all? { |property|
+            property.is_a?(OData::AbstractSchema::Property) && !!entity_type.properties.find { |p| p == property }
+          }
+        end
+        
+        def value
+          "'" + @properties.collect(&:name).join(',') + "'"
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/skip_option.rb

@@ -0,0 +1,32 @@
+module OData
+  module AbstractQuery
+    module Options
+      class SkipOption < OData::AbstractQuery::Option
+        def self.option_name
+          '$skip'
+        end
+
+        def initialize(query, key, value = nil)
+          super(query, key, value)
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          return false unless query.segments.last.respond_to?(:countable?)
+          query.segments.last.countable?
+        end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          
+          query.Option(self, key, value.to_i)
+        end
+
+        def valid?
+          return false if self.value.blank?
+          self.value.to_i >= 0
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/options/top_option.rb

@@ -0,0 +1,32 @@
+module OData
+  module AbstractQuery
+    module Options
+      class TopOption < OData::AbstractQuery::Option
+        def self.option_name
+          '$top'
+        end
+
+        def initialize(query, key, value = nil)
+          super(query, key, value)
+        end
+        
+        def self.applies_to?(query)
+          return false if query.segments.empty?
+          return false unless query.segments.last.respond_to?(:countable?)
+          query.segments.last.countable?
+        end
+
+        def self.parse!(query, key, value = nil)
+          return nil unless key == self.option_name
+          
+          query.Option(self, key, value.to_i)
+        end
+
+        def valid?
+          return false if self.value.blank?
+          self.value.to_i >= 1
+        end
+      end
+    end
+  end
+end

data/lib/o_data/abstract_query/parser.rb

@@ -0,0 +1,77 @@
+module OData
+  module AbstractQuery
+    class Parser
+      cattr_reader :reserved_option_names
+      @@reserved_option_names = %w{orderby expand select top skip filter format inlinecount}.freeze
+      
+      attr_reader :schema
+      
+      def initialize(schema)
+        @schema = schema
+      end
+      
+      def parse!(uri)
+        return nil if uri.blank?
+        
+        query = @schema.Query
+        
+        resource_path, query_string = uri.split('?', 2)
+        
+        unless resource_path.blank?
+          resource_path_components = resource_path.split('/')
+          resource_path_components.each_index do |i|
+            resource_path_component = resource_path_components[i]
+            segment = _parse_segment!(query, resource_path_component)
+          end
+        end
+        
+        unless query_string.blank?
+          query_string_components = query_string.split('&')
+          query_string_components.each_index do |i|
+            query_string_component = query_string_components[i]
+            option = _parse_option!(query, query_string_component)
+          end
+        end
+        
+        query
+      end
+      
+      protected
+      
+      def _parse_segment!(query, resource_path_component)
+        Object.subclasses_of(Segment).each do |segment_class|
+          if segment_class.can_follow?(query.segments.last)
+            if segment = segment_class.parse!(query, resource_path_component)
+              return segment
+            end
+          end
+        end
+        
+        raise Errors::ParseQuerySegmentException.new(query, resource_path_component)
+      end
+      
+      def _parse_option!(query, query_string_component)
+        key, value = query_string_component.split('=', 2)
+        
+        if md = key.match(/^\$(.*?)$/)
+          raise Errors::InvalidReservedOptionName.new(query, key, value) unless @@reserved_option_names.include?(md[1])
+        end
+        
+        if md = value.match(/^'\s*([^']+)\s*'$/)
+          value = md[1]
+        end
+        
+        Object.subclasses_of(Option).each do |option_class|
+          if option_class.applies_to?(query)
+            if option = option_class.parse!(query, key, value)
+              return option
+            end
+          end
+        end
+        
+        # basic (or "custom") option
+        query.Option(BasicOption, key, value)
+      end
+    end # Parser
+  end # AbstractQuery
+end # OData