convey_client 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Convey Client
+
+The convey_client gem is an API client for convey.io
+
+## Installation
+
+    gem install convey_client
+
+## Configuration
+
+Add the below to a file and require it at boot up:
+
+    ConveyClient.setup do |config|
+      config.subdomain = "convey"
+      config.use_cache(:basic_file, 300, :path => "tmp/")
+    end
+
+You can specify any Moneta cache store you like, e.g. basic_file, memory, memcache etc and the gem will then cache every request you perform. The (optional) second argument is cache expiry in seconds, you can provide any initialize options required by your cache store as the 3rd arg.
+
+There is an optional third config item, config.raise_request_errors which defaults to false. If you set this to true and the client encounters errors, ConveyClient::RequestErrors will be raised, otherwise you silently get an empty result set (this will be improved in the future).
+
+## Usage
+
+Get a specific item
+
+    ConveyClient::Items.find("convey-item-id")
+
+Get all of your items from convey.io
+
+    ConveyClient::Items.all
+
+Get all items from a specific convey.io bucket
+
+    ConveyClient::Items.in_bucket("convey-bucket-id")
+
+Get all items made with a specific convey.io template
+
+    ConveyClient::Items.in_bucket("convey-template-id")
+
+Get all items from a specific bucket, made with the given template
+
+  ConveyClient::Items.in_bucket_and_using_template("convey-bucket-id", "convey-template-id")
+
+For any request returning a collection, you can search and sort (limiting coming soon), for example:
+
+  ConveyClient::Items.all.sorted("published_on", "desc") # get all items, sorted by the published_on attribute
+  ConveyClient::Items.all.where("published_on" ">", "2012-05-30") # get all items published after May 30, 2012
+
+The available searching operators are: >, <, >=, <=, =, !=, contains, does_not_contain
+

data/lib/convey_client/item.rb

@@ -0,0 +1,19 @@
+module ConveyClient
+  class Item
+    attr_accessor :id, :name, :bucket, :template, :attributes
+
+    def initialize(raw_item)
+      self.id = raw_item["id"]
+      self.name = raw_item["name"]
+      self.bucket = raw_item["bucket"]
+      self.template = raw_item["template"]
+      self.attributes = raw_item["attributes"]
+    end
+
+    def method_missing(method, *args, &block)
+      super unless attributes.keys.include?(method.to_s)
+
+      attributes[method.to_s]["value"]
+    end
+  end
+end

data/lib/convey_client/items.rb

@@ -0,0 +1,100 @@
+require 'json'
+
+module ConveyClient
+  class Items
+    include Enumerable
+
+    attr_accessor :path, :sort_key, :sort_dir, :items, :search_params
+
+    def initialize(path)
+      self.path = path
+      self.items = nil
+      self.search_params = []
+    end
+
+    def sorted(key, dir)
+      self.sort_key = key
+      self.sort_dir = dir
+      self
+    end
+
+    def where(key, operator, val)
+      search_params << [ key, operator, val ]
+      self
+    end
+
+    def each
+      to_a
+      items.each { |item| yield item }
+    end
+
+    def length
+      to_a
+      items.length
+    end
+
+    def to_a
+      return items if items
+
+      parse(ConveyClient::Request.execute(url))
+      items
+    rescue RequestError
+      self.items = []
+    end
+
+    def [](index)
+      to_a[index]
+    end
+
+    def self.find(item_id)
+      new("items/#{item_id}").to_a.first
+    end
+
+    def self.all
+      new("items")
+    end
+
+    def self.in_bucket(bucket_id)
+      new("buckets/#{bucket_id}/items")
+    end
+
+    def self.using_template(template_id)
+      new("templates/#{template_id}/items")
+    end
+
+    def self.in_bucket_and_using_template(bucket_id, template_id)
+      new("buckets/#{bucket_id}/templates/#{template_id}/items")
+    end
+
+  private
+    def parse(raw_items)
+      parsed_items = JSON.parse(raw_items)
+      if parsed_items.is_a?(Array)
+        self.items = parsed_items.collect do |raw_item|
+          Item.new(raw_item)
+        end
+      else
+        self.items = [ Item.new(parsed_items) ]
+      end
+    end
+
+    def url
+      params = []
+
+      if sort_key && sort_dir
+        params << URI.encode("sort[key]=#{sort_key}")
+        params << URI.encode("sort[dir]=#{sort_dir}")
+      end
+
+      search_params.each do |(key, operator, value)|
+        params << URI.encode("search[#{key}][operator]=#{operator}&search[#{key}][value]=#{value}")
+      end
+
+      if params.any?
+        "#{path}?#{params.join("&")}"
+      else
+        path
+      end
+    end
+  end
+end

data/lib/convey_client/request.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+
+module ConveyClient
+  class Request
+    attr_accessor :path
+
+    def initialize(path)
+      self.path = path
+    end
+
+    def self.execute(path)
+      new(path).execute
+    end
+
+    def execute
+      return ConveyClient.cached_response(path) if ConveyClient.cached?(path)
+
+      response = Net::HTTP.get_response(url)
+      if response.code.to_i == 200
+        ConveyClient.cache(path, response.body)
+        response.body
+      else
+        if ConveyClient.raise_request_errors
+          raise ConveyClient::RequestError, "#{url} - #{response.code}"
+        else
+          "[]"
+        end
+      end
+    end
+
+    def url
+      return @url unless @url.nil?
+
+      full_url = ConveyClient.base_url + path
+
+      if (auth_token = ConveyClient.auth_token)
+        full_url += full_url.include?("?") ? "&" : "?"
+        full_url += "token=#{auth_token}"
+      end
+
+      @url = URI.parse(full_url)
+    end
+  end
+end

data/lib/convey_client/request_error.rb

@@ -0,0 +1,4 @@
+module ConveyClient
+  class RequestError < StandardError
+  end
+end

data/lib/convey_client.rb

@@ -0,0 +1,66 @@
+require 'moneta'
+require 'convey_client/item'
+require 'convey_client/items'
+require 'convey_client/request'
+require 'convey_client/request_error'
+
+module ConveyClient
+  class << self
+    attr_accessor :config
+  end
+
+  def self.setup
+    self.config = Configuration.new
+    yield(config)
+  end
+
+  def self.base_url
+    "http://#{config.subdomain}.convey.io/api/"
+  end
+
+  def self.cached?(key)
+    return false unless config.cache
+
+    !config.cache[key].nil? && !config.cache[key].empty?
+  end
+
+  def self.cached_response(key)
+    return unless cached?(key)
+
+    config.cache[key]
+  end
+
+  def self.cache(key, content)
+    return unless config.cache
+
+    options = {}
+    options[:expires_in] = config.cache_timeout if config.cache_timeout
+    config.cache.store(key, content, options)
+  end
+
+  def self.auth_token
+    config.auth_token
+  end
+
+  def self.subdomain
+    config.subdomain
+  end
+
+  def self.raise_request_errors
+    config.raise_request_errors
+  end
+
+  class Configuration
+    attr_accessor :subdomain, :auth_token, :cache, :cache_timeout,
+                  :raise_request_errors
+
+    def use_cache(method, timeout = nil, options={})
+      timeout, options = nil, timeout if timeout.is_a?(Hash)
+
+      klass = method.to_s.split('_').collect { |e| e.capitalize }.join
+      Moneta.autoload(klass.to_sym, "moneta/#{method}")
+      self.cache = Moneta.const_get(klass).new(options)
+      self.cache_timeout = timeout
+    end
+  end
+end

data/spec/convey_client/item_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe ConveyClient::Item do
+  before do
+    @item = ConveyClient::Item.new({
+      "id"         => "id",
+      "name"       => "name",
+      "bucket"     => "bucket-id",
+      "template"   => "template-id",
+      "attributes" => {
+        "age" => {
+          "value" => 28
+        },
+        "level" => {
+          "value" => "blue"
+        },
+      }
+    })
+  end
+
+  describe "core attributes" do
+    it "should store the items id" do
+      @item.id.should == "id"
+    end
+
+    it "should store the items name" do
+      @item.name.should == "name"
+    end
+
+    it "should store the items bucket" do
+      @item.bucket.should == "bucket-id"
+    end
+
+    it "should store the items template" do
+      @item.template.should == "template-id"
+    end
+  end
+
+  describe "accessing template attributes" do
+    it "should provide methods for each attribute key" do
+      @item.age.should == 28
+      @item.level.should == "blue"
+    end
+  end
+end

data/spec/convey_client/items_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+SINGLE_ITEM_RESPONSE = <<-ITEM
+{"name":"First Item Name","id":"first-itemg-name","template":"first-item-template","bucket":"first-items","attributes":{"published_on":{"type":"date","value":"2012-04-27"},"content":{"type":"text","value":"<p>This is some content</p>"}}}
+ITEM
+MULTIPLE_ITEMS_RESPONSE = <<-ITEMS
+[#{SINGLE_ITEM_RESPONSE},{"name":"Second Item Name","id":"second-itemg-name","template":"second-item-template","bucket":"second-items","attributes":{"published_on":{"type":"date","value":"2012-05-27"},"content":{"type":"text","value":"<p>This is second items content</p>"}}}]
+ITEMS
+
+describe ConveyClient::Items do
+  before do
+    ConveyClient.setup do |config|
+      config.subdomain = "test"
+      config.auth_token = nil
+    end
+  end
+
+  describe ".find" do
+    describe "when found" do
+      before do
+        ConveyClient::Request.stub!(:execute).and_return(SINGLE_ITEM_RESPONSE)
+      end
+
+      it "should return the found item" do
+        item = ConveyClient::Items.find("id")
+        item.name.should == "First Item Name"
+      end
+    end
+
+    describe "when nothing is found" do
+      before do
+        ConveyClient::Request.stub!(:execute).and_return("[]")
+      end
+
+      it "should return nil" do
+        ConveyClient::Items.find("id").should be_nil
+      end
+    end
+  end
+
+  describe ".all" do
+    describe "when there is one item" do
+      before do
+        ConveyClient::Request.stub!(:execute).and_return(SINGLE_ITEM_RESPONSE)
+      end
+
+      it "should return an array of one" do
+        ConveyClient::Items.all.length.should == 1
+      end
+    end
+
+    describe "when there are multiple items" do
+      before do
+        ConveyClient::Request.stub!(:execute).and_return(MULTIPLE_ITEMS_RESPONSE)
+        @items = ConveyClient::Items.all
+      end
+
+      it "should return an array" do
+        @items.length.should == 2
+      end
+
+      it "should return the results in order" do
+        @items[0].name.should == "First Item Name"
+        @items[1].name.should == "Second Item Name"
+      end
+    end
+  end
+
+  describe ".in_bucket" do
+    it "should create the appropriate request path" do
+      ConveyClient::Request.should_receive(:execute).with("buckets/bucket-id/items").and_return("[]")
+      ConveyClient::Items.in_bucket("bucket-id").to_a
+    end
+  end
+
+  describe ".using_template" do
+    it "should create the appropriate request path" do
+      ConveyClient::Request.should_receive(:execute).with("templates/template-id/items").and_return("[]")
+      ConveyClient::Items.using_template("template-id").to_a
+    end
+  end
+
+  describe ".in_bucket_and_using_template" do
+    it "should create the appropriate request path" do
+      ConveyClient::Request.should_receive(:execute).with("buckets/bucket-id/templates/template-id/items").and_return("[]")
+      ConveyClient::Items.in_bucket_and_using_template("bucket-id", "template-id").to_a
+    end
+  end
+
+  describe "sorting" do
+    it "should add the appropriate params to the request path" do
+      ConveyClient::Request.should_receive(:execute).with("items?sort[key]=age&sort[dir]=asc").and_return("[]")
+      ConveyClient::Items.all.sorted("age", "asc").to_a
+    end
+  end
+
+  describe "querying" do
+    it "should add the appropriate params to the request path" do
+      ConveyClient::Request.should_receive(:execute).with("items?search[age][operator]==&search[age][value]=20").and_return("[]")
+      ConveyClient::Items.all.where("age", "=", 20).to_a
+    end
+  end
+end

data/spec/convey_client/request_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe ConveyClient::Request do
+  describe "#url" do
+    before do
+      @request = ConveyClient::Request.new("this/is/a/path")
+    end
+
+    describe "with no auth token" do
+      before do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+        end
+      end
+
+      it "should return the base url plus the requests path" do
+        @request.url.to_s.should == "http://test.convey.io/api/this/is/a/path"
+      end
+    end
+
+    describe "with an auth token" do
+      before do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.auth_token = "basdfasdfasdf"
+        end
+      end
+
+      it "should return the base url plus the requests path" do
+        @request.url.to_s.should == "http://test.convey.io/api/this/is/a/path?token=basdfasdfasdf"
+      end
+    end
+  end
+
+  describe "#execute" do
+    before do
+      ConveyClient.setup do |config|
+        config.subdomain = "test"
+      end
+    end
+
+    describe "when a response is not a 200" do
+      before do
+        FakeWeb.register_uri(:get, "http://test.convey.io/api/my/path",
+                             :body => "404", :status => ["404", "Not Found"])
+      end
+
+      describe "when raise_request_errors is set to false" do
+        before do
+          ConveyClient.setup do |config|
+            config.subdomain = "test"
+            config.raise_request_errors = false
+          end
+        end
+
+        it "returns an empty array" do
+          ConveyClient::Request.execute("my/path").should == "[]"
+        end
+      end
+
+      describe "when raise_request_errors is set to true" do
+        before do
+          ConveyClient.setup do |config|
+            config.subdomain = "test"
+            config.raise_request_errors = true
+          end
+        end
+
+        it "raise a request error" do
+          lambda do
+            ConveyClient::Request.execute("my/path")
+          end.should raise_error(ConveyClient::RequestError)
+        end
+      end
+    end
+
+    describe "without a cache" do
+      before do
+        FakeWeb.register_uri(:get, "http://test.convey.io/api/my/path",
+                             :body => "response content")
+      end
+
+      it "should send a http request but not cache the response" do
+        ConveyClient::Request.execute("my/path").should == "response content"
+        ConveyClient.cached_response("my/path").should be_nil
+      end
+    end
+
+    describe "with a cache" do
+      before do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:memory, 86400)
+        end
+      end
+
+      describe "when the path is cached" do
+        it "should return the cached response" do
+          ConveyClient.cache("my/path", "content")
+          ConveyClient::Request.execute("my/path").should == "content"
+        end
+      end
+
+      describe "when the path is not cached" do
+        before do
+          FakeWeb.register_uri(:get, "http://test.convey.io/api/my/path",
+                               :body => "response content")
+        end
+
+        it "should send a http request and cache the response" do
+          ConveyClient::Request.execute("my/path").should == "response content"
+          ConveyClient.cached_response("my/path").should == "response content"
+        end
+      end
+    end
+  end
+end

data/spec/convey_client_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe ConveyClient do
+  describe "setup" do
+    it "should allow me to set an subdomain" do
+      ConveyClient.setup do |config|
+        config.subdomain = "test"
+      end
+
+      ConveyClient.subdomain.should == "test"
+      ConveyClient.auth_token.should be_nil
+    end
+
+    it "should allow me to set an auth_token" do
+      ConveyClient.setup do |config|
+        config.auth_token = "asdf"
+      end
+
+      ConveyClient.auth_token.should == "asdf"
+    end
+  end
+
+  describe ".base_url" do
+    it "should use the given subdomain" do
+      ConveyClient.setup do |config|
+        config.subdomain = "test"
+      end
+      ConveyClient.base_url.should == "http://test.convey.io/api/"
+    end
+  end
+
+  describe "caching" do
+    describe "setup" do
+      it "should allow me to set my cache of choice" do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:basic_file, 300, { :path => "tmp/" })
+        end
+        ConveyClient.config.cache.is_a?(Moneta::BasicFile).should be_true
+        ConveyClient.config.cache_timeout.should == 300
+      end
+    end
+
+    describe ".cached_response" do
+      before do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:memory, 86400)
+        end
+      end
+
+      it "should return the content if key is in cache" do
+        ConveyClient.cache("key", "content")
+        ConveyClient.cached_response("key").should == "content"
+      end
+
+      it "should return false if key is not in the cache cache" do
+        ConveyClient.cached_response("asdflasdklf").should be_nil
+      end
+    end
+
+    describe ".cached?" do
+      it "should be false when there is no cache" do
+        ConveyClient.cached?("key").should be_false
+      end
+
+      it "should be true if a key is in the cache" do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:memory, 86400)
+        end
+        ConveyClient.cache("key", "content")
+        ConveyClient.cached?("key").should be_true
+      end
+
+      it "should be false if a key is not in the cache" do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:memory, 86400)
+        end
+        ConveyClient.cached?("key").should be_false
+      end
+
+      it "should be false if the entry for key is empty" do
+        ConveyClient.setup do |config|
+          config.subdomain = "test"
+          config.use_cache(:memory, 86400)
+        end
+        ConveyClient.cache("key", "")
+        ConveyClient.cached?("key").should be_false
+
+        ConveyClient.cache("key", nil)
+        ConveyClient.cached?("key").should be_false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'convey_client')
+require 'fakeweb'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: convey_client
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Anthony Langhorne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: moneta
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+description: 
+email: conveyisawesome@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- lib/convey_client.rb
+- lib/convey_client/item.rb
+- lib/convey_client/items.rb
+- lib/convey_client/request.rb
+- lib/convey_client/request_error.rb
+- LICENSE
+- README.md
+- spec/convey_client_spec.rb
+- spec/convey_client/item_spec.rb
+- spec/convey_client/items_spec.rb
+- spec/convey_client/request_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/convey/convey-client
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: An API client for convey.io
+test_files: 
+- spec/convey_client_spec.rb
+- spec/convey_client/item_spec.rb
+- spec/convey_client/items_spec.rb
+- spec/convey_client/request_spec.rb
+- spec/spec_helper.rb