syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/errors.rb

@@ -1,17 +0,0 @@
-class Syncano
-  # General errors
-  class BaseError < RuntimeError
-  end
-
-  # Class represeting errors returned by the Syncano API
-  class ApiError < BaseError
-  end
-
-  # Class representing errors during connections
-  class ConnectionError < BaseError
-  end
-
-  # Class representing timeout errors
-  class TimeoutError < BaseError
-  end
-end

data/lib/syncano/jimson_client.rb

@@ -1,66 +0,0 @@
-# Overwritten module from Jimson gem
-module Jimson
-  # Overwritten helper from Jimson gem
-  class ClientHelper
-    # Overwritten send_single_request method, so it now adds header with the user agent
-    # @return [Array] collection of responses
-    def send_single_request(method, args)
-      post_data = {
-          'jsonrpc' => JSON_RPC_VERSION,
-          'method'  => method,
-          'params'  => args,
-          'id'      => self.class.make_id
-      }.to_json
-      resp = RestClient.post(@url, post_data, content_type: 'application/json', user_agent: "syncano-ruby-#{Syncano::VERSION}")
-      if resp.nil? || resp.body.nil? || resp.body.empty?
-        raise Jimson::ClientError::InvalidResponse.new
-      end
-
-      return resp.body
-
-    rescue Exception, StandardError
-      raise Jimson::ClientError::InternalError.new($!)
-    end
-
-    # Overwritten send_batch_request method, so it now adds header with the user agent
-    # @return [Array] collection of responses
-    def send_batch_request(batch)
-      post_data = batch.to_json
-      resp = RestClient.post(@url, post_data, content_type: 'application/json', user_agent: "syncano-ruby-#{Syncano::VERSION}")
-      if resp.nil? || resp.body.nil? || resp.body.empty?
-        raise Jimson::ClientError::InvalidResponse.new
-      end
-
-      return resp.body
-    end
-
-    # Overwritten send_batch method, so it now returns collection of responses
-    # @return [Array] collection of responses
-    def send_batch
-      batch = @batch.map(&:first) # get the requests
-      response = send_batch_request(batch)
-
-      begin
-        responses = JSON.parse(response)
-      rescue
-        raise Jimson::ClientError::InvalidJSON.new(json)
-      end
-
-      process_batch_response(responses)
-      responses = @batch
-
-      @batch = []
-
-      responses
-    end
-  end
-
-  # Overwritten Request class from Jimson gem
-  class Request
-    # Overwritten as_json method which solves bug with serialization batch requests
-    # @return [Hash]
-    def as_json(options = {})
-      to_h
-    end
-  end
-end

data/lib/syncano/packets/auth.rb

@@ -1,27 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing auth packets used in communication with the Sync Server
-    class Auth < Syncano::Packets::Base
-      attr_reader :message_id, :status, :error
-
-      # Constructor for Syncano::Packets::Auth object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.message_id = 'auth'
-        self.status = attributes[:result]
-        self.error = attributes[:error]
-      end
-
-      # Returns true if is an auth packet
-      # @return [TrueClass, FalseClass]
-      def auth?
-        true
-      end
-
-      private
-
-      attr_writer :message_id, :status, :error
-    end
-  end
-end

data/lib/syncano/packets/base.rb

@@ -1,70 +0,0 @@
-class Syncano
-  # Module used as a scope for classes representing packets
-  module Packets
-    # Base class for representing packets used in communication with the Sync Server
-    class Base
-      attr_reader :object, :timestamp
-
-      # Constructor for Syncano::Packets::Base object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super()
-        self.timestamp = attributes[:timestamp]
-        self.object = attributes[:object]
-      end
-
-      # Proxy method for creating instance of proper subclass
-      # @param [Hash] data
-      # @return [Syncano::Packets::Base]
-      def self.instantize_packet(data)
-        mapping = {
-          auth: ::Syncano::Packets::Auth,
-          call: ::Syncano::Packets::Call,
-          callresponse: ::Syncano::Packets::CallResponse,
-          error: ::Syncano::Packets::Error,
-          message: ::Syncano::Packets::Message,
-          new: ::Syncano::Packets::Notification,
-          change: ::Syncano::Packets::Notification,
-          delete: ::Syncano::Packets::Notification,
-          ping: ::Syncano::Packets::Ping
-        }
-
-        mapping[data[:type].to_sym].new(data)
-      end
-
-      # Returns true if is a notification packet
-      # @return [TrueClass, FalseClass]
-      def notification?
-        false
-      end
-
-      # Returns true if is a ping packet
-      # @return [TrueClass, FalseClass]
-      def ping?
-        false
-      end
-
-      # Returns true if is a call response packet
-      # @return [TrueClass, FalseClass]
-      def call_response?
-        false
-      end
-
-      # Returns true if is a message packet
-      # @return [TrueClass, FalseClass]
-      def message?
-        false
-      end
-
-      # Returns true if is an auth packet
-      # @return [TrueClass, FalseClass]
-      def auth?
-        false
-      end
-
-      private
-
-      attr_writer :object, :timestamp
-    end
-  end
-end

data/lib/syncano/packets/call.rb

@@ -1,34 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing call packets used in communication with the Sync Server
-    class Call < Syncano::Packets::Base
-      attr_reader :message_id, :resource_name, :method_name, :data
-
-      # Constructor for Syncano::Packets::Call object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.resource_name = attributes[:resource_name]
-        self.method_name = attributes[:method_name]
-        self.data = attributes[:data]
-        self.message_id = attributes[:message_id] || rand(10**12)
-      end
-
-      # Overwritten method for preparing hash for json serialization
-      # @param [Hash] options
-      # @return [Hash]
-      def as_json(options = {})
-        {
-          type: 'call',
-          method: "#{resource_name}.#{method_name}",
-          params: data,
-          message_id: message_id.to_s
-        }
-      end
-
-      private
-
-      attr_writer :message_id, :resource_name, :method_name, :data
-    end
-  end
-end

data/lib/syncano/packets/call_response.rb

@@ -1,33 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing call response packets used in communication with the Sync Server
-    class CallResponse < Syncano::Packets::Base
-      attr_reader :message_id, :data, :result
-
-      # Constructor for Syncano::Packets::CallResponse object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.message_id = attributes[:message_id]
-        self.data = attributes[:data]
-        self.result = attributes[:result]
-      end
-
-      # Prepares hash in response format
-      # @return [Hash]
-      def to_response
-        data.merge(result: result)
-      end
-
-      # Returns true if is a call response packet
-      # @return [TrueClass, FalseClass]
-      def call_response?
-        true
-      end
-
-      private
-
-      attr_writer :message_id, :data, :result
-    end
-  end
-end

data/lib/syncano/packets/error.rb

@@ -1,19 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing error packets used in communication with the Sync Server
-    class Error < Syncano::Packets::Base
-      attr_reader :error
-
-      # Constructor for Syncano::Packets::Error object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.error = attributes[:error]
-      end
-
-      private
-
-      attr_writer :error
-    end
-  end
-end

data/lib/syncano/packets/message.rb

@@ -1,30 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing message packets used in communication with the Sync Server
-    class Message < Syncano::Packets::Base
-      attr_accessor :id, :source, :target, :data
-
-      # Constructor for Syncano::Packets::Message object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.id = attributes[:id]
-        self.source = attributes[:source]
-        self.target = attributes[:target]
-        self.data = attributes[:data]
-      end
-
-      # Returns true if is a notification packet
-      # @return [TrueClass, FalseClass]
-      def notification?
-        true
-      end
-
-      # Returns true if is a message packet
-      # @return [TrueClass, FalseClass]
-      def message?
-        true
-      end
-    end
-  end
-end

data/lib/syncano/packets/notification.rb

@@ -1,39 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing notification packets used in communication with the Sync Server
-    class Notification < Syncano::Packets::Base
-      attr_reader :id, :type, :channel, :source, :target, :data
-
-      # Constructor for Syncano::Packets::Notification object
-      # @param [Hash] attributes
-      def initialize(attributes)
-        super(attributes)
-        self.id = attributes[:id]
-        self.type = attributes[:type]
-        self.channel = attributes[:channel]
-        self.source = attributes[:source]
-        self.target = attributes[:target]
-
-        if type == 'change'
-          self.data = {
-            added: attributes[:add],
-            updated: attributes[:replace],
-            deleted: attributes[:delete]
-          }
-        else
-          self.data = attributes[:data]
-        end
-      end
-
-      # Returns true if is a notification packet
-      # @return [TrueClass, FalseClass]
-      def notification?
-        true
-      end
-
-      private
-
-      attr_writer :id, :type, :channel, :source, :target, :data
-    end
-  end
-end

data/lib/syncano/packets/ping.rb

@@ -1,12 +0,0 @@
-class Syncano
-  module Packets
-    # Class representing ping packets used in communication with the Sync Server
-    class Ping < Syncano::Packets::Base
-      # Returns true if is a ping packet
-      # @return [TrueClass, FalseClass]
-      def ping?
-        true
-      end
-    end
-  end
-end

data/lib/syncano/resources/admin.rb

@@ -1,26 +0,0 @@
-class Syncano
-  module Resources
-    # Admin resource
-    class Admin < ::Syncano::Resources::Base
-      # Wrapper for api "get_one" method with admin_email as a key
-      # @param [Syncano::Clients::Base] client
-      # @param [String] email
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Syncano::Resources::Admin]
-      def self.find_by_email(client, email, scope_parameters = {}, conditions = {})
-        perform_find(client, :admin_email, email, scope_parameters, conditions)
-      end
-
-      # Wrapper for api "new" method
-      # Creates object in Syncano
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] attributes
-      # @return [Syncano::Resources::Base]
-      def self.create(client, attributes)
-        perform_create(client, nil, attributes)
-        all(client, map_to_scope_parameters(attributes)).last
-      end
-    end
-  end
-end

data/lib/syncano/resources/api_key.rb

@@ -1,108 +0,0 @@
-class Syncano
-  module Resources
-    # Api key resource
-    class ApiKey < ::Syncano::Resources::Base
-      # Overwritten constructor with initializing associated role object
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] attributes
-      def initialize(client, attributes = {})
-        super(client, attributes)
-        if @attributes[:role].is_a?(Hash)
-          @attributes[:role] = ::Syncano::Resources::Role.new(client, @attributes[:role])
-        end
-
-        if @saved_attributes[:role].is_a?(Hash)
-          @saved_attributes[:role] = ::Syncano::Resources::Role.new(client, @saved_attributes[:role])
-        end
-      end
-
-      # Wrapper for api "authorize" method
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def authorize(permission)
-        perform_authorize(nil, permission: permission)
-        self
-      end
-
-      # Wrapper for api "authorize" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def batch_authorize(batch_client, permission)
-        perform_authorize(batch_client, permission: permission)
-        self
-      end
-
-      # Wrapper for api "deauthorize" method
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def deauthorize(permission)
-        perform_deauthorize(nil, permission: permission)
-        self
-      end
-
-      # Wrapper for api "deauthorize" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String] permission
-      # @return [Syncano::Resources::Base]
-      def batch_deauthorize(batch_client, permission)
-        perform_deauthorize(batch_client, permission: permission)
-        self
-      end
-
-      private
-
-      # Prepares attributes to synchronizing with Syncano
-      # @param [Hash] attributes
-      # @return [Hash] prepared attributes
-      def self.attributes_to_sync(attributes)
-        attributes = attributes.dup
-        attributes.delete(:role)
-
-        attributes
-      end
-
-      # Name of attribute used as primary key
-      # @return [Symbol]
-      def self.primary_key_name
-        :api_client_id
-      end
-
-      # Executes proper find request
-      # @param [Syncano::Clients::Base] client
-      # @param [Symbol, String] key_name
-      # @param [Integer, String] key
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Syncano::Response]
-      def self.perform_find(client, key_name, key, scope_parameters, conditions)
-        key_parameters = key.present? ? { key_name.to_sym => key } : {}
-        make_request(client, nil, :find, conditions.merge(scope_parameters.merge(key_parameters)))
-      end
-
-      # Executes proper update request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] attributes
-      # @return [Syncano::Response]
-      def perform_update(batch_client, attributes)
-        self.class.make_request(client, batch_client, :update_description, self.class.attributes_to_sync(attributes).merge(self.class.primary_key_name.to_sym => primary_key))
-      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