query-interface-client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd8b45c8627082cfb7c536191a610f9e30f6d48b
+  data.tar.gz: 0d2b822eb090b86f7a12139e0202a7f247ddb1ec
+SHA512:
+  metadata.gz: f5400488b3a33e95912dcd7ff3883de87434e56e7ad6205328ca894d80be24c22336531fd0ca6d111a0eabc45f3dec5a44268dc58e734b96a52ba22432752650
+  data.tar.gz: b7ab3388fad70f3313d662e1a975cc9f8fda4894a41c7e7e2feccdd1586aff00f2b8bf28a37b0c93df87ebcb9a65dc01557ea476de59da00ce2f1069128c63c3

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+gem 'her'
+gem 'will_paginate'
+
+group :development do
+  gem 'rake'
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,48 @@
+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)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.10)
+    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)
+    i18n (0.6.4)
+    minitest (4.7.5)
+    multi_json (1.7.7)
+    multipart-post (1.2.0)
+    rake (10.1.0)
+    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)
+    thread_safe (0.1.0)
+      atomic
+    tzinfo (0.3.37)
+    will_paginate (3.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  her
+  rake
+  rspec
+  will_paginate

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2013 RadarServices Smart IT-Security <gems@radarservices.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# Query Interface Client
+
+TODO
+
+## Installation
+
+```
+$ gem install query-interface-client
+```
+
+```ruby
+require 'query-interface-client'
+```
+
+or use ``gem 'query-interface-client'`` in your Gemfile when using bundler.
+
+##Examples
+
+TODO
+
+### Usage
+
+TODO

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+task test: :spec

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

@@ -0,0 +1,109 @@
+module QueryInterface
+  module Client
+    class LazyQuery
+
+      attr_accessor :model, :api_params, :result
+
+      def initialize(model, api_params = 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 : [],
+        }
+        self.result = nil
+      end
+
+      def filter(conditions)
+        self.copy.tap do |dataset|
+          dataset.api_params[:conditions].merge!(conditions)
+        end
+      end
+
+      def with(*fields)
+        self.copy.tap do |dataset|
+          dataset.api_params[:with] += fields
+        end
+      end
+
+      def order(*fields)
+        self.copy.tap do |dataset|
+          dataset.api_params[:order] = fields
+        end
+      end
+
+      def copy(options = {})
+        self.class.new(self.model, self.api_params)
+      end
+
+      def do_collection_query(params={})
+        self.model.get_collection(:query, query_data: self.api_params.merge(params))
+      end
+
+      def do_resource_query(params = {})
+        self.model.get_resource(:query, query_data: self.api_params.merge(params))
+      end
+
+      def do_raw_query(params = {})
+        self.model.get_raw(:query, query_data: self.api_params.merge(params))
+      end
+
+      def first(*args)
+        one(:first, *args)
+      end
+
+      def last(*args)
+        one(:last, *args)
+      end
+
+      def evaluate
+        self.result ||= self.do_collection_query(mode: :evaluate)
+      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) }
+        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)
+      end
+
+      def count
+        if self.result
+          self.result.count
+        else
+          r = self.do_raw_query(mode: :count)
+          r[:parsed_data][:data][:count]
+        end
+      end
+
+      def to_json(*args)
+        evaluate.to_json(*args)
+      end
+
+      def method_missing(method_name, *args, &block)
+        evaluate.send(method_name, *args, &block)
+      end
+
+    protected
+
+      def one(which, params = {})
+        if self.result
+          self.result.send(which)
+        else
+          self.do_resource_query(params.merge(mode: which))
+        end
+      rescue Faraday::Error::ResourceNotFound
+        nil
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module QueryInterface::Client
+  module Resource
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    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
+    end
+
+  end
+end

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

@@ -0,0 +1,7 @@
+module QueryInterface
+  module Client
+
+    VERSION = '0.0.2'
+
+  end
+end

data/lib/query-interface-client.rb

@@ -0,0 +1,4 @@
+require 'will_paginate/array'
+
+require 'query-interface-client/lazy_query'
+require 'query-interface-client/resource'

data/query-interface-client.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require File.join(File.dirname(__FILE__), 'lib', 'query-interface-client', 'version')
+
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name = "query-interface-client"
+  s.version = QueryInterface::Client::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andreas Kopecky <andreas.kopecky@radarservices.com>", "Anton Bangratz <anton.bangratz@radarservices.com>", "Martin Natano <martin.natano@radarservices.com"]
+  s.date = Date.today.strftime
+  s.description = "Client for the radar query interface"
+  s.email = "gems [a] radarservices [d] com"
+  s.files            = `git ls-files`.split("\n").reject { |file| file == '.gitignore' }
+  s.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  s.extra_rdoc_files = %w[LICENSE README.md]
+
+  s.homepage = "http://github.com/rs-dev/query-interface-client"
+  s.require_paths = ["lib"]
+  # s.rubygems_version = "1.8.24"
+  s.summary = "Client for the radar query interface"
+  s.license = "ISC"
+
+  s.add_runtime_dependency(%q<her>)
+  s.add_runtime_dependency(%q<will_paginate>)
+  s.add_development_dependency(%q<rake>)
+  s.add_development_dependency(%q<rspec>)
+end

data/spec/lib/lazy_query_spec.rb

@@ -0,0 +1,172 @@
+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])
+  end
+end
+
+describe QueryInterface::Client::LazyQuery do
+  subject {QueryInterface::Client::LazyQuery}
+  let(:model) {double("Dummy Model")}
+  let(:default_params) { {conditions: {}, with: [], order: []} }
+
+  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.model.should eq(model)
+    end
+
+    it "honors passed api params" do
+      query = subject.new(model, api_params)
+      query.api_params.should == api_params
+    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)
+    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)
+      query_copy = query.copy
+      query_copy.api_params.should eq(query.api_params)
+      deep_copy_check(query_copy.api_params, query.api_params)
+    end
+  end
+
+  context "filtering" do
+    it "should create a new instance with updated api_params" 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})
+    end
+  end
+
+  context "with" 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)
+      query.with(:c)
+      query_copy.api_params[:with].should eq([:c])
+    end
+  end
+
+  context "order" 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)
+      query.order("-something")
+      query_copy.api_params[:order].should eq(["-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
+      query = subject.new(model)
+      query_copy = query.order("-something").order("now really")
+      query_copy.api_params[:order].should eq(["now really"])
+    end
+  end
+
+  context "first" do
+    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")
+    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")
+    end
+  end
+
+  context "evaluate" do
+    it "gets results via do_query and caches the result" 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"])
+    end
+
+    it "doesn't query the api twice" 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)
+    end
+  end
+
+  context "count" do
+    it "gets the count via do_query" 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.count.should eq(42)
+    end
+
+    it "uses cached result for counting" do
+      query = subject.new(model)
+      query.result = ["a", "b", "c"]
+      query.should_not_receive(:do_query)
+      query.count.should eq(3)
+    end
+  end
+
+  context "paginate" do
+    it "paginates results" 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)
+      result.is_a?(WillPaginate::Collection)
+      result.total_entries.should eq(15)
+    end
+  end
+
+  context "method_missing" 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!")
+      query.frobnicate!("uargh!")
+    end
+  end
+
+end

data/spec/lib/resource_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+class RMDummyClass
+  include QueryInterface::Client::Resource
+end
+
+describe QueryInterface::Client::Resource do
+
+  let(:lazy_query) { double("LazyQuery") }
+  before(:each) do
+    QueryInterface::Client::LazyQuery.stub(new: lazy_query)
+  end
+  context "class methods" do
+    context ".query" do
+      it "returns a LazyQuery object" do
+        RMDummyClass.query.should 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)
+        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)
+        RMDummyClass.last(args)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'query-interface-client'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: query-interface-client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andreas Kopecky <andreas.kopecky@radarservices.com>
+- Anton Bangratz <anton.bangratz@radarservices.com>
+- Martin Natano <martin.natano@radarservices.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: her
+  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: will_paginate
+  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
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Client for the radar query interface
+email: gems [a] radarservices [d] com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/query-interface-client.rb
+- lib/query-interface-client/lazy_query.rb
+- lib/query-interface-client/resource.rb
+- lib/query-interface-client/version.rb
+- query-interface-client.gemspec
+- spec/lib/lazy_query_spec.rb
+- spec/lib/resource_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/rs-dev/query-interface-client
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Client for the radar query interface
+test_files: []