syncano 4.0.0.alpha4 → 4.0.0.pre

data/lib/syncano/model/scope_builder.rb

@@ -0,0 +1,158 @@
+module Syncano
+  module Model
+    # ScopeBuilder class allows for creating and chaining more complex queries
+    class ScopeBuilder
+      # Constructor for ScopeBuilder
+      # @param [Class] model
+      def initialize(model)
+        raise 'Model should be a class extending module Syncano::Model::Base' unless model <= Syncano::Model::Base
+
+        self.model = model
+        self.query = HashWithIndifferentAccess.new
+      end
+
+      # Returns collection of objects
+      # @return [Array]
+      def all
+        model.syncano_class.objects.all(parameters).collect do |data_object|
+          model.new(data_object)
+        end
+      end
+
+      # Returns one object found by id
+      # @param [Integer] id
+      # @return [Object]
+      def find(id)
+        data_object = model.syncano_class.objects.find(id)
+        data_object.present? ? model.new(data_object) : nil
+      end
+
+      # Returns first object or collection of first x objects
+      # @param [Integer] amount
+      # @return [Object, Array]
+      def first(amount = nil)
+        objects = all.first(amount || 1)
+        amount.nil? ? objects.first : objects
+      end
+
+      # Returns last object or last x objects
+      # @param [Integer] amount
+      # @return [Object, Array]
+      def last(amount)
+        objects = all.last(amount || 1)
+        amount.nil? ? objects.first : objects
+      end
+
+      # Adds to the current scope builder condition to the scope builder
+      # @param [String] condition
+      # @param [Array] params
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def where(conditions, *params)
+        raise 'Invalid params count in where clause!' unless conditions.count('?') == params.count
+
+        params = params.dup
+
+        conditions.gsub(/\s+/, ' ').split(/and/i).each do |condition|
+          if condition.ends_with?('?')
+            value = params.shift
+            condition.gsub!('?', '').strip!
+          else
+            value = true
+          end
+
+          attribute, operator = condition.split(' ', 2)
+          operator.upcase!
+
+          raise 'Invalid attribute in where clause!' unless model.attributes.keys.include?(attribute)
+          raise 'Invalid operator in where clause!' unless self.class.where_mapping.keys.include?(operator)
+
+          operator = self.class.where_mapping[operator]
+
+          query[attribute] = HashWithIndifferentAccess.new if query[attribute].nil?
+          query[attribute][operator] = value
+        end
+
+        self
+      end
+
+      # Adds to the current scope builder order clause
+      # @param [String] order
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def order(order)
+        if order.is_a?(Hash)
+          attribute = order.keys.first
+          order_type = order[attribute]
+        else
+          attribute, order_type = order.gsub(/\s+/, ' ').split(' ')
+        end
+
+        raise 'Invalid attribute in order clause' unless (model.attributes.keys).include?(attribute)
+
+        self.order_clause = order_type.to_s.downcase == 'desc' ? "-#{attribute}" : attribute
+
+        self
+      end
+
+      # # Adds to the current scope builder limit clause
+      # # @param [Integer] amount
+      # # @return [Syncano::ActiveRecord::ScopeBuilder]
+      # def limit(amount)
+      #   self.parameters[:limit] = amount
+      #   self
+      # end
+      #
+      private
+
+      attr_accessor :order_clause, :query, :model, :scopes
+
+      # Returns Syncano::Resource class for current model
+      # @return [Syncano::Resources::Folder]
+      def syncano_class
+        model.syncano_class
+      end
+
+      # Returns scopes for current model
+      # @return [HashWithIndifferentAccess]
+      def scopes
+        model.scopes
+      end
+
+      def parameters
+        params = {}
+
+        params[:order_by] = order_clause if order_clause.present?
+        params[:query] = query.to_json if query.present?
+
+        params
+      end
+
+      # Returns mapping for operators
+      # @return [Hash]
+      def self.where_mapping
+        { '=' => '_eq', '!=' => '_neq', '<>' => '_neq', '>=' => '_gte', '>' => '_gt',
+          '<=' => '_lte', '<' => '_lt', 'IS NOT NULL' => '_exists', 'IN' => '_in' }
+      end
+
+      # Applies scope to the current scope builder
+      # @param [Symbol] name
+      # @param [Array] args
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def execute_scope(name, *args)
+        procedure = scopes[name]
+        instance_exec(*args, &procedure)
+        self
+      end
+
+      # Overwritten method_missing for handling calling defined scopes
+      # @param [String] name
+      # @param [Array] args
+      def method_missing(name, *args)
+        if scopes[name].nil?
+          super
+        else
+          execute_scope(name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/syncano/query_builder.rb

@@ -6,17 +6,17 @@ module Syncano
       self.scope_parameters = scope_parameters
     end
 
-    def all(query_params = {})
-      query_params[:query] = query_params[:query].to_json if query_params[:query].try(:any?)
-      resource_class.all(connection, scope_parameters, query_params)
+    def all(filter_attributes = {})
+      filter_attributes[:query] = filter_attributes[:query].to_json if filter_attributes[:query].try(:any?)
+      resource_class.all(connection, scope_parameters, filter_attributes)
     end
 
-    def first(query_params = {})
-      resource_class.first(connection, scope_parameters, query_params)
+    def first
+      resource_class.first(connection, scope_parameters)
     end
 
-    def last(query_params = {})
-      resource_class.last(connection, scope_parameters, query_params)
+    def last
+      resource_class.last(connection, scope_parameters)
     end
 
     def find(key = nil)
@@ -31,10 +31,6 @@ module Syncano
       resource_class.create(connection, scope_parameters, attributes)
     end
 
-    def destroy(primary_key)
-      resource_class.destroy connection, scope_parameters, primary_key
-    end
-
     def space(at, options = {})
       Syncano::Resources::Space.new(at, self, options)
     end

data/lib/syncano/resources/base.rb

@@ -2,25 +2,25 @@ module Syncano
   module Resources
     class Base
       include ActiveAttr::Model
-      include ActiveModel::Dirty
+      include ActiveAttr::Dirty
 
       PARAMETER_REGEXP = /\{([^}]+)\}/
 
       class << self
-        def all(connection, scope_parameters, query_params = {})
+        def all(connection, scope_parameters, filter_attributes = {})
           check_resource_method_existance!(:index)
 
-          response = connection.request(:get, collection_path(scope_parameters), query_params)
+          response = connection.request(:get, collection_path(scope_parameters), filter_attributes)
           scope = Syncano::Scope.new(connection, scope_parameters)
           Syncano::Resources::Collection.from_database(response, scope, self)
         end
 
-        def first(connection, scope_parameters, query_params = {})
-          all(connection, scope_parameters, query_params).first
+        def first(connection, scope_parameters)
+          all(connection, scope_parameters).first
         end
 
-        def last(connection, scope_parameters, query_params = {})
-          all(connection, scope_parameters, query_params).last
+        def last(connection, scope_parameters)
+          all(connection, scope_parameters).last
         end
 
         def find(connection, scope_parameters, pk)
@@ -34,21 +34,7 @@ module Syncano
         def create(connection, scope_parameters, attributes)
           check_resource_method_existance!(:create)
 
-          record = new(connection, scope_parameters, attributes)
-          record.save
-          record
-        end
-
-        def create!(connection, scope_parameters, attribues)
-          check_resource_method_existance!(:create)
-
-          new(connection, scope_parameters, attributes).save!
-        end
-
-        def destroy(connection, scope_parameters, pk)
-          check_resource_method_existance! :destroy
-
-          connection.request :delete, member_path(pk, scope_parameters)
+          new(connection, scope_parameters, attributes).save
         end
 
         def map_attributes_values(attributes)
@@ -103,7 +89,7 @@ module Syncano
       end
 
       def new_record?
-        new_record
+        primary_key.blank?
       end
 
       def saved?
@@ -119,31 +105,21 @@ module Syncano
       end
 
       def save
-        return false unless valid?
-
-        commit_save
-      end
-
-      def save!
-        raise Syncano::Resources::ResourceInvalid.new(self) unless valid?
-
-        commit_save
-      end
+        # TODO: Call validation here
+        apply_forced_defaults!
 
-      def commit_save
         if new_record?
           response = connection.request(:post, collection_path, select_create_attributes)
         else
-          response = connection.request(:patch, self_path, select_changed_attributes)
+          response = connection.request(:patch, member_path, select_update_attributes)
         end
 
         initialize!(response, true)
-
       end
 
       def destroy
         check_resource_method_existance!(:destroy)
-        connection.request(:delete, self_path)
+        connection.request(:delete, member_path)
         mark_as_destroyed!
       end
 
@@ -154,65 +130,31 @@ module Syncano
       def reload!
         raise(Syncano::Error.new('record is not saved')) if new_record?
 
-        response = connection.request(:get, self_path)
+        response = connection.request(:get, member_path)
         initialize!(response)
       end
 
-      def attribute_definitions
-        self.class.resource_definition.attributes
-      end
-
-      def attribute_definitions_map
-        Hash[ attribute_definitions.map { |attr| [attr.name, attr] } ]
-      end
-
       def select_create_attributes
-        attributes = self.attributes.select { |name, _|
-          begin
-            attribute_definitions_map[name].writable?
-          rescue NoMethodError
-            if custom_attributes.has_key?(name)
-              true
-            else
-              raise
-            end
-          end
-        }
-        attributes = custom_attributes.merge(attributes) if respond_to?(:custom_attributes)
+        attributes = self.attributes.select { |name, _value| self.class.create_writable_attributes.include?(name.to_sym) }
+        attributes.merge!(custom_attributes) if respond_to?(:custom_attributes) && custom_attributes.is_a?(Hash)
         self.class.map_attributes_values(attributes)
       end
 
       def select_update_attributes
-        attributes = updatable_attributes
-        attributes = custom_attributes.merge(attributes) if respond_to?(:custom_attributes)
+        attributes = self.attributes.select{ |name, _value| self.class.update_writable_attributes.include?(name.to_sym) }
+        attributes.merge!(custom_attributes) if respond_to?(:custom_attributes) && custom_attributes.is_a?(Hash)
         self.class.map_attributes_values(attributes)
       end
 
-      def select_changed_attributes
-        updatable_attributes
-      end
-
-      def updatable_attributes
-        attributes = self.attributes.select do |name, _value|
-          self.class.update_writable_attributes.include?(name.to_sym)
-        end
-        self.class.map_attributes_values attributes
-      end
-
       private
 
-      class_attribute :resource_definition, :create_writable_attributes,
-                      :update_writable_attributes
-      attr_accessor :connection, :association_paths, :member_path,
-                    :scope_parameters, :destroyed, :self_path, :new_record
+      class_attribute :resource_definition, :create_writable_attributes, :update_writable_attributes
+      attr_accessor :connection, :association_paths, :member_path, :scope_parameters, :destroyed
 
       def initialize!(attributes = {}, from_database = false)
         attributes = HashWithIndifferentAccess.new(attributes)
 
-        self.member_path = attributes[:links].try(:[], :self)
-        self.self_path = attributes[:links].try(:[], :self)
-        self.new_record = !from_database # TODO use from_database of self_path.nil?
-
+        initialize_routing(attributes)
         initialize_associations(attributes)
 
         self.attributes.clear
@@ -239,8 +181,37 @@ module Syncano
         end
       end
 
-      def map_collection_name_to_resource_class(name)
-        ::Syncano::Resources::Paths.instance.collections.match(association_paths[name])
+      def initialize_routing(attributes)
+        self.member_path = attributes[:links].try(:[], :self)
+      end
+
+      def self.map_member_name_to_resource_class(name)
+        name = 'code_box' if name == 'codebox'
+        "::Syncano::Resources::#{name.camelize}".constantize
+      end
+
+      def self.map_collection_name_to_resource_class(name)
+        name = case name
+                 when 'codeboxes'
+                   'code_boxes'
+                 when 'traces'
+                   case self.name
+                     when 'Syncano::Resources::CodeBox'
+                       'code_box_traces'
+                   end
+                 else
+                   name
+               end
+
+        map_member_name_to_resource_class(name.singularize)
+      end
+
+      def apply_forced_defaults!
+        self.class.attributes.each do |attr_name, attr_definition|
+          if read_attribute(attr_name).blank? && attr_definition[:force_default]
+            write_attribute(attr_name, attr_definition[:default].is_a?(Proc) ? attr_definition[:default].call : attr_definition[:default])
+          end
+        end
       end
 
       def mark_as_saved!
@@ -259,26 +230,26 @@ module Syncano
         # TODO Implement QueryBuilders without scope parameters and adding objects to the association
         raise(Syncano::Error.new('record not saved')) if new_record?
 
-        resource_class = map_collection_name_to_resource_class(name)
+        resource_class = self.class.map_collection_name_to_resource_class(name)
         scope_parameters = resource_class.extract_scope_parameters(association_paths[name])
 
         ::Syncano::QueryBuilder.new(connection, resource_class, scope_parameters)
       end
 
+      def belongs_to_association(name)
+        resource_class = self.class.map_member_name_to_resource_class(name)
+        scope_parameters = resource_class.extract_scope_parameters(association_paths[name])
+        pk = resource_class.extract_primary_key(association_paths[name])
+
+        ::Syncano::QueryBuilder.new(connection, resource_class, scope_parameters).find(pk)
+      end
+
       def custom_method(method_name, config)
         connection.request self.class.custom_method_http_method(method_name),
                            self.class.custom_method_path(method_name, primary_key, scope_parameters),
                            config
       end
 
-      def async_method(method_name, params)
-        poller = Poller.new(connection,
-                   self.class.custom_method_http_method(method_name),
-                   self.class.custom_method_path(method_name, primary_key, scope_parameters))
-        poller.async.poll
-        poller
-      end
-
       def self.custom_method_http_method(method_name)
         custom_method_definition(method_name)[:http_methods].first.to_sym
       end
@@ -359,6 +330,10 @@ module Syncano
         self.class.collection_path(scope_parameters)
       end
 
+      def member_path
+        self.class.member_path(primary_key, scope_parameters)
+      end
+
       def check_resource_method_existance!(method_name)
         self.class.check_resource_method_existance!(method_name)
       end
@@ -367,7 +342,7 @@ module Syncano
         index: { type: :collection, method: :get },
         create: { type: :collection, method: :post },
         show: { type: :member, method: :get },
-        update: { type: :member, method: :patch },
+        update: { type: :member, method: :put },
         destroy: { type: :member, method: :delete }
       }.each do |name, parameters|