query-interface-client 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38358ae4407fb6eaec45f3618356ecc0a4ce6036
-  data.tar.gz: 779c341a7401922afed15e0cc34506b6e52781fa
+  metadata.gz: 058935aef6e41bdd7e467dd59ec3f367b98d93fd
+  data.tar.gz: 30ecc627ea8f2b63a1afa8bd084bf921039e2bd3
 SHA512:
-  metadata.gz: ea1de7c1e67b563d48baaac1c66fa82d1d800186d766a83423e1ac85a7e957283bcf08a6b94db6cb417e5205cad0238ae77da8aae38065c4ce5f7de2df5d1a10
-  data.tar.gz: 2fa98440d3d0d96486b36b54c517f5cc35755bbf3b00efabd1f8ec6bd72072a11f4859268d8d3b45f3e9176b36a6c4ccc7dc461603af0ae72c883d96f9313486
+  metadata.gz: 50a8b92a71878b2a277ff1a3248750e72359c391abab5201b680c679a63a9e16015fa66b23f858435337a0406ec3668c6b75ed1206cb91531acd7a730a47e5b3
+  data.tar.gz: d14949f8023b16b781fc69a312406c129741021ad977247dba4e0008c67608fed5cec585df0a9b9d6d2d7379fd37021445bc452924e1d1d37453558920e0f342

data/Gemfile

@@ -1,9 +1,8 @@
 source 'http://rubygems.org'
 
-gem 'her'
-gem 'json'
 gem 'rs_paginator'
 gem 'activesupport', require: false
+gem 'faraday'
 
 group :development do
   gem 'rake'

data/Gemfile.lock

@@ -1,49 +1,52 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (4.0.0)
-      activesupport (= 4.0.0)
-      builder (~> 3.1.0)
-    activesupport (4.0.0)
-      i18n (~> 0.6, >= 0.6.4)
-      minitest (~> 4.2)
-      multi_json (~> 1.3)
+    actionview (4.1.6)
+      activesupport (= 4.1.6)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+    activesupport (4.1.6)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
       thread_safe (~> 0.1)
-      tzinfo (~> 0.3.37)
-    atomic (1.1.10)
+      tzinfo (~> 1.1)
     autotest-standalone (4.5.11)
-    builder (3.1.4)
-    diff-lcs (1.2.4)
-    faraday (0.8.7)
-      multipart-post (~> 1.1)
-    her (0.6.7)
-      activemodel (>= 3.0.0)
-      activesupport (>= 3.0.0)
-      faraday (~> 0.8)
-      multi_json (~> 1.7)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    erubis (2.7.0)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
     i18n (0.6.11)
     json (1.8.1)
-    minitest (4.7.5)
-    multi_json (1.7.7)
-    multipart-post (1.2.0)
-    rake (10.1.0)
-    rs_paginator (0.0.1)
+    minitest (5.4.2)
+    multi_json (1.10.1)
+    multipart-post (2.0.0)
+    rake (10.3.2)
+    rs_paginator (0.1.1)
+      actionview
       i18n
-    rspec (2.14.0)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.2)
-    rspec-expectations (2.14.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.1)
-    simplecov (0.7.1)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.6)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
       multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-    thread_safe (0.1.0)
-      atomic
-    tzinfo (0.3.37)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
@@ -51,8 +54,7 @@ PLATFORMS
 DEPENDENCIES
   activesupport
   autotest-standalone
-  her
-  json
+  faraday
   rake
   rs_paginator
   rspec

data/lib/query-interface-client/api.rb

@@ -0,0 +1,48 @@
+require 'faraday'
+
+module QueryInterface
+  module Client
+    class API
+      attr_accessor :connection, :url, :options 
+
+      def self.setup(options={}, &faraday_block)
+        @default_api = self.new(options)
+        @default_api.setup_connection(&faraday_block)
+      end
+
+      def initialize(options)
+        if options.include?(:url)
+          self.url = options.delete(:url)
+        end
+        self.options = options
+      end
+
+      def setup_connection(&faraday_block)
+        Faraday.new do |connection|
+          self.connection = connection
+          yield connection if block_given?
+        end
+        self
+      end
+
+      def request(options={})
+        method = options.delete(:_method)
+        path = options.delete(:_path)
+        headers = options.delete(:_headers)
+        response = self.connection.send method do |request|
+          request.headers.merge!(headers) if headers
+          if method == :get
+            # For GET requests, treat additional parameters as querystring data
+            request.url path, options
+          else
+            # For POST, PUT and DELETE requests, treat additional parameters as request body
+            request.url path
+            request.body = options
+          end
+        end
+        {parsed_data: response.env[:body], response: response}
+      end
+
+    end
+  end
+end

data/lib/query-interface-client/json_middleware.rb

@@ -0,0 +1,37 @@
+require 'faraday'
+
+module QueryInterface
+  module Client
+    class JsonMiddleware < Faraday::Response::Middleware
+
+      def parse_json(body)
+        body = '{}' if body.blank?
+        json = JSON.parse(body, symbolize_names: true)
+        unless json.is_a?(Hash) || json.is_a?(Array)
+          raise "Response must be Hash or Array, got: #{body.inspect}"
+        end
+        json
+      end
+
+      def parse(body)
+        json = parse_json(body)
+        errors = json.delete(:errors) || {}
+        metadata = json.delete(:metadata) || {}
+        {
+          :data => json,
+          :errors => errors,
+          :metadata => metadata
+        }
+      end
+
+      def on_complete(env)
+        env[:body] = case env[:status]
+        when 204
+          parse('{}')
+        else
+          parse(env[:body])
+        end
+      end
+    end
+  end
+end

data/lib/query-interface-client/lazy_query.rb

@@ -15,10 +15,6 @@ module QueryInterface
         self.result_model = result_model
       end
 
-      def parse(data)
-        (self.result_model ? self.result_model.parse(data) : self.model.parse(data))
-      end
-
       def instantiate(data)
         (self.result_model ? self.result_model.new(data) : self.model.new(data))
       end
@@ -128,15 +124,12 @@ module QueryInterface
         if parsed_data[:data].is_a?(Array)
           self.instantiate_collection(parsed_data)
         else
-          self.instantiate(
-            self.parse(parsed_data[:data]).
-              merge(_metadata: parsed_data[:metadata], _errors: parsed_data[:errors])
-            )
+          self.instantiate(parsed_data[:data])
         end
       end
 
       def do_raw_query
-        self.model.get_raw(:query, transformations: JSON.dump(self.transformations))
+        self.model.get_raw(path: :query, params: {transformations: JSON.dump(self.transformations)})
       end
 
       def first(*args)

data/lib/query-interface-client/model.rb

@@ -0,0 +1,206 @@
+module QueryInterface
+  module Client
+    class Property
+      attr_accessor :type, :name, :primary, :update, :array, :default
+
+      def initialize(name, type, options={})
+        unless conversion = QueryInterface::Client.types[type]
+          raise "Unknown Type #{type}"
+        end
+        self.type = conversion
+        self.primary = options.delete(:primary) {false}
+        self.update = options.delete(:update) {true}
+        self.array = options.delete(:array) {false}
+        self.default = options.delete(:default) {nil}
+      end
+
+      def run_get_conversion(value)
+        if self.array
+          value ||= []
+          value.map { |item| self.type.apply_get(item) }
+        else
+          self.type.apply_get(value) unless value.nil?
+        end
+      end
+
+      def run_set_conversion(value)
+        if self.array
+          value ||= []
+          value.map { |item| self.type.apply_set(item) }
+        else
+          self.type.apply_set(value) unless value.nil?
+        end
+      end
+    end
+
+    module Model
+      def self.included(base)
+        base.include(QueryInterface::Client::Request)
+        base.include(QueryInterface::Client::Resource)
+        base.include(ActiveModel::Validations)
+        base.include(ActiveModel::Validations::Callbacks)
+        base.include(ActiveModel::Conversion)
+        base.instance_variable_set(:@properties, {})
+        base.send(:attr_accessor, :_property_values, :_additional_values, :_property_changes)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def property(name, type, options={}, &definitions)
+          property = QueryInterface::Client::Property.new(name, type, options)
+
+          define_method name do
+            self.get_value(name)
+          end
+
+          unless property.primary || !property.update
+            define_method "#{name}=".to_sym do |value|
+              if self.get_value(name) != value
+                self.property_changes << name unless self.property_changes.include?(name)
+                self.set_value(name, value)
+              else
+                value
+              end
+            end
+          end
+
+          if block_given?
+            property.instance_eval &definitions
+          end
+
+          @properties[name] = property
+        end
+
+        def primary_keys
+          @properties.map do |name, property|
+            name if property.primary
+          end.compact
+        end
+
+        def new_collection(collection)
+          collection[:data].map do |data|
+            self.new(data)
+          end
+        end
+
+        def get(path, params={})
+          data = self.get_raw(path: path, params: params)[:parsed_data][:data]
+          self.new(data)
+        end
+      end
+
+      module InstanceMethods
+        def initialize(data={})
+          self.set_data(data)
+        end
+
+        def properties
+          self.class.instance_variable_get(:@properties)
+        end
+
+        def set_data(data)
+          data.each do |name, value|
+            name = name.to_sym
+            if self.properties.has_key?(name)
+              property = self.properties[name]
+              self.set_value(name, property.run_set_conversion(value))
+            else
+              self.additional_values[name] = value
+            end
+          end
+          # Initialize missing fields to whatever their default is
+          (self.properties.keys - data.keys.map(&:to_sym)).each do |name|
+            property = self.properties[name]
+            default = property.default
+            self.set_value(name, default.is_a?(Enumerable) ? default.dup : default)
+          end
+        end
+
+        def to_attributes(additional_data={})
+          data = {}
+          properties = self.properties.map do |name, property|
+            [name, property.run_get_conversion(self.get_value(name))] if (property.update && !property.primary)
+          end.compact.to_h
+          data[self.class.name.underscore.to_sym] = properties.merge(additional_data)
+          data
+        end
+
+        def save(additional_data={})
+          if self.persisted? && self.dirty?
+            result = self.put_raw(params: self.to_attributes(additional_data))
+            return result[:response].success?
+          elsif !self.persisted?
+            result = self.class.post_raw(params: self.to_attributes(additional_data))
+            if result[:response].success?
+              self.set_data(result[:parsed_data][:data])
+              return true
+            else
+              return false
+            end
+          else
+            return true
+          end
+        end
+
+        def update_attributes(attributes)
+          self.assign_attributes(attributes)
+          self.save
+        end
+
+        def assign_attributes(attributes)
+          attributes.each do |name, value|
+            method = "#{name}=".to_sym
+            if self.respond_to?(method)
+              self.send(method, value)
+            end
+          end
+        end
+
+        def property_values
+          self._property_values ||= {}
+        end
+
+        def additional_values
+          self._additional_values ||= {}
+        end
+
+        def property_changes
+          self._property_changes ||= []
+        end
+
+        def dirty?
+          self.property_changes.size > 0
+        end
+
+        def set_value(name, value)
+          self.property_values[name] = value
+        end
+
+        def get_value(name)
+          self.property_values[name]
+        end
+
+        def persisted?
+          !!self.id
+        end
+
+        def as_json(options={})
+          prop_vals = self.properties.map do |name, property|
+            [name, property.run_get_conversion(self.get_value(name))]
+          end.to_h
+          prop_vals.merge(self.additional_values).as_json(options)
+        end
+
+        def get(path, params={})
+          self.get_raw(path: path, params: params)[:parsed_data]
+        end
+
+        def destroy
+          result = self.delete_raw()[:parsed_data]
+          # TODO: handle errors and destroyed flag
+        end
+      end
+    end
+  end
+end

data/lib/query-interface-client/request.rb

@@ -0,0 +1,98 @@
+module QueryInterface
+  module Client
+    module Request
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+        base.instance_variable_set(:@_qi_collection_path_fragments, nil)
+        base.instance_variable_set(:@_qi_resource_path_fragments, nil)
+      end
+
+      module ClassMethods
+        def resource_name
+          self.name.underscore.pluralize
+        end
+
+        def collection_path_fragments(*fragments)
+          unless fragments.empty?
+            @_qi_collection_path_fragments = [self.default_api.url] + fragments
+          end
+          @_qi_collection_path_fragments || [self.default_api.url, self.resource_name]
+        end
+
+        def resource_path_fragments(*fragments)
+          unless fragments.empty?
+            @_qi_resource_path_fragments = [self.default_api.url] + fragments
+          end
+          @_qi_resource_path_fragments || self.collection_path_fragments + [:id]
+        end
+
+        def default_api
+          QueryInterface::Client::API.instance_variable_get(:@default_api)
+        end
+
+        def collection_path(path=nil)
+          fragments = self.collection_path_fragments.dup
+          fragments << path unless path.blank?
+          fragments.join("/")
+        end
+
+        # TODO: Discern by "am i an instance or a class" what collection and member routes do
+        def member_path(path=nil, keys={})
+          fragments = self.resource_path_fragments.map do |fragment|
+            if fragment.is_a?(Symbol)
+              if keys.has_key?(fragment) 
+                keys[fragment]
+              else
+                nil
+              end
+            else
+              fragment
+            end
+          end.compact
+          fragments << path unless path.blank?
+          fragments.join("/")
+        end
+
+        def raw_request(method, params, keys, path)
+          if keys
+            params[:_path] = self.member_path(path, keys)
+          else
+            params[:_path] = self.collection_path(path)
+          end
+          params[:_method] = method
+          if params.include?(:_headers)
+            params[:_headers] = params[:_headers].merge(self.default_api.options[:headers])
+          else
+            params[:_headers] = self.default_api.options[:headers]
+          end
+          result = self.default_api.request(params)
+          {parsed_data: result[:parsed_data], response: result[:response]}
+        end
+
+        [:get, :post, :put, :delete].each do |method|
+          define_method "#{method}_raw" do |options={}|
+            params = options.delete(:params) { {} }
+            keys = options.delete(:keys) { {} }
+            path = options.delete(:path)
+            self.raw_request(method, params, keys, path)            
+          end
+        end
+      end
+
+      module InstanceMethods
+        def keys
+          Hash[self.class.primary_keys.map {|primary_key| [primary_key, self.send(primary_key)]}]
+        end
+
+        [:get, :post, :put, :delete, :patch].each do |method|
+          define_method "#{method}_raw" do |options={}|
+            params = options.delete(:params) { {} }
+            path = options.delete(:path)
+            self.class.raw_request(method, params, self.keys, path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/query-interface-client/resource.rb

@@ -1,32 +1,72 @@
-module QueryInterface::Client
-  module Resource
+module QueryInterface
+  module Client
+    class Association
+      attr_accessor :basemodel, :klass, :autoresolve, :dataset
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def first(*args)
-        self.query.order('id').first
+      def initialize(basemodel, name, options={})
+        self.basemodel = basemodel
+        self.klass = (options.delete(:class_name) {name.to_s.singularize.camelize}).constantize
+        self.autoresolve = options.delete(:autoresolve) {true}
+        self.dataset = options.delete(:dataset) {name}
       end
 
-      def last(*args)
-        self.query.order('id').last
+      def query(id)
+        self.basemodel.query.instance(id).context(self.dataset, self.klass)
       end
+    end
 
-      def query
-        LazyQuery.new(self)
+    module Resource
+      def self.included(base)
+        base.instance_variable_set(:@associations, {})
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
       end
 
-      def association(name, class_name: nil, dataset: nil)
-        dataset ||= name
-        define_method(name) do
-          klass = (class_name || name.to_s.singularize.camelize).constantize
-          self.class.query.instance(self.id).context(dataset, klass)
+      module ClassMethods
+        def first(*args)
+          self.query.order('id').first
+        end
+
+        def last(*args)
+          self.query.order('id').last
+        end
+
+        def query
+          LazyQuery.new(self)
+        end
+
+        def association(name, options={})
+          association = QueryInterface::Client::Association.new(self, name, options)
+          define_method name do
+            association.query(self.id)
+          end
+          @associations[name] = association
+        end
+
+        def [](id)
+          self.query.instance(id).evaluate
+        end
+
+        def all
+          self.query.evaluate
         end
       end
 
-    end
+      module InstanceMethods
+        def associations
+          self.class.instance_variable_get(:@associations)
+        end
 
+        def associations_resolved?
+          self.associations.map do |name, association|
+            [name, (association.autoresolve || self.send(name).count == 0)]
+          end.to_h
+        end
+
+        def has_unresolved_dependencies?
+          !self.associations_resolved?.values.all?
+        end
+      end
+    end
   end
 end

data/lib/query-interface-client/types.rb

@@ -0,0 +1,77 @@
+module QueryInterface
+  module Client
+    class Conversion
+      attr_accessor :set_block, :get_block
+
+      def initialize
+        self.get_block = self.set_block = Proc.new { |value| value }
+      end
+
+      def set(&set_block)
+        self.set_block = set_block
+      end
+
+      def get(&get_block)
+        self.get_block = get_block
+      end
+
+      def apply_set(value)
+        self.set_block.call(value)
+      end
+
+      def apply_get(value)
+        self.get_block.call(value)
+      end
+    end
+
+    def self.types
+      @_types ||= {}
+    end
+
+    def self.register_type(type, &registry_block)
+      conversion = Conversion.new
+      if block_given?
+        conversion.instance_eval &registry_block
+      end
+      self.types[type] = conversion
+    end
+
+    register_type :string do
+      set { |value| value.to_s }
+    end
+
+    register_type :integer do
+      set { |value| value.to_i }
+    end
+
+    register_type :float do
+      set { |value| value.to_f }
+    end
+
+    register_type :ip do
+      set { |value| IPAddr.new(value) }
+      get { |value| value.to_s }
+    end
+
+    register_type :date_time do
+      set { |value| value.to_datetime }
+      get { |value| value.to_s }
+    end
+
+    register_type :date do
+      set { |value| value.to_date }
+      get { |value| value.to_s }
+    end
+
+    register_type :mac do
+      set { |value| NetAddr::EUI.create(value) }
+      get { |value| value.address(Delimiter: ':') }
+    end
+
+    register_type :boolean do
+      set { |value| !!value }
+    end
+
+    register_type :raw
+  end
+end

data/lib/query-interface-client/version.rb

@@ -1,7 +1,7 @@
 module QueryInterface
   module Client
 
-    VERSION = '1.2.1'
+    VERSION = '1.3.0'
 
   end
 end

data/lib/query-interface-client.rb

@@ -4,3 +4,8 @@ require 'active_support/core_ext/string'
 
 require 'query-interface-client/lazy_query'
 require 'query-interface-client/resource'
+require 'query-interface-client/model'
+require 'query-interface-client/api'
+require 'query-interface-client/request'
+require 'query-interface-client/types'
+require 'query-interface-client/json_middleware'

data/query-interface-client.gemspec

@@ -23,9 +23,9 @@ Gem::Specification.new do |s|
   s.summary = "Client for the radar query interface"
   s.license = "ISC"
 
-  s.add_runtime_dependency(%q<her>)
-  s.add_runtime_dependency(%q<activesupport>)
   s.add_runtime_dependency(%q<rs_paginator>)
+  s.add_runtime_dependency(%q<activesupport>)
+  s.add_runtime_dependency(%q<faraday>)
   s.add_development_dependency(%q<rake>)
   s.add_development_dependency(%q<rspec>)
 end

data/spec/lib/lazy_query_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 def deep_copy_check(left, right)
   left.each_with_index do |item, idx|
-    right[idx].should_not be(item)
+    expect(right[idx]).not_to be(item)
   end
 end
 
@@ -19,13 +19,13 @@ describe QueryInterface::Client::LazyQuery do
 
     it "initializes itself with empty parameters and a supplied model" do
       query = subject.new(model)
-      query.transformations.should == []
-      query.model.should eq(model)
+      expect(query.transformations).to eq([])
+      expect(query.model).to eq(model)
     end
 
     it "honors passed transformations params" do
       query = subject.new(model, transformations)
-      query.transformations.should eq(transformations)
+      expect(query.transformations).to eq(transformations)
     end
 
     it "does not alter the originally passed transformations" do
@@ -38,7 +38,7 @@ describe QueryInterface::Client::LazyQuery do
     it "provides a copy method cloning transformations onto a new instance" do
       query = subject.new(model, transformations)
       query_copy = query.copy
-      query_copy.transformations.should eq(query.transformations)
+      expect(query_copy.transformations).to eq(query.transformations)
       deep_copy_check(query_copy.transformations, query.transformations)
     end
   end
@@ -47,32 +47,32 @@ describe QueryInterface::Client::LazyQuery do
     it "should create a new instance with updated transformations" do
       query = subject.new(model)
       query_copy = subject.new(model)
-      query.should_receive(:copy).and_return(query_copy)
+      expect(query).to receive(:copy).and_return(query_copy)
       query.filter(a: :b)
-      query_copy.transformations.should eq([{transformation: :filter, parameter: {field: :a, value: :b}}])
+      expect(query_copy.transformations).to eq([{transformation: :filter, parameter: {field: :a, value: :b}}])
     end
   end
 
   context "instancing" do
     it "sets the instance parameter" do
       query = subject.new(model)
-      query.should_receive(:copy).and_return(query)
+      expect(query).to receive(:copy).and_return(query)
       query.instance(5)
-      query.transformations.should eq([{transformation: :instance, parameter: 5}])
+      expect(query.transformations).to eq([{transformation: :instance, parameter: 5}])
     end
   end
 
   context "context" do
     let(:query) {subject.new(model)}
     before do
-      query.should_receive(:copy).and_return(query)
+      expect(query).to receive(:copy).and_return(query)
       query.context(:context)
     end
     it "should set the correct result model class" do
-      query.result_model.should == Context
+      expect(query.result_model).to eq(Context)
     end
     it "sets the context parameter" do
-      query.transformations.should eq([{transformation: :context, parameter: :context}])
+      expect(query.transformations).to eq([{transformation: :context, parameter: :context}])
     end
   end
 
@@ -80,9 +80,9 @@ describe QueryInterface::Client::LazyQuery do
     it "should create a new instance including additional fields" do
       query = subject.new(model)
       query_copy = subject.new(model)
-      query.should_receive(:copy).and_return(query_copy)
+      expect(query).to receive(:copy).and_return(query_copy)
       query.with(:c)
-      query_copy.transformations.should eq([{transformation: :with, parameter: {field: :c}}])
+      expect(query_copy.transformations).to eq([{transformation: :with, parameter: {field: :c}}])
     end
   end
 
@@ -90,9 +90,9 @@ describe QueryInterface::Client::LazyQuery do
     it "should create a new instance includuing order fields" do
       query = subject.new(model)
       query_copy = subject.new(model)
-      query.should_receive(:copy).and_return(query_copy)
+      expect(query).to receive(:copy).and_return(query_copy)
       query.order("-something")
-      query_copy.transformations.should eq([{transformation: :order, parameter: "-something"}])
+      expect(query_copy.transformations).to eq([{transformation: :order, parameter: "-something"}])
     end
   end
 
@@ -100,7 +100,7 @@ describe QueryInterface::Client::LazyQuery do
     it "allows chaining transformations in order of appearance" do
       query = subject.new(model)
       query_copy = query.filter(a: :b, c: :d).filter(e: :f).with(:x, :y).instance(12).context(:context)
-      query_copy.transformations.should eq(
+      expect(query_copy.transformations).to eq(
         [
           {transformation: :filter, parameter: {field: :a, value: :b}},
           {transformation: :filter, parameter: {field: :c, value: :d}},
@@ -118,8 +118,8 @@ describe QueryInterface::Client::LazyQuery do
     it 'gets the first object' do
       query = subject.new(model)
       result = double('result')
-      query.should_receive(:one).with(:first).and_return(result)
-      query.first.should be(result)
+      expect(query).to receive(:one).with(:first).and_return(result)
+      expect(query.first).to be(result)
     end
   end
 
@@ -127,8 +127,8 @@ describe QueryInterface::Client::LazyQuery do
     it 'gets the last object' do
       query = subject.new(model)
       result = double('result')
-      query.should_receive(:one).with(:last).and_return(result)
-      query.last.should be(result)
+      expect(query).to receive(:one).with(:last).and_return(result)
+      expect(query.last).to be(result)
     end
   end
 
@@ -136,17 +136,17 @@ describe QueryInterface::Client::LazyQuery do
     it 'gets one object' do
       query = subject.new(model)
       result = double('result')
-      query.should_receive(:copy).and_return(query)
-      query.should_receive(:do_query).and_return(result)
-      query.result.should be_nil
-      query.send(:one, :anyone).should be(result)
-      query.transformations.should eq([{transformation: :anyone, parameter: nil}])
+      expect(query).to receive(:copy).and_return(query)
+      expect(query).to receive(:do_query).and_return(result)
+      expect(query.result).to be_nil
+      expect(query.send(:one, :anyone)).to be(result)
+      expect(query.transformations).to eq([{transformation: :anyone, parameter: nil}])
     end
     it "uses the cached result" do
       query = subject.new(model)
       query.result = ["a", "b", "c"]
-      query.should_not_receive(:do_query)
-      query.first.should eq("a")
+      expect(query).not_to receive(:do_query)
+      expect(query.first).to eq("a")
     end
   end
 
@@ -154,29 +154,29 @@ describe QueryInterface::Client::LazyQuery do
     let(:transformations) {[]}
     context "without instance set" do
       before do
-        model.should_receive(:get_raw)
-        .with(:query, transformations: JSON.dump(self.transformations))
+        expect(model).to receive(:get_raw)
+        .with(path: :query, params: {transformations: JSON.dump(self.transformations)})
         .and_return({parsed_data: {data: ["result object"]}})
-        model.stub(:new_collection).and_return(["result object"])
+        allow(model).to receive(:new_collection).and_return(["result object"])
       end
 
       it "add an evaluation transformation" do
         query = subject.new(model)
         query.evaluate
-        query.transformations.should eq(transformations)
+        expect(query.transformations).to eq(transformations)
       end
 
       it "gets results via do_query and caches the result" do
         query = subject.new(model)
-        query.evaluate.should eq(["result object"])
-        query.result.should eq(["result object"])
+        expect(query.evaluate).to eq(["result object"])
+        expect(query.result).to eq(["result object"])
       end
 
       it "doesn't query the api twice" do
         query = subject.new(model)
         result = query.evaluate
         result_second = query.evaluate
-        result.should be(result_second)
+        expect(result).to be(result_second)
       end
     end
   end
@@ -186,17 +186,17 @@ describe QueryInterface::Client::LazyQuery do
 
     it "adds a map_ids transformation" do
       query = subject.new(model)
-      query.should_receive(:copy).and_return(query)
-      query.stub(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
+      expect(query).to receive(:copy).and_return(query)
+      allow(query).to receive(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
       query.ids
-      query.transformations.should eq(self.transformations)
+      expect(query.transformations).to eq(self.transformations)
     end
 
     it "returns the data of the parsed query" do
       query = subject.new(model)
-      query.should_receive(:copy).and_return(query)
-      query.should_receive(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
-      query.ids.should eq([1, 2, 3])
+      expect(query).to receive(:copy).and_return(query)
+      expect(query).to receive(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
+      expect(query.ids).to eq([1, 2, 3])
     end
   end
 
@@ -205,17 +205,17 @@ describe QueryInterface::Client::LazyQuery do
 
     it "adds a count transformation" do
       query = subject.new(model)
-      query.should_receive(:copy).and_return(query)
-      query.should_receive(:do_raw_query).and_return({parsed_data: {data: {count: 42}}})
-      query.count.should eq(42)
-      query.transformations.should eq(self.transformations)
+      expect(query).to receive(:copy).and_return(query)
+      expect(query).to receive(:do_raw_query).and_return({parsed_data: {data: {count: 42}}})
+      expect(query.count).to eq(42)
+      expect(query.transformations).to eq(self.transformations)
     end
 
     it "uses cached result for counting" do
       query = subject.new(model)
       query.result = ["a", "b", "c"]
-      query.should_not_receive(:do_raw_query)
-      query.count.should eq(3)
+      expect(query).not_to receive(:do_raw_query)
+      expect(query.count).to eq(3)
     end
   end
 
@@ -225,15 +225,15 @@ describe QueryInterface::Client::LazyQuery do
 
     it "adds a paginate transformation" do
       query = subject.new(model)
-      query.should_receive(:copy).and_return(query)
+      expect(query).to receive(:copy).and_return(query)
       objects = (1..10).to_a
-      model.stub(:new).and_return(*objects)
-      query.should_receive(:do_raw_query).and_return({parsed_data: {data: {objects: objects, total: 15}, errors: []}})
+      allow(model).to receive(:new).and_return(*objects)
+      expect(query).to receive(:do_raw_query).and_return({parsed_data: {data: {objects: objects, total: 15}, errors: []}})
       result = query.paginate
-      query.transformations.should eq(self.transformations)
-      result.should eq(objects)
-      result.is_a?(WillPaginate::Collection)
-      result.total_entries.should eq(15)
+      expect(query.transformations).to eq(self.transformations)
+      expect(result).to eq(objects)
+      result.is_a?(RsPaginator::Collection)
+      expect(result.total).to eq(15)
     end
   end
 
@@ -241,8 +241,8 @@ describe QueryInterface::Client::LazyQuery do
     it "delegates unknown methods to the result of evaluate" do
       query = subject.new(model)
       result = double("result")
-      query.should_receive(:evaluate).and_return(result)
-      result.should_receive(:frobnicate!).with("uargh!")
+      expect(query).to receive(:evaluate).and_return(result)
+      expect(result).to receive(:frobnicate!).with("uargh!")
       query.frobnicate!("uargh!")
     end
   end
@@ -250,24 +250,23 @@ describe QueryInterface::Client::LazyQuery do
   context "do queries" do
     it "queries the api raw" do
       query = subject.new(model)
-      model.should_receive(:get_raw).with(:query, transformations: "[]")
+      expect(model).to receive(:get_raw).with(path: :query, params: {transformations: "[]"})
       query.do_raw_query
     end
 
     it "executes the actual query and creates a collection where appropriate" do
       query = subject.new(model)
       data = {parsed_data: {data: [1,2,3]}}
-      query.should_receive(:do_raw_query).and_return(data)
-      query.should_receive(:instantiate_collection).with(data[:parsed_data])
+      expect(query).to receive(:do_raw_query).and_return(data)
+      expect(query).to receive(:instantiate_collection).with(data[:parsed_data])
       query.do_query
     end
 
     it "executes the actual query and creates an object where appropriate" do
       query = subject.new(model)
       data = {parsed_data: {data: {id: 1, bunny: 'wuschel'}}}
-      query.should_receive(:do_raw_query).and_return(data)
-      query.should_receive(:parse).and_return(data[:parsed_data])
-      query.should_receive(:instantiate).with(data[:parsed_data].merge(_metadata: nil, _errors: nil))
+      expect(query).to receive(:do_raw_query).and_return(data)
+      expect(query).to receive(:instantiate).with(data[:parsed_data][:data])
       query.do_query
     end
 
@@ -280,13 +279,13 @@ describe QueryInterface::Client::LazyQuery do
     it "parses the data via result model if set" do
       query = subject.new(model)
       query.result_model = result_model
-      result_model.should_receive(:parse).with(data)
+      expect(result_model).to receive(:parse).with(data)
       query.parse(data)
     end
 
     it "parses the data via model if no result model set" do
       query = subject.new(model)
-      model.should_receive(:parse).with(data)
+      expect(model).to receive(:parse).with(data)
       query.parse(data)
     end
   end
@@ -295,14 +294,14 @@ describe QueryInterface::Client::LazyQuery do
     let(:transformations) {[]}
     let(:result) { double("result") }
     before do
-      model.should_receive(:get_raw)
-      .with(:query, transformations: JSON.dump(self.transformations))
+      expect(model).to receive(:get_raw)
+      .with(path: :query, params: {transformations: JSON.dump(self.transformations)})
       .and_return({parsed_data: {data: ["result object"]}})
-      model.stub(:new_collection).and_return(result)
+      allow(model).to receive(:new_collection).and_return(result)
     end
     it "calls to_json on the evaluated result" do
       query = subject.new(model)
-      result.should_receive(:to_json)
+      expect(result).to receive(:to_json)
       query.to_json
     end
   end
@@ -311,16 +310,16 @@ describe QueryInterface::Client::LazyQuery do
     let(:transformations) {[]}
     let(:result) { double("result") }
     before do
-      model.should_receive(:get_raw)
-      .with(:query, transformations: JSON.dump(self.transformations))
+      expect(model).to receive(:get_raw)
+      .with(path: :query, params: {transformations: JSON.dump(self.transformations)})
       .and_return({parsed_data: {data: ["result object"]}})
-      model.stub(:new_collection).and_return(result)
+      allow(model).to receive(:new_collection).and_return(result)
     end
     it "calls to_key on the evaluated result if persisted" do
       query = subject.new(model)
-      result.should_receive(:persisted?).and_return(true)
-      result.should_receive(:to_key).and_return([5])
-      query.to_param.should eq("5")
+      expect(result).to receive(:persisted?).and_return(true)
+      expect(result).to receive(:to_key).and_return([5])
+      expect(query.to_param).to eq("5")
     end
 
   end

data/spec/lib/resource_spec.rb

@@ -8,27 +8,27 @@ describe QueryInterface::Client::Resource do
 
   let(:lazy_query) { double("LazyQuery") }
   before(:each) do
-    QueryInterface::Client::LazyQuery.stub(new: lazy_query)
+    allow(QueryInterface::Client::LazyQuery).to receive_messages(new: lazy_query)
   end
   context "class methods" do
     context ".query" do
       it "returns a LazyQuery object" do
-        RMDummyClass.query.should eq(lazy_query)
+        expect(RMDummyClass.query).to eq(lazy_query)
       end
     end
     context ".first" do
       it "queries the query object" do
         args = double("Args")
-        lazy_query.should_receive(:order).with('id').and_return(lazy_query)
-        lazy_query.should_receive(:first)
+        expect(lazy_query).to receive(:order).with('id').and_return(lazy_query)
+        expect(lazy_query).to receive(:first)
         RMDummyClass.first(args)
       end
     end
     context ".last" do
       it "queries the query object" do
         args = double("Args")
-        lazy_query.should_receive(:order).with('id').and_return(lazy_query)
-        lazy_query.should_receive(:last)
+        expect(lazy_query).to receive(:order).with('id').and_return(lazy_query)
+        expect(lazy_query).to receive(:last)
         RMDummyClass.last(args)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query-interface-client
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Andreas Kopecky <andreas.kopecky@radarservices.com>
@@ -10,10 +10,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2014-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: her
+  name: rs_paginator
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -41,7 +41,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rs_paginator
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -96,8 +96,13 @@ files:
 - README.md
 - Rakefile
 - lib/query-interface-client.rb
+- lib/query-interface-client/api.rb
+- lib/query-interface-client/json_middleware.rb
 - lib/query-interface-client/lazy_query.rb
+- lib/query-interface-client/model.rb
+- lib/query-interface-client/request.rb
 - lib/query-interface-client/resource.rb
+- lib/query-interface-client/types.rb
 - lib/query-interface-client/version.rb
 - query-interface-client.gemspec
 - spec/lib/lazy_query_spec.rb