rhoconnect-rb 0.3.2 → 1.0.0

data/.travis.yml

@@ -4,6 +4,8 @@ rvm:
   - 1.9.2
   - 1.9.3
   - ree
+  - jruby-18mode
+  - jruby-19mode
 notifications:
   email:
     on_success: always

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 1.0.0
+* Added rhoconnect API methods
+* Changed namespace from Rhoconnect to Rhoconnectrb
+* `rhoconnect_query` now takes an attributes hash
+* Added default settings for easier setup w/ RhoConnect apps
+* Travis build support for JRuby

data/Gemfile

@@ -6,6 +6,10 @@ gem 'rails', '>= 3.0'
 
 group :test do
   gem 'rspec', '~>2.5.0', :require => 'spec'
-  gem 'rcov', '~>0.9.8', :platforms => [:ruby_18]
+  gem 'simplecov', :platforms => [:ruby_19,:jruby]
   gem 'webmock'
 end
+
+platforms :jruby do
+  gem 'jruby-openssl'
+end

data/README.md

@@ -1,4 +1,4 @@
-rhoconnect-rb ![Build Status](https://secure.travis-ci.org/rhomobile/rhoconnect-rb.png)
+rhoconnect-rb [![Build Status](https://secure.travis-ci.org/rhomobile/rhoconnect-rb.png)](http://travis-ci.org/rhomobile/rhoconnect-rb)
 ===
 
 A ruby library for the [RhoConnect](http://rhomobile.com/products/rhoconnect) App Integration Server.
@@ -12,23 +12,23 @@ Load the `rhoconnect-rb` library:
 	require 'rhoconnect-rb'
 
 Note, if you are using datamapper, install the `dm-serializer` library and require it in your application.  `rhoconnect-rb` depends on this utility to interact with Rhoconnect applications using JSON.
-	
+
 ## Setup the Model
-Now include Rhoconnect::Resource in a model that you want to synchronize with your mobile application:
+Now include Rhoconnectrb::Resource in a model that you want to synchronize with your mobile application:
 
 	class Product < ActiveRecord::Base
-	  include Rhoconnect::Resource
+	  include Rhoconnectrb::Resource
 	end
-	
+
 Or, if you are using DataMapper:
 
 	class Product
 	  include DataMapper::Resource
-	  include Rhoconnect::Resource
+	  include Rhoconnectrb::Resource
 	end
 
 ## Partitioning Datasets
-	
+
 Next, your models will need to declare a partition key for `rhoconnect-rb`.  This partition key is used by `rhoconnect-rb` to uniquely identify the model dataset when it is stored in a rhoconnect instance.  It is typically an attribute on the model or related model.  `rhoconnect-rb` supports two types of partitions:
 
 * :app - No unique key will be used, a shared dataset is synchronized for all users.
@@ -37,21 +37,21 @@ Next, your models will need to declare a partition key for `rhoconnect-rb`.  Thi
 For example, the `Product` model above might have a `belongs_to :user` relationship.  This provides us a simple way to organize the `Product` dataset for rhoconnect by reusing this relationship.  The partition identifying a username would be declared as:
 
 	class Product < ActiveRecord::Base
-	  include Rhoconnect::Resource
-	  
+	  include Rhoconnectrb::Resource
+
 	  belongs_to :user
-	
-	  def partition 
-		lambda { self.user.username }
+
+	  def partition
+			lambda { self.user.username }
 	  end
 	end
-	
+
 Now all of the `Product` data synchronized by rhoconnect will organized by `self.user.username`.  Note: You can also used a fixed key if the dataset doesn't require a dynamic value:
 
 	def partition
 	  :app
 	end
-	
+
 For more information about Rhoconnect partitions, please refer to the [Rhoconnect docs](http://docs.rhomobile.com/rhoconnect/source-adapters#data-partitioning).
 
 ## Querying Datasets
@@ -59,20 +59,20 @@ For more information about Rhoconnect partitions, please refer to the [Rhoconnec
 `rhoconnect-rb` installs a `/rhoconnect/query` route in your application which the Rhoconnect instance invokes to query the dataset for the dataset you want to synchronize.  This route is mapped to a `rhoconnect_query` method in your model.  This method should return a collection of objects:
 
 	class Product < ActiveRecord::Base
-	  include Rhoconnect::Resource
-	  
+	  include Rhoconnectrb::Resource
+
 	  belongs_to :user
-	
-	  def partition 
-		lambda { self.user.username }
+
+	  def partition
+			lambda { self.user.username }
 	  end
-	
+
 	  def self.rhoconnect_query(partition, attributes = nil)
 	    Product.includes(:user).where("users.username = ?", partition)
 	  end
 	end
 
-In this example, `self.rhoconnect_query` returns a list of products where the partition string (provided by the rhoconnect instance) matches the `user_id` field in the products table.  
+In this example, `self.rhoconnect_query` returns a list of products where the partition string (provided by the rhoconnect instance) matches the `user_id` field in the products table.
 
 ## Configuration and Authentication
 
@@ -83,41 +83,246 @@ Configure RhoConnect in an initializer like `config/initializers/rhoconnect.rb`
 	config.uri   = "http://myrhoconnect.com"
 	config.token = "secrettoken"
 	config.app_endpoint = "http://myapp.heroku.com"
-	
+
 If `app_endpoint` is defined, your Rhoconnect instance will be configured to query data from the endpoint using the rhoconnect_query method in your model.  For example, if your `app_endpoint` is defined as "http://myapp.heroku.com", RhoConnect will query data with:
 
 	POST http://myapp.heroku.com/rhoconnect/query
 
-Example: 
+Example:
 
-   	Rhoconnect.configure do |config|
-      config.uri   		  = "http://myrhoconnect-server.com"
-      config.token 		  = "secrettoken"
-	  config.app_endpoint = "http://myapp.heroku.com"
+	Rhoconnectrb.configure do |config|
+		config.uri    = "http://localhost:8675"
+		config.token  = "mydevtoken"
+		config.app_endpoint = "http://localhost:3000"
 	end
-	
+
 Example with authentication:
 
 `rhoconnect-rb` installs a `/rhoconnect/authenticate` route into your application which will receive credentials from the client.  Add block which handles the credentials:
 
-	Rhoconnect.configure do |config|
-      config.uri   = "http://myrhoconnect-server.com"
-      config.token = "secrettoken"
-	  config.authenticate = lambda { |credentials| 
-        User.authenticate(credentials[:login], credentials[:password]) 
+	Rhoconnectrb.configure do |config|
+		config.uri    = "http://localhost:8675"
+		config.token  = "mydevtoken"
+		config.app_endpoint = "http://localhost:3000"
+	  config.authenticate = lambda { |credentials|
+	  	User.authenticate(credentials[:login], credentials[:password])
 	  }
 	end
-	
+
 ### Using the [RhoConnect Heroku Addon](http://docs.rhomobile.com/rhoconnect/heroku-addon)
 
 If you're using the [RhoConnect Heroku Addon](http://docs.rhomobile.com/rhoconnect/heroku-addon), then you can omit the config.uri and config.token (they are managed for you):
 
-	Rhoconnect.configure do |config|
-	  config.authenticate = lambda { |credentials| 
-	    User.authenticate(credentials[:login], credentials[:password]) 
+	Rhoconnectrb.configure do |config|
+		config.app_endpoint = "http://myapp.heroku.com"
+	  config.authenticate = lambda { |credentials|
+	    User.authenticate(credentials[:login], credentials[:password])
 	  }
 	end
-		
+
+## Rhoconnect-rb API
+
+### Overview of the API
+
+The Rhoconnectrb::API module contains routes to all the resources available in <a href='http://docs.rhomobile.com/rhoconnect/rest-api'>Rhoconnect</a>.  At a high level the API calls take on the following syntax:
+
+	Namespace::Resource.verb_action1_action2_...([resource_id,action1_id,action2_id],data)
+
+Some of these values are not used for every API call such as resource_id and data.
+
+### System Resource
+
+#### `POST /rc/v1/system/login`
+
+
+	data = {:login=>'username',:password=>'password'}
+	Rhoconnectrb::API::System.post_login(data)
+
+#### `GET /rc/v1/system/license`
+
+
+	Rhoconnectrb::API::System.get_license
+
+#### `POST /rc/v1/system/reset`
+
+
+	Rhoconnectrb::API::System.post_reset({})
+
+#### `GET /rc/v1/system/appserver`
+
+
+	Rhoconnectrb::API::System.get_appserver
+
+#### `POST /rc/v1/system/appserver`
+
+
+	data = {:adapter_url=>'http://test.com'}
+	Rhoconnectrb::API::System.post_appserver(data)
+
+#### `GET /rc/v1/system/stats`
+
+
+	data ={:names=>"*sources*"}
+	Rhoconnectrb::API::System.get_stats(data)
+
+### Store Resource
+
+#### `GET /rc/v1/store/:doc`
+
+
+	Rhoconnectrb::API::Store.get('docname')
+
+#### `POST /rc/v1/store/:doc`
+
+
+	data = {:data=>{:id=3},:append=>false}
+	Rhoconnectrb::API::Store.post('docname',data)
+
+### User Resource
+
+#### `POST /rc/v1/users`
+
+
+	data = {:attributes=>{:login=>'login',:password=>'password'}}
+	Rhoconnectrb::API::Users.post(data)
+
+#### `DELETE /rc/v1/users/:user_id`
+
+
+	Rhoconnectrb::API::Users.delete('user_id')
+
+#### `PUT /rc/v1/users/:user_id`
+
+
+	data = {:attributes=>{:a_user_specific_attribute => a_user_specific_attribute_value}}
+	Rhoconnectrb::API::Users.put('user_id',data)
+
+#### `GET /rc/v1/users`
+
+
+	Rhoconnectrb::API::Users.get
+
+#### `Get /rc/v1/users/:user_id`
+
+	Rhoconnectrb::API::Users.get('user_id')
+
+#### `Get /rc/v1/users/:user_id/clients`
+
+
+	Rhoconnectrb::API::Users.get_clients(['user_id','client_id'])
+
+#### `DELETE /rc/v1/users/:user_id/clients/:client_id`
+
+
+	Rhoconnectrb::API::Users.delete_clients(['user_id','client_id'])
+
+#### `GET /rc/v1/users/:user_id/sources/:source_id/docnames`
+
+
+	Rhoconnectrb::API::Users.get_sources_docnames(['user_id','source_id'])
+
+#### `POST /rc/v1/users/ping`
+
+
+	data = {
+	  :api_token => token,
+	  :user_id => [array_of_users],
+	  :sources => source_name,
+	  :message => 'hello world',
+	  :vibrate => 2000,
+	  :sound => 'hello.mp3'
+	}
+	Rhoconnectrb::API::Users.post_ping(data)
+
+#### `GET /rc/v1/users/:user_id/sources/:source_id/docs/:doc`
+
+
+	Rhoconnectrb::API::Users.get_sources_docs(['user_id','source_id','docname'])
+
+#### `POST /rc/v1/users/:user_id/sources/:source_id/docs/:doc`
+
+
+	data = {:data=>data,:append=>false}
+	Rhoconnectrb::API::Users.post_sources_docs(['user_id','source_id','docname'],data)
+
+### Read State Resource
+
+#### `POST /rc/v1/read_state/users/:user_id/sources/:source_id`
+
+
+	data = {:refresh_time => 100}
+	Rhconnectrb::API::ReadState.post_users_sources(['user_id','source_id'])
+
+### Source Resource
+
+#### `GET /rc/v1/sources/type/:partition_type`
+
+
+	Rhoconnectrb::API::Sources.get_type('parition_type')
+
+#### `GET /rc/v1/sources/:source_id`
+
+
+	Rhoconnectrb::API::Sources.get('source_id')
+
+#### `PUT /rc/v1/sources/:source_id`
+
+
+	data = {:user_name=>'username',:data=>{:poll_interval=>25}}
+	Rhoconnectrb::API::Sources.put('source_id',data)
+
+### Client Resource
+
+#### `GET /rc/v1/clients/:client_id`
+
+
+	Rhoconnectrb::API::Clients.get('client_id')
+
+#### `GET /rc/v1/clients/:client_id/sources/:source_id/docnames`
+
+
+	Rhoconnectrb::API::Clients.get_sources_docnames(['client_id','source_id'])
+
+#### `POST /rc/v1/clients/:client_id/sources/:source_id/docnames`
+
+
+	data = {:data=>data,:append=>false}
+	Rhoconnectrb::API::Clients.post_sources_docnames(['client_id','source_id'],data)
+
+### Resource Resource
+
+The Resource class is used for API calls to user defined dynamic or source adapters.  The resource name is passed in as a parameter.
+
+#### `POST /app/v1/:source_name/push_objects`
+
+
+	data = {:user_id=>'user_id',:objects=>data}
+	Rhoconnectrb::API::Resource.post_push_objects('source_name',data)
+
+#### `POST /app/v1/:source_name/push_deletes`
+
+
+	data = {:user_id => 'user_id',:objects=>'object_ids'}
+	Rhoconnectrb::API::Resource.post_push_deletes('source_name',data)
+
+#### `POST /app/v1/:source_name/fast_insert`
+
+
+	data = {:user_id=>'user_id',:objects=>data}
+	Rhoconnectrb::API::Resource.post_fast_insert('source_name',data)
+
+#### `POST /app/v1/:source_name/fast_update`
+
+
+	data = {:user_id=>'user_id',:objects=>data}
+	Rhoconnectrb::API::Resource.post_fast_update('source_name',data)
+
+#### `POST /app/v1/:source_name/fast_delete`
+
+
+	data = {:user_id=>'user_id',:objects=>data}
+	Rhoconnectrb::API::Resource.post_fast_delete('source_name',data)
+
 
 ## Meta
 Created and maintained by Lucas Campbell-Rossen, Vladimir Tarasov and Lars Burgess.

data/Rakefile

@@ -11,11 +11,4 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
-desc "Run all specs with rcov"
-RSpec::Core::RakeTask.new(:rcov) do |t|
-  t.rcov = true
-  t.rcov_opts =  ['--exclude', 'spec/*,gems/*']
-  t.rspec_opts = ["-b", "-c", "-fd"]
-end
-
 task :default => :spec

data/config/routes.rb

@@ -1,7 +1,7 @@
 Rails.application.routes.draw do
-  match '/rhoconnect/authenticate' => Rhoconnect::Authenticate
-  match '/rhoconnect/query' => Rhoconnect::Query
-  match '/rhoconnect/create' => Rhoconnect::Create
-  match '/rhoconnect/update' => Rhoconnect::Update
-  match '/rhoconnect/delete' => Rhoconnect::Delete
+  match '/rhoconnect/authenticate' => Rhoconnectrb::Authenticate
+  match '/rhoconnect/query' => Rhoconnectrb::Query
+  match '/rhoconnect/create' => Rhoconnectrb::Create
+  match '/rhoconnect/update' => Rhoconnectrb::Update
+  match '/rhoconnect/delete' => Rhoconnectrb::Delete
 end

data/lib/rhoconnect-rb.rb

@@ -1,8 +1,9 @@
 require 'json'
 require 'rest_client'
-require 'rhoconnect/version'
-require 'rhoconnect/configuration'
-require 'rhoconnect/client'
-require 'rhoconnect/resource'
-require 'rhoconnect/endpoints'
-require 'rhoconnect/railtie' if defined?(Rails)
+require 'rhoconnectrb/version'
+require 'rhoconnectrb/configuration'
+require 'rhoconnectrb/client'
+require 'rhoconnectrb/resource'
+require 'rhoconnectrb/endpoints'
+require 'rhoconnectrb/railtie' if defined?(Rails)
+Dir["/rhoconnectrb/api/*.rb"].each {|file| require file }

data/lib/rhoconnectrb/api/base.rb

@@ -0,0 +1,50 @@
+require 'rest_client'
+require 'uri'
+
+module Rhoconnectrb
+  module API
+    
+    class Base
+      def self.post(url,data)
+        resp = resource[url].post data.to_json
+        resp.body
+      end
+      
+      def self.get(url,params=nil)
+        if params
+          params = {:params=>params} 
+          resp = resource[url].get(params)
+        else
+          resp = resource[url].get self.content
+        end
+        resp.body
+      end
+      
+      def self.put(url,data)
+        resp = resource[url].put data.to_json
+        resp.body
+      end
+      
+      def self.delete(url,nothing=nil)
+        resp = resource[url].delete
+        resp.body
+      end
+      
+      def self.token
+        url = Rhoconnectrb.configuration.uri || ENV['RHOCONNECT_URL']
+        uri = URI.parse(url)
+        Rhoconnectrb.configuration.token || uri.user
+      end
+      
+      def self.content
+        {'X-RhoConnect-API-TOKEN'=> self.token, :content_type => :json, :accept => :json}
+      end
+      
+      def self.resource
+        uri = Rhoconnectrb.configuration.uri || ENV['RHOCONNECT_URL']
+        RestClient::Resource.new(uri + "/rc/v1",:headers=>self.content)
+      end
+      
+    end
+  end
+end

data/lib/rhoconnectrb/api/clients.rb

@@ -0,0 +1,43 @@
+module Rhoconnectrb
+  module API
+    class Clients
+      def self.klass
+        self.to_s.underscore.split('/')[2]
+      end  
+      
+      def self.method_missing method_name, *args
+        action = method_name.to_s.split("_")
+        #handle CRUD operations
+        if action.size == 1
+          if action[0] =~ /put|delete/
+            Base.send(action[0],"/#{klass}/#{args[0]}",args[1])
+          else
+            url = args.size > 0 ? "/#{klass}/#{args[0]}" : "/#{klass}"
+            resp = Base.send(action[0],url,args[1])
+          end
+        end
+        
+        if action.size > 1
+          verb = action.delete_at(0)
+          #if posting without parameters just post with data else contruct url
+          if verb == 'post' and !args[1]
+            Base.send(verb,"/#{klass}/#{action[0]}",args[0])
+          else
+            if args[0].class.to_s == 'String'
+              url = "/#{klass}/#{args[0]}/#{action[0]}"
+            else
+              url = klass
+              args[0].each_with_index do |value,index|
+                url += "/#{value}"
+                url += "/#{action[index]}" if action[index]
+              end
+            end
+            resp = Base.send(verb,url,args[1])  
+          end
+        end
+        resp
+      end
+      
+    end
+  end
+end

data/lib/rhoconnectrb/api/read_state.rb

@@ -0,0 +1,30 @@
+#READSTATE is special class that does not have resource id so logic changes to account for nil id inherint to every request
+module Rhoconnectrb
+  module API
+    class ReadState
+      
+      def self.klass
+        self.to_s.underscore.split('/')[2]
+      end
+      
+      def self.method_missing method_name, *args
+        action = method_name.to_s.split("_")
+      
+        if action.size > 1
+          verb = action.delete_at(0)
+          
+          if args[0].class.to_s == 'String'
+            url = "/#{klass}/#{action[0]}/#{args[0]}"
+          else
+            url = klass
+            args[0].each_with_index do |value,index|
+              url += "/#{action[index]}" if action[index]
+              url += "/#{value}"
+            end
+          end
+          Base.send(verb,url,args[1])
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnectrb/api/resource.rb

@@ -0,0 +1,36 @@
+module Rhoconnectrb
+  module API
+    class Resource
+      
+      def self.method_missing method_name, *args
+        action = method_name.to_s.split("_")
+        method = "#{action[1]}_#{action[2]}"
+        url = "/#{args[0]}/#{method}"
+        self.send(action[0],url,args[1])  
+      end
+      
+      private 
+      
+      def self.post(url,data)
+        resp = resource[url].post data.to_json, self.content
+        resp.body
+      end
+      
+      def self.token
+         url = Rhoconnectrb.configuration.uri || ENV['RHOCONNECT_URL']
+         uri = URI.parse(url)
+         Rhoconnectrb.configuration.token || uri.user
+      end
+
+      def self.content
+         {'X-RhoConnect-API-TOKEN'=> self.token, :content_type => :json, :accept => :json}
+      end
+
+      def self.resource
+         uri = Rhoconnectrb.configuration.uri || ENV['RHOCONNECT_URL']
+         RestClient::Resource.new(uri + "/app/v1")
+      end
+      
+    end
+  end
+end

data/lib/rhoconnectrb/api/sources.rb

@@ -0,0 +1,47 @@
+module Rhoconnectrb
+  module API
+    class Sources
+
+      def self.klass
+        self.to_s.underscore.split('/')[2]
+      end  
+
+      def self.method_missing method_name, *args
+        action = method_name.to_s.split("_")
+        #handle CRUD operations
+        if action.size == 1
+          if action[0] =~ /put|delete/
+            resp = Base.send(action[0],"/#{klass}/#{args[0]}",args[1])
+          else
+            url = args.size > 0 ? "/#{klass}/#{args[0]}" : klass
+            resp = Base.send(action[0],url,args[1])
+          end
+        end
+  
+        if action.size > 1
+          verb = action.delete_at(0)
+          #if posting without parameters just post with data else contruct url
+          if verb == 'post' and !args[1]
+            resp = Base.send(verb,"/#{klass}/#{action[0]}",args[0])
+          elsif action[0] =~ /type/
+            #special case currently for this one call, refactor after rhoconnect is refactored.  check for array or string passed
+            partition_type =  args[0].is_a?(Array) ? args[0].first.to_sym : args[0].to_sym
+            resp = Base.send(verb,"/#{klass}/#{action[0]}/#{partition_type}")
+          else
+            if args[0].class.to_s == 'String'
+              url = "/#{klass}/#{args[0]}/#{action[0]}"
+            else
+              url = klass
+              args[0].each_with_index do |value,index|
+                url += "/#{value}"
+                url += "/#{action[index]}" if action[index]
+              end
+            end
+            resp = Base.send(verb,url,args[1])  
+          end
+        end
+        resp
+      end
+    end
+  end
+end

data/lib/rhoconnectrb/api/store.rb

@@ -0,0 +1,37 @@
+module Rhoconnectrb
+  module API
+    class Store
+      
+      def self.klass
+        self.to_s.underscore.split('/')[2]
+      end
+      
+      def self.method_missing method_name, *args
+        action = method_name.to_s.split("_")
+        if action.size == 1
+          resp = Base.send(action[0],"/#{klass}/#{args[0]}",args[1])
+        else
+        
+          verb = action.delete_at(0)
+          #if posting without parameters just post with data else contruct url
+          if verb == 'post' and !args[1]
+            resp = Base.send(verb,"/#{klass}/#{action[0]}",args[0])
+          else
+            if args[0].class.to_s == 'String'
+              url = "/#{klass}/#{args[0]}/#{action[0]}"
+            else
+              url = klass
+              args[0].each_with_index do |value,index|
+                url += "/#{value}"
+                url += "/#{action[index]}" if action[index]
+              end
+            end
+            resp = Base.send(verb,url,args[1])  
+          end
+        end
+        resp
+      end
+      
+    end
+  end
+end