query-interface-client 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1b22d87e9ab86971cef744ff906b9cc4e2bbf23
-  data.tar.gz: 39eaf53ecd571946d6d65464e40a0959d11c3e3d
+  metadata.gz: c18cd4dae2c81dd2e352d5509607cc1905c0e01e
+  data.tar.gz: 1b68f3bb6b2d722861b111d4237590840f0ec041
 SHA512:
-  metadata.gz: b0ce5334bb11a93e241a8fea146753054bcb7852f4fc06e2f9dcd2a257d4166adbae17868c630bf5f0ad7dbfbab03a22b78520c0668a596510a6fcf2e698dfcd
-  data.tar.gz: f1d68a3da3014232c3e54d48346221c4388f191907a9050b490a2d412ddcd48d75f567662bb8d6ca983cee3071dec10b1e880d3a8e6987252fa62f45c9eeed99
+  metadata.gz: 3ab5f0827c2b0f95f2adf47ac32b5300cd37ba75930551fdc6fa0d73dcbf7f2c83d81a21aaf4a818e73f89eb74fd34c22ca728910d81d6b13637f3b03c6149e4
+  data.tar.gz: c5f347f8779355906031dbf25aa546d992c53750f3090c061a15ce204118cab9a19d835f7a8a65f3ec3a1deba3215ef02f0a8e492bc00a2e0fc12264cb749415

data/Gemfile

@@ -2,8 +2,11 @@ source 'http://rubygems.org'
 
 gem 'her'
 gem 'will_paginate'
+gem 'activesupport', require: false
 
 group :development do
   gem 'rake'
   gem 'rspec'
+  gem 'autotest-standalone'
+  gem 'simplecov', :require => false, :group => :test
 end

data/Gemfile.lock

@@ -11,6 +11,7 @@ GEM
       thread_safe (~> 0.1)
       tzinfo (~> 0.3.37)
     atomic (1.1.10)
+    autotest-standalone (4.5.11)
     builder (3.1.4)
     diff-lcs (1.2.4)
     faraday (0.8.7)
@@ -33,6 +34,10 @@ GEM
     rspec-expectations (2.14.0)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.14.1)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
     thread_safe (0.1.0)
       atomic
     tzinfo (0.3.37)
@@ -42,7 +47,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
+  autotest-standalone
   her
   rake
   rspec
+  simplecov
   will_paginate

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

@@ -2,88 +2,130 @@ module QueryInterface
   module Client
     class LazyQuery
 
-      attr_accessor :model, :api_params, :result
+      attr_accessor :model, :result, :result_model, :transformations
 
-      def initialize(model, api_params = nil)
+      def initialize(model, transformations=nil, result_model=nil)
         self.model = model
-        self.api_params = {
-          conditions: api_params ? api_params[:conditions].dup : {},
-          with: api_params ? api_params[:with].dup : [],
-          order: api_params ? api_params[:order].dup : [],
-        }
+        if transformations
+          self.transformations = transformations.map {|item| item.dup}
+        else
+          self.transformations = []
+        end
         self.result = nil
+        self.result_model = result_model
       end
 
-      def filter(conditions)
-        self.copy.tap do |dataset|
-          dataset.api_params[:conditions].merge!(conditions)
-        end
+      def parse(data)
+        (self.result_model ? self.result_model.parse(data) : self.model.parse(data))
       end
 
-      def with(*fields)
-        self.copy.tap do |dataset|
-          dataset.api_params[:with] += fields
-        end
+      def instantiate(data)
+        (self.result_model ? self.result_model.new(data) : self.model.new(data))
       end
 
-      def order(*fields)
-        self.copy.tap do |dataset|
-          dataset.api_params[:order] = fields
-        end
+      def instantiate_collection(parsed_data)
+        (self.result_model ? self.result_model.new_collection(parsed_data) : self.model.new_collection(parsed_data))
       end
 
       def copy(options = {})
-        self.class.new(self.model, self.api_params)
+        self.class.new(self.model, self.transformations, self.result_model)
       end
 
-      def do_collection_query(params={})
-        self.model.get_collection(:query, query_data: self.api_params.merge(params))
+      def add_transformation(type, parameter=nil)
+        self.transformations << {transformation: type, parameter: parameter}
       end
 
-      def do_resource_query(params = {})
-        self.model.get_resource(:query, query_data: self.api_params.merge(params))
+      def filter(conditions={})
+        self.copy.tap do |query|
+          conditions.each do |key, value|
+            query.add_transformation(:filter, {field: key, value: value})
+          end
+        end
       end
 
-      def do_raw_query(params = {})
-        self.model.get_raw(:query, query_data: self.api_params.merge(params))
+      def instance(id)
+        self.copy.tap do |query|
+          query.add_transformation(:instance, id)
+        end
       end
 
-      def first(*args)
-        one(:first, *args)
+      def context(association, model=nil)
+        self.copy.tap do |query|
+          query.result_model = (model ? model : association.to_s.singularize.camelize.constantize)
+          query.add_transformation(:context, association)
+        end
       end
 
-      def last(*args)
-        one(:last, *args)
+      def with(*fields)
+        self.copy.tap do |query|
+          fields.each do |field|
+            query.add_transformation(:with, field)
+          end
+        end
+      end
+
+      def order(*fields)
+        self.copy.tap do |query|
+          fields.each do |field|
+            query.add_transformation(:order, field)
+          end
+        end
       end
 
       def evaluate
-        self.result ||= self.do_collection_query(mode: :evaluate)
+        self.result ||= self.do_query()
       end
 
-      def paginate(params = {})
-        params = {page: 1, per_page: 10, mode: :paginate}.merge(params)
-        raw = self.do_raw_query(params)[:parsed_data]
-        result = raw[:data]
-        objects = result[:objects].map { |h| self.model.new(h) }
+      def paginate(params={})
+        params = {page: 1, per_page: 10,}.merge(params)
+        self.add_transformation(:paginate, params)
+        raw = self.do_raw_query()
+        result = raw[:parsed_data][:data]
+        objects = result[:objects].map { |h| self.instantiate(h) }
         WillPaginate::Collection.create(params[:page], params[:per_page], result[:total]) do |pager|
           pager.replace objects
         end
       end
 
       def ids
-        response = self.do_raw_query(mode: :ids)
-        response.try(:[], :data)
+        self.add_transformation(:map_ids)
+        self.do_raw_query()[:parsed_data][:data]
       end
 
       def count
         if self.result
           self.result.count
         else
-          r = self.do_raw_query(mode: :count)
+          self.add_transformation(:count)
+          r = self.do_raw_query()
           r[:parsed_data][:data][:count]
         end
       end
 
+      def do_query
+        parsed_data = self.do_raw_query[:parsed_data]
+        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])
+            )
+        end
+      end
+
+      def do_raw_query
+        self.model.get_raw(:query, transformations: self.transformations)
+      end
+
+      def first(*args)
+        one(:first, *args)
+      end
+
+      def last(*args)
+        one(:last, *args)
+      end
+
       def to_json(*args)
         evaluate.to_json(*args)
       end
@@ -98,10 +140,9 @@ module QueryInterface
         if self.result
           self.result.send(which)
         else
-          self.do_resource_query(params.merge(mode: which))
+          self.add_transformation(which)
+          self.do_query
         end
-      rescue Faraday::Error::ResourceNotFound
-        nil
       end
 
     end

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

@@ -1,7 +1,7 @@
 module QueryInterface
   module Client
 
-    VERSION = '0.0.3'
+    VERSION = '0.1.0'
 
   end
 end

data/lib/query-interface-client.rb

@@ -1,4 +1,6 @@
 require 'will_paginate/array'
 
+require 'active_support/core_ext/string'
+
 require 'query-interface-client/lazy_query'
 require 'query-interface-client/resource'

data/query-interface-client.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency(%q<her>)
   s.add_runtime_dependency(%q<will_paginate>)
+  s.add_runtime_dependency(%q<activesupport>)
   s.add_development_dependency(%q<rake>)
   s.add_development_dependency(%q<rspec>)
 end

data/spec/lib/lazy_query_spec.rb

@@ -2,58 +2,77 @@ require 'spec_helper'
 
 
 def deep_copy_check(left, right)
-  left.should_not be(right)
-  [:conditions, :with, :order].each do |key|
-    left[key].should_not be(right[key])
+  left.each_with_index do |item, idx|
+    right[idx].should_not be(item)
   end
 end
 
+class Context
+end
+
 describe QueryInterface::Client::LazyQuery do
   subject {QueryInterface::Client::LazyQuery}
   let(:model) {double("Dummy Model")}
-  let(:default_params) { {conditions: {}, with: [], order: []} }
+  let(:transformations) {[{transformation: :filter, parameter: {field: "hase", value: "wuschel"}}]}
 
   context "construction" do
-    let(:api_params) do
-      {conditions: {field: 'value'}, with: [:inclusion], order: ["-something"]}
-    end
 
     it "initializes itself with empty parameters and a supplied model" do
       query = subject.new(model)
-      query.api_params.should == {conditions: {}, with: [], order: []}
+      query.transformations.should == []
       query.model.should eq(model)
     end
 
-    it "honors passed api params" do
-      query = subject.new(model, api_params)
-      query.api_params.should == api_params
+    it "honors passed transformations params" do
+      query = subject.new(model, transformations)
+      query.transformations.should eq(transformations)
     end
 
-    it "does not alter the originally passed api_params" do
-      query = subject.new(model, api_params)
-      deep_copy_check(api_params, query.api_params)
+    it "does not alter the originally passed transformations" do
+      query = subject.new(model, transformations)
+      deep_copy_check(transformations, query.transformations)
     end
   end
 
   context "copy" do
-    let(:api_params) do
-      {conditions: {field: 'value'}, with: [:inclusion], order: ["-something"]}
-    end
-    it "provides a copy method cloning api_params onto a new instance" do
-      query = subject.new(model, api_params)
+    it "provides a copy method cloning transformations onto a new instance" do
+      query = subject.new(model, transformations)
       query_copy = query.copy
-      query_copy.api_params.should eq(query.api_params)
-      deep_copy_check(query_copy.api_params, query.api_params)
+      query_copy.transformations.should eq(query.transformations)
+      deep_copy_check(query_copy.transformations, query.transformations)
     end
   end
 
   context "filtering" do
-    it "should create a new instance with updated api_params" 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)
       query.filter(a: :b)
-      query_copy.api_params[:conditions].should eq({a: :b})
+      query_copy.transformations.should 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)
+      query.instance(5)
+      query.transformations.should eq([{transformation: :instance, parameter: 5}])
+    end
+  end
+
+  context "context" do
+    let(:query) {subject.new(model)}
+    before do
+      query.should_receive(:copy).and_return(query)
+      query.context(:context)
+    end
+    it "should set the correct result model class" do
+      query.result_model.should == Context
+    end
+    it "sets the context parameter" do
+      query.transformations.should eq([{transformation: :context, parameter: :context}])
     end
   end
 
@@ -63,7 +82,7 @@ describe QueryInterface::Client::LazyQuery do
       query_copy = subject.new(model)
       query.should_receive(:copy).and_return(query_copy)
       query.with(:c)
-      query_copy.api_params[:with].should eq([:c])
+      query_copy.transformations.should eq([{transformation: :with, parameter: :c}])
     end
   end
 
@@ -73,87 +92,140 @@ describe QueryInterface::Client::LazyQuery do
       query_copy = subject.new(model)
       query.should_receive(:copy).and_return(query_copy)
       query.order("-something")
-      query_copy.api_params[:order].should eq(["-something"])
+      query_copy.transformations.should eq([{transformation: :order, parameter: "-something"}])
     end
   end
 
   context "chaining" do
-    it "allows chaining of filter and with" do
-      query = subject.new(model)
-      query_copy = query.filter(a: :b).filter(c: :d).with(:e).with(:f, :g)
-      query_copy.api_params[:conditions].should eq({a: :b, c: :d})
-      query_copy.api_params[:with].should eq([:e, :f, :g])
-    end
-
-    it "calling order multiple times overwrites" do
+    it "allows chaining transformations in order of appearance" do
       query = subject.new(model)
-      query_copy = query.order("-something").order("now really")
-      query_copy.api_params[:order].should eq(["now really"])
+      query_copy = query.filter(a: :b, c: :d).filter(e: :f).with(:x, :y).instance(12).context(:context)
+      query_copy.transformations.should eq(
+        [
+          {transformation: :filter, parameter: {field: :a, value: :b}},
+          {transformation: :filter, parameter: {field: :c, value: :d}},
+          {transformation: :filter, parameter: {field: :e, value: :f}},
+          {transformation: :with, parameter: :x},
+          {transformation: :with, parameter: :y},
+          {transformation: :instance, parameter: 12},
+          {transformation: :context, parameter: :context}
+        ]
+      )
     end
   end
 
   context "first" do
+    let(:transformations) {[transformation: :first, parameter: nil]}
     it "gets the first object via do_query" do
       query = subject.new(model)
-      model.should_receive(:get_resource)
-        .with(:query, query_data: default_params.merge(mode: :first))
-        .and_return("result object")
-      query.first.should eq("result object")
+      query.should_receive(:do_query)
+      query.first
+      query.transformations.should eq(self.transformations)
     end
 
     it "uses the cached result" do
       query = subject.new(model)
       query.result = ["a", "b", "c"]
-      query.should_not_receive(:do_query)
+      query.should_not_receive(:do_raw_query)
       query.first.should eq("a")
     end
   end
 
+  context "last" do
+    let(:transformations) {[transformation: :last, parameter: nil]}
+    it "gets the last object via do_query" do
+      query = subject.new(model)
+      query.should_receive(:do_query)
+      query.last
+      query.transformations.should eq(self.transformations)
+    end
+
+    it "uses the cached result" do
+      query = subject.new(model)
+      query.result = ["a", "b", "c"]
+      query.should_not_receive(:do_raw_query)
+      query.last.should eq("c")
+    end
+  end
+
   context "evaluate" do
-    it "gets results via do_query and caches the result" do
+    let(:transformations) {[]}
+    context "without instance set" do
+      before do
+        model.should_receive(:get_raw)
+        .with(:query, transformations: self.transformations)
+        .and_return({parsed_data: {data: ["result object"]}})
+        model.stub(:new_collection).and_return(["result object"])
+      end
+
+      it "add an evaluation transformation" do
+        query = subject.new(model)
+        query.evaluate
+        query.transformations.should 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"])
+      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)
+      end
+    end
+  end
+
+  context "ids" do
+    let(:transformations) { [{transformation: :map_ids, parameter: nil}] }
+
+    it "adds a map_ids transformation" do
       query = subject.new(model)
-      model.should_receive(:get_collection)
-        .with(:query, query_data: default_params.merge(mode: :evaluate))
-        .and_return(["result object"])
-      query.evaluate.should eq(["result object"])
-      query.result.should eq(["result object"])
+      query.stub!(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
+      query.ids
+      query.transformations.should eq(self.transformations)
     end
 
-    it "doesn't query the api twice" do
+    it "returns the data of the parsed query" do
       query = subject.new(model)
-      model.should_receive(:get_collection)
-        .with(:query, query_data: default_params.merge(mode: :evaluate))
-        .and_return(["result object"])
-      result = query.evaluate
-      result_second = query.evaluate
-      result.should be(result_second)
+      query.should_receive(:do_raw_query).and_return({parsed_data: {data: [1,2,3]}})
+      query.ids.should eq([1, 2, 3])
     end
   end
 
   context "count" do
-    it "gets the count via do_query" do
+    let(:transformations) {[{transformation: :count, parameter: nil}]}
+
+    it "adds a count transformation" do
       query = subject.new(model)
-      model.should_receive(:get_raw).with(:query, query_data: default_params.merge(mode: :count))
-      .and_return({parsed_data: {data: {count: 42}}})
+      query.should_receive(:do_raw_query).and_return({parsed_data: {data: {count: 42}}})
       query.count.should eq(42)
+      query.transformations.should 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_query)
+      query.should_not_receive(:do_raw_query)
       query.count.should eq(3)
     end
   end
 
   context "paginate" do
-    it "paginates results" do
+    let(:transformations) {[{transformation: :paginate, parameter: {page: 1, per_page: 10}}]}
+
+
+    it "adds a paginate transformation" do
       query = subject.new(model)
       objects = (1..10).to_a
-      model.should_receive(:get_raw).with(:query, query_data: default_params.merge({mode: :paginate, page: 1, per_page: 10})).and_return({parsed_data: {data: {objects: objects, total: 15}, errors: []}})
-      objects.should_receive(:map).and_return(objects)
-      result = query.paginate(page: 1, per_page: 10)
-      result.should eq((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: []}})
+      result = query.paginate
+      query.transformations.should eq(self.transformations)
+      result.should eq(objects)
       result.is_a?(WillPaginate::Collection)
       result.total_entries.should eq(15)
     end
@@ -169,4 +241,64 @@ describe QueryInterface::Client::LazyQuery do
     end
   end
 
+  context "do queries" do
+    it "queries the api raw" do
+      query = subject.new(model)
+      model.should_receive(:get_raw).with(:query, 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])
+      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))
+      query.do_query
+    end
+
+  end
+
+  context "parsing" do
+    let(:result_model) { double("result model") }
+    let(:data) { double("data") }
+
+    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)
+      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)
+      query.parse(data)
+    end
+  end
+
+  context "to_json" do
+    let(:transformations) {[]}
+    let(:result) { double("result") }
+    before do
+      model.should_receive(:get_raw)
+      .with(:query, transformations: self.transformations)
+      .and_return({parsed_data: {data: ["result object"]}})
+      model.stub(:new_collection).and_return(result)
+    end
+    it "calls to_json on the evaluated result" do
+      query = subject.new(model)
+      result.should_receive(:to_json)
+      query.to_json
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1 +1,6 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "vendor/"
+  add_filter "spec/"
+end
 require 'query-interface-client'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query-interface-client
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Andreas Kopecky <andreas.kopecky@radarservices.com>
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-10 00:00:00.000000000 Z
+date: 2013-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: her
@@ -40,6 +40,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement