syncano 4.0.0.alpha1 → 4.0.0.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f06e086fb01f6bdd1a005c7ab4618d75babee13e
-  data.tar.gz: b906104e4fa06db0cb09e3808d3fa924dcb8d5ce
+  metadata.gz: bd053f463d602ab8927be7cd6f1da7080cd50e03
+  data.tar.gz: 672affd48e958f2387e1e01a3b74e5a8324a95d2
 SHA512:
-  metadata.gz: 0174413a95cfca8ed8fc4c05409877a0ca76b2f623da5331374a46263e85a50acf38c6b5bb507fa991f2343f58b8ea6f9e0d71e6dbcfbdb9330bfcea4fd450f5
-  data.tar.gz: ac1b5fc9689cac452c336462f7ca71d56b83c67da684e2149ba1ae40bca3c1a51e6a450ae12dc02e582023832a6f15813ab3a5e07b8187a72bc46b76602e8969
+  metadata.gz: 35fc5c588f6b5d90a0b8cd318bf9be218a432985cd7703fe0ab98d1f4c9d01838685e2b137f5e39e3bbd6424f72de3f611e654f01c95d31b3b6c86e0f569f8d9
+  data.tar.gz: 7b4373ec897884764c0a70c0ea1a03504eb72d8841dad4f64653b01a47c4c2b1186a9bf16b74b16d3ca067ffbb679d3602b12321a22fdff84a6c8a0f3033f3ba

data/README.md

@@ -1,167 +1,18 @@
-# Syncano 4.0 ruby gem
+# Syncano 4.0 Ruby Gem
 
+## Ruby QuickStart Guide
+---
 
-## Installation
+Syncano ruby gem provides communication with Syncano platform - ([www.syncano.io](http://www.syncano.io/?utm_source=github&utm_medium=readme&utm_campaign=syncano-ruby))
 
-Using gems:
+You can find quick start on installing and using Syncano's Ruby library in our [documentation](http://docs.syncano.io/docs/ruby/?utm_source=github&utm_medium=readme&utm_campaign=syncano-js).
 
-```bash
-$ gem install syncano --pre
-```
+For more detailed information on how to use Syncano and its features - our [Developer Manual](http://docs.syncano.io/docs/getting-started-with-syncano/?utm_source=github&utm_medium=readme&utm_campaign=syncano-js) should be very helpful.
 
-## First steps
-
-After installation, you have to set a path for api root for syncano.
-
-If you want to use staging, export:
-
-```bash
-$ export API_ROOT=https://api.syncano.rocks
-```
-
-If you're less adventurous, use our production api servers:
-
-```bash
-$ export=API_ROOT=https://api.syncano.io
-```
-
-Ok, now we can start coding!
-
-```ruby
-require 'syncano'
-
-syncano = Syncano.connect(api_key: 'your-api-key')
-
-syncano.instances.all.each { |instance| puts instance }
-```
-
-You can either pass your API key to the connect method as above or set
-`ENV['SYNCANO_API_KEY']` and call just `Syncano.connect`.
-
-## API basics
-
-Syncano API is a nested API - all the endpointes are scoped by an instances, ex.
-codeboxes path is `/instance/your_instance_name/codeboxes/`. Syncano instances
-is more less a schema is in relation databases. **Your instance name must be
-unique across all existing Syncano instnaces, not only limitted to your account.**
-
-
-# Instances
-
-In order to do anything with Syncano, you have to create an instances. Choose a
-globally unique name and call:
-
-```ruby
-instances = syncano.instances.create name: 'my_instances_name'       
-instance.first
-
-#=> #<Syncano::Resources::Instance created_at: Sun, 26 Apr 2015 18:09:46 +0000, description: "", metadata: {}, name: "my_instance_name", owner: nil, role: "full", updated_at: Sun, 26 Apr 2015 18:09:46 +0000>
-```
-
-# Classes and objects
-
-In order to save objects in Syncano, first you need to create a class. A class
-defines objects' attributes in the class' schema. The attribute definition has two
-mandatory (`name`, `type`) and two optional fields (`filter_index`, `order_index`).
-What these fields are for is rather obvious - `name` defines objects' attribute
-name, and `type` defines type (you can read more about available types in the 
-[API docs](http://docs.syncano.com/v0.1/docs/instancesinstanceclasses-2)). `*_index`
-fields are indexing. `order_index` allows you order returned collections, 
-`filter_index` allows filtering in a various ways. There will be a few examples
-in this README, but you can read in the 
-[API docs](http://docs.syncano.com/v0.1/docs/filtering-data-objects).
-
-```ruby
-  stock = instance.classes.create name: 'stock_items',
-                                  schema: [{ name: 'name', type: 'string',
-                                             filter_index: true },
-                                           { name: 'amount', type: 'integer',
-                                             filter_index: true,
-                                             order_index: true }]
-```
-
-Once we have a class, we can start creating objects. 
-
-```ruby
-  chorizo = stock.objects.create name: 'Chorizo', amount: 100
-  black_pudding = stock.objects.create name: 'Black pudding', amount: 200
-  curry_wurts = stock.objects.create name: 'Curry wurst', amount: 150
-  kabanos = stock.objects.create name: 'Kabanos' 
-  something = stock.objects.create amount: 3
-```
-
-Now we have a few items in stock, let's try filtering. 
-
-```ruby
-  stock.objects.all(order_by: '-amount', query: { amount: { _lte: 150 }, name: { _exists: true } })
-  #=> #<Syncano::Resources::Collection:0x007fc18b9c7698 @next=false, @prev=false, @collection=[#<Syncano::Resources::Object amount: 150, channel: nil, channel_room: nil, created_at: Mon, 27 Apr 2015 05:21:31 +0000, group: nil, group_permissions: "none", id: 12, name: "Curry wurst", other_permissions: "none", owner: nil, owner_permissions: "none", revision: 1, updated_at: Mon, 27 Apr 2015 05:21:31 +0000>, #<Syncano::Resources::Object amount: 100, channel: nil, channel_room: nil, created_at: Mon, 27 Apr 2015 05:21:30 +0000, group: nil, group_permissions: "none", id: 10, name: "Chorizo", other_permissions: "none", owner: nil, owner_permissions: "none", revision: 1, updated_at: Mon, 27 Apr 2015 05:21:30 +0000>]> 
-```
-
-Let's give `something` a name and try again.
-
-```ruby
-  something.name = 'Unidentified sausage' 
-  something.save
-  
-  stock.objects.all(order_by: '-amount', query: { amount: { _lte: 150 }, name: { _exists: true } })
-  #=> #<Syncano::Resources::Collection:0x007fc18d58a628 @next=false, @prev=false, @collection=[#<Syncano::Resources::Object amount: 150, channel: nil, channel_room: nil, created_at: Mon, 27 Apr 2015 05:21:31 +0000, group: nil, group_permissions: \"none\", id: 12, name: \"Curry wurst\", other_permissions: \"none\", owner: nil, owner_permissions: \"none\", revision: 1, updated_at: Mon, 27 Apr 2015 05:21:31 +0000>, #<Syncano::Resources::Object amount: 100, channel: nil, channel_room: nil, created_at: Mon, 27 Apr 2015 05:21:30 +0000, group: nil, group_permissions: \"none\", id: 10, name: \"Chorizo\", other_permissions: \"none\", owner: nil, owner_permissions: \"none\", revision: 1, updated_at: Mon, 27 Apr 2015 05:21:30 +0000>, #<Syncano::Resources::Object amount: 3, channel: nil, channel_room: nil, created_at: Mon, 27 Apr 2015 05:30:18 +0000, group: nil, group_permissions: \"none\", id: 15, name: \"Unidentified sausage\", other_permissions: \"none\", owner: nil, owner_permissions: \"none\", revision: 2, updated_at: Mon, 27 Apr 2015 05:30:48 +0000>]>
-```
-
-Now it matches the query and appears in the result.
-
-# Codeboxes
-
-Codeboxes are small pieces of code that run on Syncano servers. You can run them
-manually using the API, you can create a schedule to run them periodically, you 
-can create a Webhook (and optionally make it public) to run them from the web, 
-you can create a trigger to run one after a class' object is created, updated or 
-deleted. There are three runtimes available: Ruby, Python and Node. This gem is 
-available in Ruby runtime (just needs to be required). Let's create a simple 
-codebox and run it. 
-
-```ruby
-clock = instance.codeboxes.create(name: 'clock', source: 'puts Time.now', runtime_name: 'ruby')
-#=> #<Syncano::Resources::CodeBox config: {}, created_at: Thu, 30 Apr 2015 05:50:09 +0000, description: "", id: 1, name: "clock", runtime_name: "ruby", source: "puts Time.now", updated_at: Thu, 30 Apr 2015 05:50:09 +0000>
-clock.run 
-#=> {"status"=>"pending", "links"=>{"self"=>"gv1/instances/a523b7e842dea927d8c306ec0a9a7a4ac30191c2cd034b11d/codeboxes/1/traces/1/"}, "executed_at"=>nil, "result"=>"", "duration"=>nil, "id"=>1}
-```
-
-When you schedule a codebox run, it returns the trace. Immediately after the 
-call it's status is pending, so you need to check the trace. 
-
-```ruby
-clock.traces.first
-=> #<Syncano::Resources::CodeBoxTrace duration: 526, executed_at: Thu, 30 Apr 2015 05:25:14 +0000, id: 1, result: "2015-04-30 05:25:14 +0000", status: "success">
-```
-
-The run method is asynchronous and returns immediately. You should use this to
-run codeboxes when you don't care about results at this very moment. If you 
-want to run the codebox and get results in one call, you should use webhooks.
-
-# Webhooks 
-
-You can use webhooks to run codeboxes synchronously. Webhooks can be either 
-public or private. You have to provide your API key when calling private ones, 
-public are public, you can call them with curl, connect with third party
-services,  etc. Ruby:
-
-
-```ruby
-webhook = @instance.webhooks.create slug: 'clock-webhook', codebox: clock.primary_key, public: true
-#=> #<Syncano::Resources::Webhook codebox: 1, public: true, public_link: "a20b0ae122b53b2f2c445f6a7a202b274c3631ad", slug: "clock-webhook">
-
-webhook.run['result']
-#=> "2015-04-30 05:51:45 +0000"
-```
-
-and curl
-
-```bash
-$ curl "https://api.syncano.rocks/v1/instances//af248d3e8b92e6e7aaa42dfc41de80c66c90d620cbe3fcd19/webhooks/p/a20b0ae122b53b2f2c445f6a7a202b274c3631ad/"
-{"status": "success", "duration": 270, "result": "2015-04-30 06:11:08 +0000", "executed_at": "2015-04-30T06:11:08.607389Z"}
-```
+In case you need help working with the library - email us at libraries@syncano.com - we will be happy to help!
 
 ## Contributing
+---
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/circle.yml

@@ -2,7 +2,7 @@ machine:
   ruby:
     version: 2.1.5
   environment:
-    API_ROOT: https://v4.hydraengine.com
+    API_ROOT: https://api.syncano.rocks
 dependencies:
   override:
     - gem install bundler -v 1.7

data/lib/syncano.rb

@@ -1,30 +1,42 @@
 $: << Dir.pwd
 
-require 'faraday'
-require 'active_attr/model'
-require 'active_attr/dirty'
-require 'active_attr/typecasting_override'
-require 'active_support/core_ext/hash/indifferent_access'
+require 'active_attr'
+require 'active_model'
+require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/inflector'
+require 'celluloid/future'
+require 'celluloid/io'
+require 'faraday'
+require 'http'
+require 'yaml'
+require 'mimetype_fu'
+
+require 'syncano/query_builder'
 require 'syncano/version'
 require 'syncano/api'
+require 'syncano/api/endpoints'
 require 'syncano/connection'
 require 'syncano/schema'
 require 'syncano/scope'
+require 'syncano/poller'
 require 'syncano/resources'
 require 'syncano/resources/base'
 require 'syncano/resources/collection'
+require 'syncano/resources/paths'
+require 'syncano/resources/resource_invalid'
 require 'syncano/resources/space'
+require 'syncano/response'
+require 'syncano/upload_io'
 require 'syncano/query_builder'
-require 'syncano/model/base'
 
 module Syncano
   class << self
     def connect(options = {})
       connection = Connection.new(
           options.reverse_merge(api_key: ENV['SYNCANO_API_KEY']))
-      connection.authenticate! unless connection.authenticated?
+      connection.authenticate unless connection.authenticated?
 
       API.new connection
     end
@@ -35,6 +47,23 @@ module Syncano
   class RuntimeError < StandardError; end
 
   class HTTPError < StandardError
+  end
+
+  class NotFound < HTTPError
+    attr_accessor :path, :method_name
+
+    def initialize(path, method_name)
+      self.path = path
+      self.method_name = method_name
+    end
+
+    def inspect
+      %{#{self.class.name} path: "#{path}" method: "#{method_name}"}
+    end
+  end
+
+  class HTTPErrorWithBody < HTTPError
+
     attr_accessor :body, :original_response
 
     def initialize(body, original_response)
@@ -49,8 +78,8 @@ module Syncano
     alias :to_s :inspect
   end
 
-  class ClientError < HTTPError; end
-  class ServerError < HTTPError; end
+  class ClientError < HTTPErrorWithBody; end
+  class ServerError < HTTPErrorWithBody; end
 
   class UnsupportedStatusError < StandardError
     attr_accessor :original_response
@@ -62,7 +91,5 @@ module Syncano
     def inspect
       "The server returned unsupported status code #{original_response.status}"
     end
-
-    alias :to_s :inspect
   end
 end

data/lib/syncano/api.rb

@@ -1,13 +1,31 @@
 module Syncano
   class API
+
     def initialize(connection)
       self.connection = connection
-      schema = ::Syncano::Schema.new(connection)
-      schema.process!
+
+      self.class.initialize(connection) unless self.class.initialized?
+    end
+
+    class << self
+      def initialize(connection)
+        endpoints = Schema::EndpointsWhitelist.new(Schema.new(connection))
+
+        resources_definitions = Resources.build_definitions(endpoints)
+
+        include Syncano::API::Endpoints.definition(resources_definitions)
+
+        self.initialized = true
+      end
+
+      def initialized?
+        initialized
+      end
     end
 
     private
 
     attr_accessor :connection
+    cattr_accessor :initialized
   end
 end

data/lib/syncano/api/endpoints.rb

@@ -0,0 +1,17 @@
+module Syncano
+  class API
+    module Endpoints
+      def self.definition(resources_definition)
+        Module.new do
+          resources_definition.each do |resource_definition|
+            resource_class = ::Syncano::Resources.define_resource_class(resource_definition)
+
+            define_method(resource_definition.name.tableize) do
+              ::Syncano::QueryBuilder.new(connection, resource_class)
+            end if resource_definition.top_level?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syncano/connection.rb

@@ -6,89 +6,81 @@ module Syncano
     AUTH_PATH = 'account/auth/'
     METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
 
-    def self.api_root
-      ENV['API_ROOT']
+    attr_accessor :api_key
+    attr_accessor :user_key
+
+    class << self
+      def api_root
+        ENV['API_ROOT']
+      end
+    end
+
+    def http_fetcher
+      HttpFetcher.new api_key, user_key
     end
 
     def initialize(options = {})
       self.api_key = options[:api_key]
       self.email = options[:email]
       self.password = options[:password]
-
-      # TODO: take it easy with SSL for development only, temporary solution
-      self.conn = Faraday.new(self.class.api_root, ssl: { verify: false })
-      conn.path_prefix = API_VERSION
-      conn.request :url_encoded
+      self.user_key = options[:user_key]
+      self.conn = Faraday.new(self.class.api_root) do |faraday|
+        faraday.path_prefix = API_VERSION
+        faraday.request :multipart
+        faraday.request  :url_encoded
+        faraday.adapter  Faraday.default_adapter
+      end
     end
 
     def authenticated?
       !api_key.nil?
     end
 
-    def authenticate(email, password)
-      self.email = email
-      self.password = password
-      authenticate!
-    end
-
-    def authenticate!
-      response = conn.post(AUTH_PATH, email: email, password: password)
-      body = parse_response(response)
-
-      case response
-        when Status.successful
-          self.api_key = body['account_key']
-        when Status.client_error
-          raise ClientError.new(body, response)
-      end
+    def authenticate
+      api_key = request(:post, AUTH_PATH,
+                        email: email,
+                        password: password)['account_key']
+      self.api_key = api_key
     end
 
     def request(method, path, params = {})
       raise %{Unsupported method "#{method}"} unless METHODS.include? method
-      conn.headers['X-API-KEY'] = api_key
+
+      conn.headers['X-API-KEY'] = api_key if api_key
+      conn.headers['X-USER-KEY'] = user_key if user_key
       conn.headers['User-Agent'] = "Syncano Ruby Gem #{Syncano::VERSION}"
-      response = conn.send(method, path, params)
-
-      case response
-        when Status.no_content
-        when Status.successful
-          parse_response response
-        when Status.client_error # TODO figure out if we want to raise an exception on not found or not
-          raise ClientError.new(response.body, response)
-        when Status.server_error
-          raise ServerError.new(response.body, response)
-        else
-          raise UnsupportedStatusError.new(response)
-      end
+
+      raw_response = conn.send(method, path, params)
+
+      Syncano::Response.handle ResponseWrapper.new(raw_response)
     end
 
     private
 
-    def parse_response(response)
-      JSON.parse(response.body)
-    end
+    class ResponseWrapper < BasicObject
+      def initialize(response)
+        @response = response
+      end
 
-    class Status
-      class << self
-        def successful
-          ->(response) { (200...300).include? response.status }
-        end
+      def method_missing(name, *args, &block)
+        @response.__send__(name, *args, &block)
+      end
 
-        def client_error
-          ->(response) { (400...500).include? response.status }
-        end
+      def status
+        Status.new @response.status
+      end
 
-        def no_content
-          ->(response) { response.status == 204 }
-        end
+      private
+
+      class Status
+        attr_accessor :code
 
-        def server_error
-          ->(response) { response.status >= 500 }
+        def initialize(code)
+          self.code = code
         end
       end
     end
 
-    attr_accessor :api_key
     attr_accessor :api_root
     attr_accessor :email
     attr_accessor :password