syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/resources/notifications/create.rb

@@ -1,20 +0,0 @@
-class Syncano
-  module Resources
-    module Notifications
-      # Notification resource about creating data object - represents notification with type "new"
-      class Create < Syncano::Resources::Notifications::Base
-
-        # Constructor for Syncano::Notifications::Create object
-        # @param [Syncano::Clients::Base] client
-        # @param [Hash] attributes
-        def initialize(client, attributes)
-          super(client, attributes)
-
-          if attributes.is_a?(::Syncano::Packets::Base)
-            self[:channel] = attributes.channel
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syncano/resources/notifications/destroy.rb

@@ -1,20 +0,0 @@
-class Syncano
-  module Resources
-    module Notifications
-      # Notification resource about destroying data object - represents notification with type "delete"
-      class Destroy < Syncano::Resources::Notifications::Base
-
-        # Constructor for Syncano::Notifications::Create object
-        # @param [Syncano::Clients::Base] client
-        # @param [Hash] attributes
-        def initialize(client, attributes)
-          super(client, attributes)
-
-          if attributes.is_a?(::Syncano::Packets::Base)
-            self[:target] = attributes.target
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syncano/resources/notifications/message.rb

@@ -1,9 +0,0 @@
-class Syncano
-  module Resources
-    module Notifications
-      # Notification resource representing general notifications
-      class Message < Syncano::Resources::Notifications::Base
-      end
-    end
-  end
-end

data/lib/syncano/resources/notifications/update.rb

@@ -1,24 +0,0 @@
-class Syncano
-  module Resources
-    module Notifications
-      # Notification resource about updating data object - represents notification with type "change"
-      class Update < Syncano::Resources::Notifications::Base
-        # Constructor for Syncano::Notifications::Update object
-        # @param [Syncano::Clients::Base] client
-        # @param [Hash] attributes
-        def initialize(client, attributes)
-          super(client, attributes)
-
-          if attributes.is_a?(::Syncano::Packets::Base)
-            self.attributes = {
-              added: attributes.data[:added],
-              updated: attributes.data[:updated],
-              deleted: attributes.data[:deleted],
-              target: attributes.target
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syncano/resources/project.rb

@@ -1,96 +0,0 @@
-class Syncano
-  module Resources
-    # Project resource
-    class Project < ::Syncano::Resources::Base
-      # Association has_many :collections
-      # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::Collection
-      def collections
-        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::Collection, project_id: id)
-      end
-
-      # Wrapper for api "subscription.subscribe_project" method
-      # @return [Syncano::Resource::Project]
-      def subscribe
-        perform_subscribe
-        reload!
-      end
-
-      # Wrapper for api "subscription.unsubscribe_project" method
-      # @return [Syncano::Resource::Project]
-      def unsubscribe
-        perform_unsubscribe
-        reload!
-      end
-
-      # Wrapper for api "authorize" method
-      # @param [Integer] api_client_id
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def authorize(api_client_id, permission)
-        perform_authorize(nil, api_client_id: api_client_id, permission: permission)
-        self
-      end
-
-      # Wrapper for api "authorize" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Integer] api_client_id
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def batch_authorize(batch_client, api_client_id, permission)
-        perform_authorize(batch_client, api_client_id: api_client_id, permission: permission)
-        self
-      end
-
-      # Wrapper for api "deauthorize" method
-      # @param [Integer] api_client_id
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def deauthorize(api_client_id, permission)
-        perform_deauthorize(nil, api_client_id: api_client_id, permission: permission)
-        self
-      end
-
-      # Wrapper for api "deauthorize" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Integer] api_client_id
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def batch_deauthorize(batch_client, api_client_id, permission)
-        perform_deauthorize(batch_client, api_client_id: api_client_id, permission: permission)
-        self
-      end
-
-      private
-
-      # Executes proper subscribe request
-      # @return [Syncano::Response]
-      def perform_subscribe
-        check_if_sync_client!
-        client.make_request(:subscription, :subscribe_project, { project_id: id })
-      end
-
-      # Executes proper unsubscribe request
-      # @return [Syncano::Response]
-      def perform_unsubscribe
-        check_if_sync_client!
-        client.make_request(:subscription, :unsubscribe_project, { project_id: id })
-      end
-
-      # Executes proper authorize request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] parameters
-      # @return [Syncano::Response]
-      def perform_authorize(batch_client, parameters)
-        self.class.make_request(client, batch_client, :authorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
-      end
-
-      # Executes proper deauthorize request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] parameters
-      # @return [Syncano::Response]
-      def perform_deauthorize(batch_client, parameters)
-        self.class.make_request(client, batch_client, :deauthorize, parameters.merge(self.class.primary_key_name.to_sym => primary_key))
-      end
-    end
-  end
-end

data/lib/syncano/resources/role.rb

@@ -1,11 +0,0 @@
-class Syncano
-  module Resources
-    # Role resource
-    class Role < ::Syncano::Resources::Base
-      private
-
-      self.crud_class_methods = [:all]
-      self.crud_instance_methods = []
-    end
-  end
-end

data/lib/syncano/resources/subscription.rb

@@ -1,12 +0,0 @@
-class Syncano
-  module Resources
-    # Subscription resource
-    class Subscription < ::Syncano::Resources::Base
-
-      private
-
-      self.crud_class_methods = [:all]
-      self.crud_instance_methods = []
-    end
-  end
-end

data/lib/syncano/resources/user.rb

@@ -1,65 +0,0 @@
-class Syncano
-  module Resources
-    # User resource
-    class User < ::Syncano::Resources::Base
-      # Wrapper for api "count" method
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Integer]
-      def self.count(client, scope_parameters = {}, conditions = {})
-        response = perform_count(client, scope_parameters, conditions)
-        response.data if response.status
-      end
-
-      # Wrapper for api "login" method
-      # @param [Syncano::Clients::Base] client
-      # @param [String] username
-      # @param [String] password
-      # @return [Integer]
-      def self.login(client, username, password)
-        response = perform_login(client, user_name: username, password: password)
-        response.data
-      end
-
-      private
-
-      self.scope_parameters = [:project_id, :collection_id]
-
-      # Prepares hash with attributes used in synchronization with Syncano
-      # @return [Hash]
-      def self.attributes_to_sync(attributes)
-        attributes = attributes.dup
-
-        if attributes.keys.map(&:to_sym).include?(:avatar)
-          if attributes[:avatar].blank?
-            attributes[:avatar] = ''
-          elsif attributes[:avatar].is_a?(String)
-            attributes[:avatar] = Base64.encode64(File.read(attributes[:avatar]))
-          else
-            attributes.delete(:image)
-          end
-        end
-
-        attributes
-      end
-
-      # Executes proper count request
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Syncano::Response]
-      def self.perform_count(client, scope_parameters, conditions)
-        make_request(client, nil, :count, conditions.merge(scope_parameters))
-      end
-
-      # Executes proper login request
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] parameters
-      # @return [Syncano::Response]
-      def self.perform_login(client, parameters = {})
-        make_request(client, nil, :login, parameters, :auth_key)
-      end
-    end
-  end
-end

data/lib/syncano/response.rb

@@ -1,22 +0,0 @@
-class Syncano
-  # Represents response from Syncano API
-  class Response
-    attr_reader :status, :data, :errors
-
-    # Constructor for Syncano::Response
-    # @param [Boolean] status
-    # @param [Hash] data
-    # @param [Array] errors
-    def initialize(status = false, data = nil, errors = [])
-      super()
-
-      self.status = status
-      self.data   = data
-      self.errors = errors
-    end
-
-    private
-
-    attr_writer :status, :data, :errors
-  end
-end

data/lib/syncano/sync_connection.rb

@@ -1,133 +0,0 @@
-class Syncano
-  # Represents connection with Sync Server
-  class SyncConnection < EventMachine::Connection
-    attr_reader :client
-
-    # Constructor for Syncano::SyncConnection object
-    def initialize
-      super
-
-      self.callbacks = ::ActiveSupport::HashWithIndifferentAccess.new
-      self.callbacks_queue = []
-
-      self.responses = ::ActiveSupport::HashWithIndifferentAccess.new
-      self.responses_queue = []
-
-      self.client = ::Syncano::Clients::Sync.instance
-      self.received_data = ''
-    end
-
-    # Eventmachine callback invoked after completing connection
-    def connection_completed
-      start_tls
-    end
-
-    # Eventmachine callback invoked after completing ssl handshake
-    def ssl_handshake_completed
-      auth_data = {
-        api_key: client.api_key,
-        instance: client.instance_name,
-        'user-agent' => "syncano-ruby-#{Syncano::VERSION}"
-      }
-
-      auth_data[:auth_key] = client.auth_key if client.auth_key.present?
-
-      client.connection = self
-
-      send_data "#{auth_data.to_json}\n"
-    end
-
-    # Eventmachine callback invoked after receiving data from socket
-    # Data are parsed here and processed by callbacks chain
-    def receive_data(data)
-      self.received_data += data
-      process_data if data.end_with?("\n")
-    end
-
-    # Appends callback method to the end of callbacks chain
-    # @param [Symbol, String] callback_name
-    # @param [Block] callback
-    def append_callback(callback_name, callback)
-      callbacks[callback_name] = callback
-      callbacks_queue << callback_name
-    end
-
-    # Prepends callback method to the beginning of callbacks chain
-    # @param [Symbol, String] callback_name
-    # @param [Block] callback
-    def prepend_callback(callback_name, callback)
-      callbacks[callback_name] = callback
-      callbacks_queue.unshift(callback_name)
-    end
-
-    # Removes callback from callbacks chain
-    # @param [Symbol, String] callback_name
-    def remove_callback(callback_name)
-      callbacks.delete(callback_name)
-      callbacks_queue.delete(callback_name)
-    end
-
-    # Gets call response packet from the responses queue
-    # @param [Integer, String] message_id
-    # @return [Syncano::Packets::CallResponse]
-    def get_response(message_id)
-      responses.delete(message_id.to_s)
-    end
-
-    protected
-
-    attr_accessor :received_data
-
-    private
-
-    attr_accessor :client, :callbacks, :callbacks_queue, :responses, :responses_queue
-
-    # Processes data received in the receive_data callback
-    def process_data
-      begin
-        data = ::ActiveSupport::HashWithIndifferentAccess.new(JSON.parse(received_data))
-        packet = ::Syncano::Packets::Base.instantize_packet(data)
-
-        if packet.notification?
-          notification = ::Syncano::Resources::Notifications::Base.instantize_notification(client, packet)
-
-          callbacks_queue.each do |callback_name|
-            callbacks[callback_name].call(notification)
-          end
-        elsif packet.call_response?
-          queue_response(packet)
-        elsif packet.auth?
-          queue_response(packet)
-        end
-
-        self.received_data = ''
-      rescue Exception => e
-        p 'EXCEPTION!'
-        p e.inspect
-      end
-    end
-
-    # Adds call response packet to the responses queue
-    # @param [Syncano::Packets::CallResponse] packet
-    def queue_response(packet)
-      prune_responses_queue
-      message_id = packet.message_id.to_s
-      responses[message_id] = packet
-      responses_queue << message_id.to_s
-    end
-
-    # Removes old call response packets from the responses queue
-    def prune_responses_queue
-      while !responses_queue.empty?
-        message_id = responses_queue.first
-
-        if responses[message_id].nil? || Time.now - responses[message_id].timestamp.to_time > 2.minutes
-          responses_queue.shift
-          responses.delete(message_id)
-        else
-          break
-        end
-      end
-    end
-  end
-end

data/spec/admins_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe 'Syncano::Resource::Admin' do
-  it 'should get admins' do
-    @client.admins.all.each do |admin|
-      admin.id.should_not be_nil
-      admin[:email].should_not be_nil
-    end
-  end
-
-  it 'should get one admin' do
-    admins = @client.admins.all
-
-    @client.admins.find(admins.last.id)[:name].should == admins.last[:name]
-  end
-end