syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/resources/collection.rb

@@ -1,240 +1,36 @@
-class Syncano
+module Syncano
   module Resources
-    # Collection resource
-    class Collection < ::Syncano::Resources::Base
-      # Association has_many :folders
-      # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::Folder
-      def folders
-        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::Folder, scope_parameters.merge(collection_id: id))
-      end
-
-      # Association has_many :data_objects
-      # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::DataObject
-      def data_objects
-        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::DataObject, scope_parameters.merge(collection_id: id))
-      end
-
-      # Association has_many :users
-      # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::User
-      def users
-        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::User, scope_parameters.merge(collection_id: id))
-      end
-
-      # Wrapper for api "get_one" method with collection_key as a key
-      # @param [Syncano::Clients::Base] client
-      # @param [String] key
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Syncano::Resources::Collection]
-      def self.find_by_key(client, key, scope_parameters = {}, conditions = {})
-        perform_find(client, :key, key, scope_parameters, conditions)
-      end
-
-      # Wrapper for api "activate" method
-      # @param [TrueClass, FalseClass] force
-      # @return [Syncano::Resources::Collection]
-      def activate(force = false)
-        response = perform_activate(nil, force)
-        reload! if response.status
-
-        self
-      end
-
-      # Batch version of "activate" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [TrueClass, FalseClass] force
-      # @return [Syncano::Response]
-      def batch_activate(batch_client, force = false)
-        perform_activate(batch_client, force)
-      end
-
-      # Wrapper for api "deactivate" method
-      # @return [Syncano::Resources::Collection]
-      def deactivate
-        response = perform_deactivate(nil)
-        reload! if response.status
-
-        self
-      end
-
-      # Batch version of "deactivate" method
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def batch_deactivate(batch_client)
-        perform_deactivate(batch_client)
-      end
-
-      # Wrapper for api "add_tag" method
-      # @param [String, Array] tags
-      # @param [Numeric] weight
-      # @param [TrueClass, FalseClass] remove_other
-      # @return [Syncano::Resources::Collection]
-      def add_tag(tags, weight = 1, remove_other = false)
-        response = perform_add_tag(nil, tags, weight, remove_other)
-        reload! if response.status
-
-        self
-      end
-
-      # Batch version of "add_tags" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String, Array] tags
-      # @param [Numeric] weight
-      # @param [TrueClass, FalseClass] remove_other
-      # @return [Syncano::Response]
-      def batch_add_tags(batch_client, tags, weight = 1, remove_other = false)
-        perform_add_tag(batch_client, tags, weight, remove_other)
-      end
+    class Collection
+      include Enumerable
 
-      # Wrapper for api "delete_tag" method
-      # @param [String, Array] tags
-      # @return [Syncano::Resources::Collection]
-      def delete_tags(tags)
-        response = perform_delete_tag(nil, tags)
-        reload! if response.status
+      delegate :last, :[], to: :collection
 
-        self
+      def self.from_database(response, scope, element_class)
+        new response, scope, element_class, true
       end
 
-      # Batch version of "delete_tag" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String, Array] tags
-      # @return [Syncano::Response]
-      def batch_delete_tag(batch_client, tags)
-        perform_delete_tag(batch_client, tags)
+      def each(&block)
+        collection.each &block
       end
 
-      # Wrapper for api "subscription.subscribe_collection" method
-      # @return [Syncano::Resource::Collection]
-      def subscribe
-        perform_subscribe
-        reload!
+      def prev?
+        @prev
       end
 
-      # Wrapper for api "subscription.unsubscribe_collection" method
-      # @return [Syncano::Resource::Collection]
-      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
+      def next?
+        @next
       end
 
       private
 
-      self.scope_parameters = [:project_id]
-
-      # Executes proper activate request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [TrueClass, FalseClass] force
-      # @return [Syncano::Response]
-      def perform_activate(batch_client, force)
-        self.class.make_request(client, batch_client, :activate, scope_parameters.merge(
-          self.class.primary_key_name => primary_key,
-          force: force
-        ))
-      end
-
-      # Executes proper deactivate request
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def perform_deactivate(batch_client)
-        self.class.make_request(client, batch_client, :deactivate, scope_parameters.merge(
-          self.class.primary_key_name => primary_key
-        ))
-      end
-
-      # Executes proper add_tags request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String, Array] tags
-      # @param [Numeric] weight
-      # @param [TrueClass, FalseClass] remove_other
-      # @return [Syncano::Response]
-      def perform_add_tags(batch_client, tags, weight, remove_other)
-        self.class.make_request(client, batch_client, :add_tag, scope_parameters.merge(
-          self.class.primary_key_name => primary_key,
-          tags: tags,
-          weight: weight,
-          remove_other: remove_other
-        ))
-      end
-
-      # Executes proper delete_tags request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String, Array] tags
-      # @return [Syncano::Response]
-      def perform_delete_tags(batch_client, tags)
-        self.class.make_request(client, batch_client, :delete_tag, scope_parameters.merge(
-          self.class.primary_key_name => primary_key,
-          tags: tags
-        ))
-      end
-
-      # Executes proper subscribe request
-      # @return [Syncano::Response]
-      def perform_subscribe
-        check_if_sync_client!
-        client.make_request(:subscription, :subscribe_collection, scope_parameters.merge(collection_id: id))
-      end
-
-      # Executes proper unsubscribe request
-      # @return [Syncano::Response]
-      def perform_unsubscribe
-        check_if_sync_client!
-        client.make_request(:subscription, :unsubscribe_collection, scope_parameters.merge(collection_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, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
-      end
+      attr_accessor :collection
 
-      # 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, scope_parameters.merge(parameters.merge(self.class.primary_key_name.to_sym => primary_key)))
+      def initialize(response, scope, element_class, from_database)
+        @prev, @next = response['prev'].present?, response['next'].present?
+        self.collection = response['objects'].map do |attributes|
+          element_class.new scope.connection, scope.scope_parameters, attributes, from_database
+        end
       end
     end
   end
-end
+end

data/lib/syncano/resources/space.rb

@@ -0,0 +1,29 @@
+module Syncano
+  module Resources
+    class Space
+
+      DEFAULT_DIRECTION = :next
+      DIRECTIONS = { DEFAULT_DIRECTION => 1, :prev => 0 }
+      DIRECTIONS.default_proc = ->(hash, key) do
+        if key.nil?
+          hash[DEFAULT_DIRECTION]
+        else
+          raise Syncano::RuntimeError.new("Valid orders are #{hash.keys}, you passed #{key.inspect}")
+        end
+      end
+      DIRECTIONS.freeze
+
+      attr_accessor :at, :query_builder, :direction
+
+      def initialize(at, query_builder, options = {})
+        self.at = at
+        self.query_builder = query_builder
+        self.direction = DIRECTIONS[options[:direction]]
+      end
+
+      def all
+        query_builder.all last_pk: at.primary_key, direction: direction
+      end
+    end
+  end
+end

data/lib/syncano/schema.rb

@@ -0,0 +1,86 @@
+require_relative './schema/attribute_definition'
+require_relative './schema/resource_definition'
+
+module Syncano
+  class Schema
+    SCHEMA_PATH = 'schema/'
+
+    attr_reader :schema
+
+    def initialize(connection)
+      self.connection = connection
+      load_schema
+    end
+
+    def process!
+      schema.each do |name, raw_resource_definition|
+        resource_definition = Syncano::Schema::ResourceDefinition.new(name, raw_resource_definition)
+        resource_class = ::Syncano::Resources.define_resource_class(resource_definition)
+
+        if resource_definition[:collection].present? && resource_definition[:collection][:path].scan(/\{([^}]+)\}/).empty?
+          self.class.generate_client_method(name, resource_class)
+        end
+      end
+    end
+
+    private
+
+    attr_accessor :connection
+    attr_writer :schema
+
+    def load_schema
+      raw_schema = connection.request(:get, SCHEMA_PATH)
+      resources = {}
+
+      raw_schema.each do |resource_schema|
+        class_name = resource_schema['name']
+
+        resources[class_name] = {
+            attributes: {},
+            associations: {},
+            collection: nil,
+            member: nil,
+            custom_methods: []
+        }
+
+        fields = resource_schema['endpoints']['list'].try(:[], 'fields') || {}
+
+        resources[class_name][:attributes].merge! fields
+
+        if fields['links']
+          resources[class_name][:attributes].delete('links')
+          resources[class_name][:associations].merge!(fields['links'])
+        end
+
+        resource_schema['endpoints'].each do |type, endpoint|
+          endpoint_data = {
+              path: endpoint['path'],
+              http_methods: endpoint['methods'],
+              params: endpoint['properties']
+          }
+
+          if type == 'list'
+            resources[class_name][:collection] = endpoint_data
+          elsif type == 'detail'
+            resources[class_name][:member] = endpoint_data
+          else
+            endpoint_data.merge!(name: type)
+            resources[class_name][:custom_methods] << endpoint_data
+          end
+        end
+      end
+
+      self.schema = resources
+    end
+
+    class << self
+      def generate_client_method(resource_name, resource_class)
+        method_name = resource_name.tableize
+
+        ::Syncano::API.send(:define_method, method_name) do
+          ::Syncano::QueryBuilder.new(connection, resource_class)
+        end
+      end
+    end
+  end
+end

data/lib/syncano/schema/attribute_definition.rb

@@ -0,0 +1,83 @@
+module Syncano
+  class Schema
+    class AttributeDefinition
+      attr_accessor :name, :type, :default
+
+      TYPES_MAPPING = { 'string' => ::String,
+                        'email' => ::String,
+                        'choice' => ::String,
+                        'slug' => ::String,
+                        'integer' => ::Integer,
+                        'float' => ::Float,
+                        'date' => ::Date,
+                        'datetime' => ::DateTime,
+                        'field' => ::Object }
+
+      def initialize(name, raw_definition)
+        # TODO implement #original_name to send request with correct parameters
+        self.name = name == 'class' ? 'associated_class' : name
+        self.raw_definition = raw_definition
+
+        set_type
+        set_default
+      end
+
+      def force_default?
+        !default.nil?
+      end
+
+      def writable?
+        raw_definition['read_only'] == false
+      end
+
+      def required?
+        raw_definition['required'] == true
+      end
+
+      def required_length
+        begin
+          { maximum: Integer(raw_definition['max_length']) }
+        rescue TypeError, ArgumentError
+        end
+      end
+
+      def required_values_inclusion
+        return unless choices = raw_definition['choices']
+
+        { in: choices.map { |choice| choice['value'] } }
+      end
+
+      alias :updatable? :writable?
+
+      def [](key)
+        raw_definition[key]
+      end
+
+      private
+
+      attr_accessor :raw_definition
+
+      def set_type
+        self.type = if %w[owner group].include?(name)
+                      ::Integer
+                    elsif raw_definition['type'].blank?
+                      ::Object
+                    else
+                      TYPES_MAPPING[raw_definition['type']]
+                    end
+      end
+
+      def set_default
+        self.default = if name == 'channel'
+                         nil
+                       elsif raw_definition['type'].present? && raw_definition['type'].to_sym == :field
+                         {}
+                       elsif raw_definition['type'].present? && raw_definition['type'].to_sym == :choice
+                          raw_definition['choices'].first['value']
+                       else
+                         nil
+                       end
+      end
+    end
+  end
+end