odata-model 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dcef84e8ecc5149a6a18c69532677a69bb5febad
-  data.tar.gz: ce363fbfb1866a67e3705b0260e9fc80e0ac004b
+  metadata.gz: 332cae2c88d7bec95fd2099befabbbecc227585a
+  data.tar.gz: 9c7c7fb9ad675081918ddbd85397425ec086c9a0
 SHA512:
-  metadata.gz: 5d171f64ab550e40f4fe064e5d83afb4c595348b9239a5c3efd0b7aa35be874b31d5205478690497eac5494bcc7dac8c18db2702c31004a132393e6f0f18ba68
-  data.tar.gz: cbc3a736fee2b716381ccaaf357dd7cb9037c3e4969f5b71f1e81d021345d80fe80af95c53b974f96b0e1f9f0d22ec6f7c6d01fe115feea32ec55325bb6f6e68
+  metadata.gz: a7d906d5dbf1970f0391133f3daf252e193cdfb452f00a0fda0532357f7c8fb955524579338f1648d93c1025d2664ee746dff72d67f90f03344fa30510431294
+  data.tar.gz: 2de6ebdf03dd5b12d4870e3c39f338d873459be5a1f48f2f9b7f90c1ea973b530fba95d8b003c89aa6a4c86db92d7d8b5aa810be7274816e12575b29fb087e41

data/lib/odata/model/active_model.rb

@@ -0,0 +1,48 @@
+require 'active_model'
+
+module OData
+  module Model
+    # The OData::Model::ActiveModel module encapsulates all the functionality
+    # specifically needed for OData::Model to work with Rails via the
+    # ActiveModel conventions.
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      extend ::ActiveModel::Naming
+      include ::ActiveModel::Validations
+      include ::ActiveModel::Conversion
+      include ::ActiveModel::Dirty
+
+      included do
+        # ...
+      end
+
+      # Integrates ActiveModel's error handling capabilities
+      # @return [ActiveModel::Errors]
+      def errors
+        @errors ||= ::ActiveModel::Errors.new(self)
+      end
+
+      # Used for ActiveModel validations
+      # @api private
+      def read_attribute_for_validation(attr)
+        send(attr)
+      end
+
+      # Methods mixed in at the class level.
+      module ClassMethods
+        # Used for ActiveModel validations
+        # @api private
+        def human_attribute_name(attr, options = {})
+          attr
+        end
+
+        # Used for ActiveModel validations
+        # @api private
+        def lookup_ancestors
+          [self]
+        end
+      end
+    end
+  end
+end

data/lib/odata/model/attributes.rb

@@ -0,0 +1,121 @@
+module OData
+  module Model
+    # The OData::Model::Attributes module encapsulates all the functionality
+    # specifically needed for OData::Model to support the mapping of
+    # OData::Entity properties to attributes on the class that includes
+    # OData::Model.
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        # ...
+      end
+
+      # Returns an array of registered attributes.
+      # @return [Array]
+      # @api private
+      def attributes
+        self.class.class_variable_get(:@@attributes)
+      end
+
+      # Returns the hash for the attribute to property mapping.
+      # @return [Hash]
+      # @api private
+      def property_map
+        self.class.class_variable_get(:@@property_map)
+      end
+
+      # Methods mixed in at the class level.
+      module ClassMethods
+        # Defines a property from this model's related OData::Entity you want
+        # mapped to an attribute.
+        #
+        # @param literal_name [to_s] the literal Entity property name
+        # @param options [Hash] hash of options
+        # @return nil
+        def property(literal_name, options = {})
+          attribute_name = (options[:as] || literal_name.to_s.underscore).to_sym
+
+          register_attribute(attribute_name, literal_name, options)
+          create_accessors(attribute_name)
+
+          nil
+        end
+
+        # Returns an array of all registered attributes
+        # @return [Array]
+        # @api private
+        def attributes
+          if self.class_variable_defined?(:@@attributes)
+            class_variable_get(:@@attributes)
+          else
+            class_variable_set(:@@attributes, [])
+            class_variable_get(:@@attributes)
+          end
+        end
+
+        # Returns a hash keyed to the attribute name of passed options from the
+        # property definitions.
+        # @return [Hash]
+        # @api private
+        def attribute_options
+          if self.class_variable_defined?(:@@attribute_options)
+            class_variable_get(:@@attribute_options)
+          else
+            class_variable_set(:@@attribute_options, {})
+            class_variable_get(:@@attribute_options)
+          end
+        end
+
+        # Returns a hash keyed to the attribute name with the values being the
+        # literal OData property name to use when accessing entity data.
+        # @return [Hash]
+        # @api private
+        def property_map
+          if self.class_variable_defined?(:@@property_map)
+            class_variable_get(:@@property_map)
+          else
+            class_variable_set(:@@property_map, {})
+            class_variable_get(:@@property_map)
+          end
+        end
+
+        # Registers a supplied attribute with its literal property name and any
+        # provided options.
+        # @return [nil]
+        # @api private
+        def register_attribute(attribute_name, literal_name, options)
+          attributes << attribute_name
+          attribute_options[attribute_name] = options
+          property_map[attribute_name] = literal_name
+
+          # Ties into ActiveModel::Dirty
+          define_attribute_methods attribute_name
+
+          nil
+        end
+
+        # Create attribute accessors for the supplied attribute name.
+        # @return [nil]
+        # @api private
+        def create_accessors(attribute_name)
+          class_eval do
+            define_method(attribute_name) do
+              odata_entity[property_map[attribute_name]]
+            end
+
+            define_method("#{attribute_name}=") do |value|
+              unless entity[property_map[attribute_name]] == value
+                send("#{attribute_name}_will_change!")
+              end
+
+              odata_entity[property_map[attribute_name]] = value
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/odata/model/configuration.rb

@@ -0,0 +1,104 @@
+module OData
+  module Model
+    # The OData::Model::Configuration module encapsulates all the functionality
+    # specifically needed for OData::Model to maintain internal configuration
+    # details about it's relationship to the OData gem.
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        # ...
+      end
+
+      # Returns the entity the current model is associated with, or a fresh
+      # entity.
+      # @return [OData::Entity]
+      # @api private
+      def odata_entity
+        @odata_entity ||= self.class.odata_service[odata_entity_set_name].new_entity
+      end
+
+      # Returns the name of the OData::EntitySet the current model is related
+      # to.
+      # @return [String]
+      # @api private
+      def odata_entity_set_name
+        self.class.odata_entity_set_name
+      end
+
+      # Returns the OData::EntitySet the current model is related to.
+      # @return [OData::EntitySet]
+      # @api private
+      def odata_entity_set
+        self.class.odata_entity_set
+      end
+
+      # Methods mixed in at the class level.
+      module ClassMethods
+        # Define the service to use for the current OData::Model. This method
+        # will cause the service to be looked up in the OData::ServiceRegistry
+        # by the supplied key, so it can accept either the service's URL or its
+        # namespace.
+        #
+        # @param service_key [to_s] service URL or namespace
+        # @return [nil]
+        def use_service(service_key)
+          odata_config[:service] = OData::ServiceRegistry[service_key.to_s]
+          nil
+        end
+
+        # Define the entity set to use for the current OData::Model. This
+        # method will record in the OData configuration the supplied name so
+        # that it can be used to communicate properly with the underlying
+        # OData::Service.
+        #
+        # @param set_name [to_s] name of EntitySet used by OData service
+        # @return [nil]
+        def use_entity_set(set_name)
+          odata_config[:entity_set_name] = set_name.to_s
+          nil
+        end
+
+        # Get the OData::Service
+        # @return [OData::Service]
+        # @api private
+        def odata_service
+          odata_config[:service]
+        end
+
+        # Get the OData::Service's namespace
+        # @return [String] OData Service's namespace
+        # @api private
+        def odata_namespace
+          odata_service.try(:namespace)
+        end
+
+        # Returns the configuration for working with the OData gem.
+        # @return [Hash]
+        # @api private
+        def odata_config
+          if class_variable_defined?(:@@odata_config)
+            class_variable_get(:@@odata_config)
+          else
+            class_variable_set(:@@odata_config, {})
+            class_variable_get(:@@odata_config)
+          end
+        end
+
+        # Returns the entity set name this model is related to.
+        # @return [String]
+        # @api private
+        def odata_entity_set_name
+          odata_config[:entity_set_name] ||= self.name.pluralize
+        end
+
+        # Returns the OData::EntitySet the current model is related to.
+        # @return [OData::EntitySet]
+        # @api private
+        def odata_entity_set
+          odata_config[:entity_set] ||= odata_service[odata_entity_set_name]
+        end
+      end
+    end
+  end
+end

data/lib/odata/model/persistence.rb

@@ -0,0 +1,43 @@
+module OData
+  module Model
+    # The OData::Model::Persistence module encapsulates all the functionality
+    # specifically needed for OData::Model to persist data to and from the
+    # OData gem.
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        # ...
+      end
+
+      # Returns whether the current instance has been persisted.
+      # @return [Boolean]
+      def persisted?
+        if instance_variable_defined?(:@persisted)
+          instance_variable_get(:@persisted)
+        else
+          instance_variable_set(:@persisted, false)
+          instance_variable_get(:@persisted)
+        end
+      end
+
+      # Save the current model.
+      def save
+        odata_service[odata_entity_set_name] << odata_entity
+        instance_variable_set(:@persisted, true)
+        changes_applied
+      end
+
+      # Reload the model from OData
+      def reload!
+        # TODO reload OData entity
+        reset_changes
+      end
+
+      # Methods mixed in at the class level.
+      module ClassMethods
+        # ...
+      end
+    end
+  end
+end

data/lib/odata/model/query.rb

@@ -0,0 +1,29 @@
+module OData
+  module Model
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        # ...
+      end
+
+      module ClassMethods
+        # Starts a chain for building up an OData query.
+        # @return [OData::Query::Builder]
+        def find
+          OData::Query::Builder.new(self)
+        end
+
+        # Enables lookup of model entities by their primary key.
+        # @param [to_s] primary key value to lookup
+        # @return [OData::Model,nil]
+        def [](primary_key_value)
+          entity = odata_entity_set[primary_key_value]
+          model = self.new
+          model.instance_variable_set(:@odata_entity, entity)
+          model
+        end
+      end
+    end
+  end
+end

data/lib/odata/model/version.rb

@@ -1,5 +1,5 @@
 module OData
   module Model
-    VERSION = '0.0.1'
+    VERSION = '0.0.2'
   end
 end

data/lib/odata/model.rb

@@ -1,8 +1,17 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/concern'
+
 require 'odata'
-require 'odata/model/version'
 
-require 'active_model'
-require 'active_support/concern'
+require 'odata/query/builder'
+
+require 'odata/model/version'
+require 'odata/model/active_model'
+require 'odata/model/configuration'
+require 'odata/model/attributes'
+require 'odata/model/persistence'
+require 'odata/model/query'
 
 # OData is the parent namespace for the OData::Model project.
 module OData
@@ -12,46 +21,10 @@ module OData
   module Model
     extend ActiveSupport::Concern
 
-    extend ActiveModel::Naming
-    include ActiveModel::Validations
-    include ActiveModel::Conversion
-
-    included do
-      # ...
-    end
-
-    # Integrates ActiveModel's error handling capabilities
-    # @return [ActiveModel::Errors]
-    def errors
-      @errors ||= ActiveModel::Errors.new(self)
-    end
-
-    # Returns whether the current instance has been persisted.
-    # @return [Boolean]
-    def persisted?
-      false
-    end
-
-    # Used for ActiveModel validations
-    # @api private
-    def read_attribute_for_validation(attr)
-      send(attr)
-    end
-
-    # Methods integrated at the class level when OData::Model is included into
-    # a given class.
-    module ClassMethods
-      # Used for ActiveModel validations
-      # @api private
-      def human_attribute_name(attr, options = {})
-        attr
-      end
-
-      # Used for ActiveModel validations
-      # @api private
-      def lookup_ancestors
-        [self]
-      end
-    end
+    include OData::Model::ActiveModel
+    include OData::Model::Configuration
+    include OData::Model::Attributes
+    include OData::Model::Persistence
+    include OData::Model::Query
   end
 end

data/lib/odata/query/builder.rb

@@ -0,0 +1,210 @@
+module OData
+  class Query
+    class Builder
+      SUPPORTED_OPERATIONS = [:eq, :ne, :gt, :ge, :lt, :le, :not]
+
+      # Sets up a new Query Builder.
+      # @param entity_set [OData::EntitySet] the EntitySet to query
+      def initialize(model)
+        @entity_set = model.odata_entity_set
+        @property_map = model.property_map
+      end
+
+      # Set the number of entities to skip for the final query.
+      # @param value [to_i,nil]
+      # @return [self]
+      def skip(value)
+        value = nil if value == 0
+        query_structure[:skip] = value.try(:to_i)
+        self
+      end
+
+      # Set the number of entities to return in the final query.
+      # @param value [to_i,nil]
+      # @return [self]
+      def limit(value)
+        value = nil if value == 0
+        query_structure[:top] = value.try(:to_i)
+        self
+      end
+
+      # Set the options for ordering the final query.
+      # @param args [Symbol,Hash]
+      # @return [self]
+      def order_by(*args)
+        validate_order_by_arguments(args)
+        query_structure[:orderby] += process_order_by_arguments(args)
+        self
+      end
+
+      # Set the properties to select with the final query.
+      # @param args [Array<Symbol>]
+      # @return self
+      def select(*args)
+        args.each {|arg| query_structure[:select] << arg.to_sym}
+        self
+      end
+
+      # Sets up a new filter condition on the provided property mapping.
+      # @param value [to_s]
+      # @return self
+      def where(value)
+        last_filter = query_structure[:filter].last
+        clause = {
+          property:   lookup_property_name(value),
+          opeartion:  nil,
+          argument:   nil
+        }
+
+        if last_filter.is_a?(Array)
+          last_filter << clause
+        else
+          query_structure[:filter] << [clause]
+        end
+        self
+      end
+
+      # Sets the operation and argument for the last filter condition started
+      # by #where, #and or #or.
+      # @param value [Hash]
+      # @return self
+      def is(value)
+        value = value.first
+        validate_is_argument(value)
+        last_filter = query_structure[:filter].last.last
+        if last_filter[:operation].nil? && last_filter[:argument].nil?
+          last_filter[:operation] = value[0].to_sym
+          last_filter[:argument] = value[1]
+        else
+          query_structure[:filter].last << {
+              property:   last_filter[:property],
+              operation:  value[0].to_sym,
+              argument:   value[1]
+          }
+        end
+        self
+      end
+
+      # Adds another filter to the last supplied clause.
+      # @param value [to_s]
+      # @return self
+      def and(value)
+        query_structure[:filter].last << {
+          property:   lookup_property_name(value),
+          opeartion:  nil,
+          argument:   nil
+        }
+        self
+      end
+
+      # Adds an alternate filter after the last supplied clause.
+      # @param value [to_s]
+      # @return self
+      def or(value)
+        query_structure[:filter] << [{
+          property:   lookup_property_name(value),
+          opeartion:  nil,
+          argument:   nil
+        }]
+        self
+      end
+
+      # Returns the current query structure as a valid query string.
+      def to_s
+        # TODO validate the actual query structure
+
+        query_array = []
+        query_array << filters_to_query
+        query_array << orderby_to_query
+        query_array << select_to_query
+        query_array << top_to_query
+        query_array << skip_to_query
+        query_array.compact!
+
+        query_string = query_array.join('&')
+        "#{entity_set.name}?#{query_string}"
+      end
+
+      private
+
+      def query_structure
+        @query_structure ||= {
+            top:      nil,
+            skip:     nil,
+            orderby:  [],
+            select:   [],
+            filter:   []
+        }
+      end
+
+      def entity_set
+        @entity_set
+      end
+
+      def skip_to_query
+        return nil if query_structure[:skip].nil?
+        "$skip=#{query_structure[:skip]}"
+      end
+
+      def top_to_query
+        return nil if query_structure[:top].nil?
+        "$top=#{query_structure[:top]}"
+      end
+
+      def orderby_to_query
+        return nil if query_structure[:orderby].empty?
+        "$orderby=#{query_structure[:orderby].join(',')}"
+      end
+
+      def select_to_query
+        return nil if query_structure[:select].empty?
+        "$select=#{query_structure[:select].join(',')}"
+      end
+
+      def filters_to_query
+        str = "$filter="
+        clauses = []
+        query_structure[:filter].each do |clause|
+          clause_filters = []
+          clause.each do |filter|
+            clause_filters << "#{filter[:property]} #{filter[:operation]} #{filter[:argument]}"
+          end
+          clauses << clause_filters.join(' and ')
+        end
+        clauses.collect! {|clause| "(#{clause})"}
+        str << clauses.join(' or ')
+        str
+      end
+
+      def validate_order_by_arguments(args)
+        args.each do |arg|
+          unless arg.is_a?(Hash) || arg.is_a?(Symbol)
+            raise ArgumentError, 'must be a Hash or Symbol'
+          end
+        end
+      end
+
+      def validate_is_argument(value)
+        raise ArgumentError, 'argument must be a hash' unless value.size == 2
+        raise ArgumentError, "unsupported operation: #{value[0]}" unless SUPPORTED_OPERATIONS.include?(value[0].to_sym)
+      end
+
+      def process_order_by_arguments(args)
+        args.collect do |arg|
+          case arg
+            when is_a?(Symbol)
+              lookup_property_name(arg)
+            when is_a?(Hash)
+              arg.each do |key, value|
+                "#{lookup_property_name(key)} #{value}"
+              end
+          end
+        end
+      end
+
+      def lookup_property_name(mapping)
+        @property_map[mapping.to_s.to_sym]
+      end
+    end
+  end
+end

data/odata-model.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'codeclimate-test-reporter'
   spec.add_development_dependency 'rspec', '~> 3.0.0'
 
-  spec.add_dependency 'odata', '~> 0.1.0'
+  spec.add_dependency 'odata', '~> 0.2.0'
   spec.add_dependency 'activesupport', '>= 3.0.0'
   spec.add_dependency 'activemodel', '>= 3.0.0'
 end

data/spec/example_models/bare_model.rb

@@ -0,0 +1,3 @@
+class BareModel
+  include OData::Model
+end

data/spec/example_models/odatademo_product.rb

@@ -0,0 +1,13 @@
+class Product
+  include OData::Model
+
+  use_service 'ODataDemo'
+
+  property 'ID'
+  property 'Name'
+  property 'Description'
+  property 'Rating'
+  property 'Price'
+  property 'ReleaseDate'
+  property 'DiscontinuedDate'
+end

data/spec/{active_model_lint_spec.rb → model/active_model_lint_spec.rb}

@@ -1,13 +1,9 @@
 require 'spec_helper'
 
-class BareModel
-  include OData::Model
-end
-
 describe OData::Model do
-  let(:subject) { BareModel.new }
+  let(:subject) { Product.new }
 
-  it { expect(BareModel).to respond_to(:model_name) }
+  it { expect(Product).to respond_to(:model_name) }
 
   it { expect(subject).to respond_to(:to_key) }
   it { expect(subject).to respond_to(:to_param) }
@@ -46,7 +42,7 @@ describe OData::Model do
   end
 
   describe '.model_name' do
-    let(:model_name) { BareModel.model_name }
+    let(:model_name) { Product.model_name }
 
     it { expect(model_name).to respond_to(:to_str) }
     it { expect(model_name.human).to respond_to(:to_str) }

data/spec/model/property_defaults_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe OData::Model do
+  describe 'property defaults' do
+    properties = %w{ID Name Description Rating Price ReleaseDate DiscontinuedDate}
+    attributes = properties.collect {|k| k.underscore.to_sym}
+
+    attributes.each do |attr_name|
+      it { expect(Product.new).to respond_to(attr_name) }
+    end
+
+    attributes.each do |attr_name|
+      it { expect(Product.new).to respond_to("#{attr_name}=") }
+    end
+
+    it { expect(Product).to respond_to(:attributes)}
+    it { expect(Product.attributes).to eq(attributes) }
+
+    it { expect(Product.new).to respond_to(:attributes) }
+    it { expect(Product.new.attributes).to eq(attributes) }
+  end
+end

data/spec/model/query_interface_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe OData::Model do
+  describe 'query interface' do
+    it { expect(Product).to respond_to(:[]) }
+    it { expect(Product).to respond_to(:find) }
+
+    describe 'Product[]' do
+      it 'finds a model instance' do
+        expect(Product[0]).to be_a(Product)
+      end
+    end
+
+    describe 'Product.find' do
+      it 'returns an OData::Query::Builder' do
+        expect(Product.find).to be_a(OData::Query::Builder)
+      end
+    end
+  end
+end

data/spec/model/service_integration_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe OData::Model do
+  describe 'service integration' do
+    let(:service) { OData::ServiceRegistry['ODataDemo'] }
+
+    it { expect(Product).to respond_to(:odata_service) }
+    it { expect(Product.odata_service).to be_a(OData::Service) }
+    it { expect(Product.odata_service).to eq(service)}
+
+    it { expect(Product).to respond_to(:odata_namespace) }
+    it { expect(Product.odata_namespace).to eq('ODataDemo') }
+  end
+end

data/spec/query/builder/filters_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe OData::Query::Builder do
+  let(:subject) { OData::Query::Builder.new(Product) }
+
+  describe 'filter method' do
+    describe '#where' do
+      it { expect(subject).to respond_to(:where) }
+
+      it { expect(subject.where(:name)).to be_a(OData::Query::Builder) }
+      it { expect(subject.where(:name)).to eq(subject) }
+    end
+
+    describe '#is' do
+      let(:subject) { OData::Query::Builder.new(Product).where(:name) }
+
+      it { expect(subject).to respond_to(:is) }
+
+      it { expect(subject.is(eq: 'Bread')).to be_a(OData::Query::Builder) }
+      it { expect(subject.is(eq: 'Bread')).to eq(subject) }
+    end
+
+    describe '#and' do
+      let(:subject) { OData::Query::Builder.new(Product).where(:name).is(eq: 'Bread') }
+
+      it { expect(subject).to respond_to(:and) }
+
+      it { expect(subject.and(:name)).to be_a(OData::Query::Builder) }
+      it { expect(subject.and(:name)).to eq(subject) }
+    end
+
+    describe '#or' do
+      let(:subject) { OData::Query::Builder.new(Product).where(:name).is(eq: 'Bread') }
+
+      it { expect(subject).to respond_to(:or) }
+
+      it { expect(subject.or(:name)).to be_a(OData::Query::Builder) }
+      it { expect(subject.or(:name)).to eq(subject) }
+    end
+  end
+end

data/spec/query/builder/order_by_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe OData::Query::Builder do
+  let(:subject) { OData::Query::Builder.new(Product) }
+
+  describe '#order_by' do
+    it { expect(subject).to respond_to(:order_by) }
+
+    describe 'accepts Symbols' do
+      it { expect(subject.order_by(:name)).to be_a(OData::Query::Builder) }
+      it { expect(subject.order_by(:name)).to eq(subject) }
+
+      it { expect(subject.order_by(:price, :rating)).to be_a(OData::Query::Builder) }
+      it { expect(subject.order_by(:price, :rating)).to eq(subject) }
+    end
+
+    describe 'accepts a Hash' do
+      it { expect(subject.order_by(name: :asc)).to be_a(OData::Query::Builder) }
+      it { expect(subject.order_by(name: :asc)).to eq(subject) }
+    end
+  end
+end

data/spec/query/builder/pagination_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe OData::Query::Builder do
+  let(:subject) { OData::Query::Builder.new(Product) }
+
+  describe 'pagination method' do
+    describe '#skip' do
+      it { expect(subject).to respond_to(:skip) }
+      it { expect(subject.skip(5)).to be_a(OData::Query::Builder) }
+      it { expect(subject.skip(5)).to eq(subject) }
+    end
+
+    describe '#limit' do
+      it { expect(subject).to respond_to(:limit) }
+      it { expect(subject.limit(5)).to be_a(OData::Query::Builder) }
+      it { expect(subject.limit(5)).to eq(subject) }
+    end
+  end
+end

data/spec/query/builder/select_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe OData::Query::Builder do
+  let(:subject) { OData::Query::Builder.new(Product) }
+
+  describe '#select' do
+    it { expect(subject).to respond_to(:select) }
+
+    it { expect(subject.select(:name, :description)).to be_a(OData::Query::Builder) }
+    it { expect(subject.select(:name, :description)).to eq(subject) }
+  end
+end

data/spec/query/builder_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe OData::Query::Builder do
+  let(:subject) { OData::Query::Builder.new(Product) }
+
+  describe '#to_s' do
+    it 'properly builds queries' do
+      query_string = "Products?$filter=(Name eq 'Bread')"
+      query = subject.where(:name).is(eq: "'Bread'")
+      expect(query.to_s).to eq(query_string)
+    end
+
+    it 'properly builds queries' do
+      query_string = "Products?$filter=(Name eq 'Bread') or (Name eq 'Milk')"
+      query = subject.where(:name).is(eq: "'Bread'").or(:name).is(eq: "'Milk'")
+      expect(query.to_s).to eq(query_string)
+    end
+
+    it 'properly builds queries' do
+      query_string = 'Products?$filter=(Price lt 15 and Rating gt 3)'
+      query = subject.where(:price).is(lt: 15).and(:rating).is(gt: 3)
+      expect(query.to_s).to eq(query_string)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+
 if ENV['CI']
   require 'codeclimate-test-reporter'
   CodeClimate::TestReporter.start
@@ -10,6 +13,14 @@ end
 
 require 'odata/model'
 
+# Suppressing a deprecation warning
+I18n.enforce_available_locales = false
+
+OData::Service.open('http://services.odata.org/OData/OData.svc')
+
+require 'example_models/bare_model'
+require 'example_models/odatademo_product'
+
 RSpec::Matchers.define :be_boolean do
   match do |actual|
     expect(actual).to satisfy { |x| x == true || x == false }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: odata-model
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - James Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -138,9 +138,25 @@ files:
 - README.md
 - Rakefile
 - lib/odata/model.rb
+- lib/odata/model/active_model.rb
+- lib/odata/model/attributes.rb
+- lib/odata/model/configuration.rb
+- lib/odata/model/persistence.rb
+- lib/odata/model/query.rb
 - lib/odata/model/version.rb
+- lib/odata/query/builder.rb
 - odata-model.gemspec
-- spec/active_model_lint_spec.rb
+- spec/example_models/bare_model.rb
+- spec/example_models/odatademo_product.rb
+- spec/model/active_model_lint_spec.rb
+- spec/model/property_defaults_spec.rb
+- spec/model/query_interface_spec.rb
+- spec/model/service_integration_spec.rb
+- spec/query/builder/filters_spec.rb
+- spec/query/builder/order_by_spec.rb
+- spec/query/builder/pagination_spec.rb
+- spec/query/builder/select_spec.rb
+- spec/query/builder_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ruby-odata/odata-model
 licenses:
@@ -167,5 +183,15 @@ signing_key:
 specification_version: 4
 summary: An ActiveModel mapping layer for the OData gem
 test_files:
-- spec/active_model_lint_spec.rb
+- spec/example_models/bare_model.rb
+- spec/example_models/odatademo_product.rb
+- spec/model/active_model_lint_spec.rb
+- spec/model/property_defaults_spec.rb
+- spec/model/query_interface_spec.rb
+- spec/model/service_integration_spec.rb
+- spec/query/builder/filters_spec.rb
+- spec/query/builder/order_by_spec.rb
+- spec/query/builder/pagination_spec.rb
+- spec/query/builder/select_spec.rb
+- spec/query/builder_spec.rb
 - spec/spec_helper.rb