syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/query_builder.rb

@@ -1,152 +1,42 @@
-class Syncano
-  # Proxy class for creating proper requests to api through ActiveRecord pattern
+module Syncano
   class QueryBuilder
-    # Constructor for Syncano::QueryBuilder object
-    # @param [Syncano::Clients::Base] client
-    # @param [String] resource_class
-    # @param [Hash] scope_parameters
-    def initialize(client, resource_class, scope_parameters = {})
-      self.client = client
+    def initialize(connection, resource_class, scope_parameters = {})
+      self.connection = connection
       self.resource_class = resource_class
       self.scope_parameters = scope_parameters
     end
 
-    # Proxy for preparing batch requests
-    # ie. query_builder.batch.create will prepare BatchQueueElement
-    # which invokes batch_create method on query builder object
-    # @return [Syncano::BatchQueueElement]
-    def batch
-      ::Syncano::BatchQueueElement.new(self)
+    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)
     end
 
-    # Proxy for calling "all" method on the resource object
-    # @param [Hash] conditions
-    # @return [Array] collection of Syncano::Resources::Base objects
-    def all(conditions = {})
-      resource_class.all(client, conditions.merge(scope_parameters))
+    def first(query_params = {})
+      resource_class.first(connection, scope_parameters, query_params)
     end
 
-    # Proxy for calling "count" method on the resource object
-    # @param [Hash] conditions
-    # @return [Integer]
-    def count(conditions = {})
-      resource_class.count(client, conditions.merge(scope_parameters))
+    def last(query_params = {})
+      resource_class.last(connection, scope_parameters, query_params)
     end
 
-    # Returns first element from all returned by "all" method
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def first(conditions = {})
-      all(conditions).first
+    def find(key = nil)
+      resource_class.find(connection, scope_parameters, key)
     end
 
-    # Returns last element from all returned by "all" method
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def last(conditions = {})
-      all(conditions).last
-    end
-
-    # Proxy for calling "find" method on the resource object
-    # @param [Integer, String] key
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def find(key = nil, conditions = {})
-      resource_class.find(client, key, scope_parameters, conditions)
-    end
-
-    # Proxy for calling "find_by_key" method on the resource object
-    # @param [String] key
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def find_by_key(key, conditions = {})
-      resource_class.find_by_key(client, key, scope_parameters, conditions)
-    end
-
-    # Proxy for calling "find_by_name" method on the resource object
-    # @param [String] name
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def find_by_name(name, conditions = {})
-      resource_class.find_by_name(client, name, scope_parameters, conditions)
-    end
-
-    # Proxy for calling "find_by_email" method on the resource object
-    # @param [String] email
-    # @param [Hash] conditions
-    # @return [Syncano::Resources::Base]
-    def find_by_email(email, conditions = {})
-      resource_class.find_by_email(client, email, scope_parameters, conditions)
-    end
-
-    # Proxy for calling "new" method on the resource object
-    # @param [Hash] attributes
-    # @return [Syncano::Resources::Base]
     def new(attributes = {})
-      resource_class.new(client, attributes.merge(scope_parameters))
-    end
-
-    # Proxy for calling "create" method on the resource object
-    # @param [Hash] attributes
-    # @return [Syncano::Resources::Base]
-    def create(attributes)
-      resource_class.create(client, attributes.merge(scope_parameters))
-    end
-
-    # Proxy for calling "batch_create" method on the resource object
-    # @param [Jimson::Client] batch_client
-    # @param [Hash] attributes
-    # @return [Syncano::Response]
-    def batch_create(batch_client, attributes)
-      resource_class.batch_create(batch_client, client, attributes.merge(scope_parameters))
-    end
-
-    # Proxy for calling "copy" method on the resource object
-    # @param [Array] ids
-    # @return [Array] collection of Syncano::Resource objects
-    def copy(ids)
-      resource_class.copy(client, scope_parameters, ids)
-    end
-
-    # Proxy for calling "batch_copy" method on the resource object
-    # @param [Jimson::Client] batch_client
-    # @param [Array] ids
-    # @return [Syncano::Response]
-    def batch_copy(batch_client, ids)
-      resource_class.batch_copy(batch_client, scope_parameters, ids)
-    end
-
-    # Proxy for calling "move" method on the resource object
-    # @param [Array] ids
-    # @param [Hash] conditions
-    # @param [String] new_folder
-    # @param [String] new_state
-    # @return [Array] collection of Syncano::Resource objects
-    def move(ids, conditions = {}, new_folder = nil, new_state = nil)
-      resource_class.move(client, scope_parameters, ids, conditions, new_folder, new_state)
+      resource_class.new(connection, scope_parameters, attributes)
     end
 
-    # Proxy for calling "batch_move" method on the resource object
-    # @param [Jimson::Client] batch_client
-    # @param [Array] ids
-    # @param [Hash] conditions
-    # @param [String] new_folder
-    # @param [String] new_state
-    # @return [Syncano::Response]
-    def batch_move(batch_client, ids, conditions = {}, new_folder = nil, new_state = nil)
-      resource_class.batch_move(batch_client, scope_parameters, ids, conditions, new_folder, new_state)
+    def create(attributes = {})
+      resource_class.create(connection, scope_parameters, attributes)
     end
 
-    # Proxy for calling "login" method on the resource object
-    # @param [String] username
-    # @param [String] password
-    # @return [Array] collection of Syncano::Resource objects
-    def login(username = nil, password = nil)
-      resource_class.login(client, username, password)
+    def space(at, options = {})
+      Syncano::Resources::Space.new(at, self, options)
     end
 
     private
 
-    attr_accessor :client, :resource_class, :scope_parameters
+    attr_accessor :connection, :resource_class, :scope_parameters
   end
-end
+end

data/lib/syncano/resources.rb

@@ -0,0 +1,126 @@
+require 'dirty_hashy'
+
+module Syncano
+  module Resources
+    class << self
+      def define_resource_class(resource_definition)
+        const_set resource_definition.name, new_resource_class(resource_definition)
+      end
+
+      def new_resource_class(definition)
+        attributes_definitions = definition.attributes
+
+        ::Class.new(::Syncano::Resources::Base) do
+          self.create_writable_attributes = []
+          self.update_writable_attributes = []
+
+          attributes_definitions.each do |attribute_definition|
+            attribute attribute_definition.name,
+                      type: attribute_definition.type,
+                      default: attribute_definition.default,
+                      force_default: attribute_definition.force_default?
+
+            if attribute_definition.required?
+              validates attribute_definition.name, presence: true
+            end
+
+            validates attribute_definition.name, length: attribute_definition.required_length
+
+            if inclusion = attribute_definition.required_values_inclusion
+              validates attribute_definition.name, inclusion: inclusion
+            end
+
+            self.create_writable_attributes << attribute_definition.name.to_sym if attribute_definition.writable?
+            self.update_writable_attributes << attribute_definition.name.to_sym if attribute_definition.updatable?
+          end
+
+
+          if definition.name == 'Object' #TODO: extract to a separate module + spec
+            def save(options = {})
+              options.assert_valid_keys :overwrite
+              overwrite = options[:overwrite] == true
+
+              if new_record? || !overwrite
+                super()
+              else
+                response = connection.request(:post, member_path, attributes)
+                initialize! response, true
+              end
+            end
+
+            def initialize!(_attributes = {}, _from_database = false)
+              to_return = super
+
+              custom_attributes.clean_up!
+
+              to_return
+            end
+
+            def select_changed_attributes
+              custom_attributes.changes.inject(super) do |changed, (key, (_was, is))|
+                changed[key] = is
+                changed
+              end
+            end
+
+            def attributes=(new_attributes)
+              super
+
+              self.custom_attributes = new_attributes.select { |k, v| !self.class.attributes.keys.include?(k) }
+            end
+
+            def attributes
+              super.merge custom_attributes
+            end
+
+            def changed
+              super + custom_attributes.changes.keys
+            end
+
+            def custom_attributes
+              @custom_attributes ||= DirtyHashy.new
+            end
+
+            def custom_attributes=(value)
+              @custom_attributes = value.is_a?(DirtyHashy) ?
+                value : DirtyHashy.new(value)
+            end
+
+            def method_missing(method_name, *args, &block)
+              if method_name.to_s =~ /=$/
+                custom_attributes[method_name.to_s.gsub(/=$/, '')] = args.first
+              else
+                if custom_attributes.has_key? method_name.to_s
+                  custom_attributes[method_name.to_s]
+                else
+                  super
+                end
+              end
+            end
+          end
+
+          (definition[:associations]['links'] || []).each do |association_schema|
+            if association_schema['type'] == 'list'
+              define_method(association_schema['name']) do
+                has_many_association(association_schema['name'])
+              end
+            elsif association_schema['type'] == 'detail' && association_schema['name'] != 'self'
+              define_method(association_schema['name']) do
+                belongs_to_association(association_schema['name'])
+              end
+            elsif association_schema['type'] == 'run'
+              define_method(association_schema['name']) do |config = nil|
+                custom_method association_schema['name'], config
+              end
+            end
+          end
+
+          private
+
+          self.resource_definition = definition
+        end
+      end
+
+    end
+  end
+end

data/lib/syncano/resources/base.rb

@@ -1,380 +1,384 @@
-class Syncano
-  # Module used as a scope for classes representing resources
+module Syncano
   module Resources
-    # Base resource used for inheritance
     class Base
-      attr_accessor :attributes
-      attr_reader :id, :destroyed
+      include ActiveAttr::Model
+      include ActiveAttr::Dirty
 
-      # Constructor for base resource
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] attributes used in making requests to api (ie. parent id)
-      def initialize(client, attributes = {})
-        super()
+      PARAMETER_REGEXP = /\{([^}]+)\}/
 
-        @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
-        @saved_attributes = ActiveSupport::HashWithIndifferentAccess.new
-        self.id = @attributes.delete(:id)
+      class << self
+        def all(connection, scope_parameters, query_params = {})
+          check_resource_method_existance!(:index)
 
-        self.client = client
+          response = connection.request(:get, collection_path(scope_parameters), query_params)
+          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
+        end
+
+        def last(connection, scope_parameters, query_params = {})
+          all(connection, scope_parameters, query_params).last
+        end
+
+        def find(connection, scope_parameters, pk)
+          check_resource_method_existance!(:show)
+          return unless pk.present?
+
+          response = connection.request(:get, member_path(pk, scope_parameters))
+          new(connection, scope_parameters, response, true)
+        end
+
+        def create(connection, scope_parameters, attributes)
+          check_resource_method_existance!(:create)
+
+          new(connection, scope_parameters, attributes).save
+        end
+
+        def map_attributes_values(attributes)
+          attributes.each do |name, value|
+            attributes[name] = value.to_json if value.is_a?(Array) || value.is_a?(Hash)
+          end
+
+          attributes
+        end
 
-        mark_as_saved! if id.present?
+        def extract_scope_parameters(path)
+          return {} if scope_parameters_names.empty?
+
+          pattern = collection_path_schema.sub('/', '\/')
+
+          scope_parameters_names.each do |parameter_name|
+            pattern.sub!("{#{parameter_name}}", '([^\/]+)')
+          end
+
+          pattern = Regexp.new(pattern)
+          parameter_values = path.scan(pattern).first
+
+          Hash[*scope_parameters_names.zip(parameter_values).flatten]
+        end
+
+        def extract_primary_key(path)
+          return nil if path.blank?
+
+          pattern = member_path_schema.gsub('/', '\/')
+
+          scope_parameters_names.each do |parameter_name|
+            pattern.sub!("{#{parameter_name}}", '([^\/]+)')
+          end
+
+          pattern.sub!("{#{primary_key_name}}", '([^\/]+)')
+
+          pattern = Regexp.new(pattern)
+          parameter_values = path.scan(pattern).first
+          parameter_values.last
+        end
       end
 
-      # Attributes setter
-      # @param [Hash] attributes
-      # @return [Hash]
-      def attributes=(attributes)
-        @attributes.merge!(attributes)
+      def initialize(connection, scope_parameters, attributes, from_database = false)
+        self.connection = connection
+        self.scope_parameters = scope_parameters
+
+        initialize!(attributes, from_database)
       end
 
-      # Single attribute getter
-      # @param [Symbol, String] attribute_name
-      # @return [Object]
-      def [](attribute_name)
-        attributes[attribute_name]
+      def primary_key
+        self.class.extract_primary_key(association_paths[:self])
       end
 
-      # Single attribute setter
-      # @param [Symbol, String] attribute_name
-      # @param [Object] attribute_value
-      # @return [Object]
-      def []=(attribute_name, attribute_value)
-        attributes[attribute_name] = attribute_value
+      def new_record?
+        primary_key.blank?
       end
 
-      # Proxy for preparing batch requests
-      # ie. resource.batch.update will prepare BatchQueueElement
-      # which invokes batch_update method on resource object
-      # @return [Syncano::BatchQueueElement]
-      def batch
-        ::Syncano::BatchQueueElement.new(self)
+      def saved?
+        !new_record? && !changed?
       end
 
-      # Wrapper for api "get" method
-      # Returns all objects from Syncano
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Array] which contains Syncano::Resources::Base objects
-      def self.all(client, scope_parameters = {}, conditions = {})
-        response = perform_all(client, scope_parameters, conditions)
-        response.data.to_a.collect do |attributes|
-          new(client, attributes.merge(scope_parameters))
-        end
+      def update_attributes(attributes)
+        check_resource_method_existance!(:update)
+        raise(Syncano::Error.new('record is not saved')) if new_record?
+
+        self.attributes = attributes
+        save
       end
 
-      # Returns amount of elements returned from all method
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Integer]
-      def self.count(client, scope_parameters = {}, conditions = {})
-        perform_count(client, scope_parameters, conditions)
-      end
-
-      # Wrapper for api "get_one" method
-      # Returns one object from Syncano
-      # @param [Syncano::Clients::Base] client
-      # @param [Integer, String] key
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      def self.find(client, key, scope_parameters = {}, conditions = {})
-        response = perform_find(client, primary_key_name, key, scope_parameters, conditions)
-        new(client, scope_parameters.merge(response.data))
-      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)
-        response = perform_create(client, nil, attributes)
-        new(client, map_to_scope_parameters(attributes).merge(response.data))
-      end
-
-      # Batch version of "create" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] attributes
-      # @return [Syncano::Response]
-      def self.batch_create(batch_client, client, attributes)
-        perform_create(client, batch_client, attributes)
-      end
-
-      # Wrapper for api "update" method
-      # Updates object in Syncano
-      # @param [Hash] attributes
-      # @return [Syncano::Resources::Base]
-      def update(attributes)
-        response = perform_update(nil, attributes)
-        response.data.delete('id')
-        self.attributes = scope_parameters.merge(response.data)
-        mark_as_saved!
-      end
-
-      # Batch version of "update" method
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] attributes
-      # @return [Syncano::Response]
-      def batch_update(batch_client, attributes)
-        perform_update(batch_client, attributes)
-      end
-
-      # Invokes create or update methods
-      # @return [Syncano::Resources::Base]
       def save
-        response = perform_save(nil)
-        response_data = ActiveSupport::HashWithIndifferentAccess.new(response.data)
+        # TODO: Call validation here
 
         if new_record?
-          created_object = self.class.new(client, self.class.map_to_scope_parameters(attributes).merge(response_data))
-
-          self.id = created_object.id
-          self.attributes.merge!(created_object.attributes)
+          apply_forced_defaults!
+          response = connection.request(:post, collection_path, select_create_attributes)
         else
-          self[:updated_at] = response_data[:updated_at]
+          response = connection.request(:patch, member_path, select_changed_attributes)
         end
 
-        mark_as_saved!
-        self
+        initialize!(response, true)
       end
 
-      # Batch version of "save" method
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def batch_save(batch_client)
-        perform_save(batch_client)
+      def destroy
+        check_resource_method_existance!(:destroy)
+        connection.request(:delete, member_path)
+        mark_as_destroyed!
       end
 
-      # Wrapper for api "delete" method
-      # Destroys object in Syncano
-      # @return [Syncano::Resources::Base] marked as destroyed
-      def destroy
-        response = perform_destroy(nil)
-        self.destroyed = response.status
-        self
+      def destroyed?
+        !!destroyed
       end
 
-      # Batch version of "destroy" method
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def batch_destroy(batch_client)
-        perform_destroy(batch_client)
+      def reload!
+        raise(Syncano::Error.new('record is not saved')) if new_record?
+
+        response = connection.request(:get, member_path)
+        initialize!(response)
       end
 
-      # Checks whether is newly initialized or not
-      # @return [TrueClass, FalseClass]
-      def new_record?
-        id.nil?
+      def attribute_definitions
+        self.class.resource_definition.attributes
       end
 
-      # Checks whether record is different than stored in Syncano
-      # @return [TrueClass, FalseClass]
-      def saved?
-        !new_record? && attributes == saved_attributes
+      def attribute_definitions_map
+        Hash[ attribute_definitions.map { |attr| [attr.name, attr] } ]
       end
 
-      # Checks whether record is marked as destroyed
-      # @return [TrueClass, FalseClass]
-      def destroyed?
-        !!destroyed
+      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)
+        self.class.map_attributes_values(attributes)
       end
 
-      # Reloads record from Syncano
-      # @return [TrueClass, FalseClass]
-      def reload!(conditions = {})
-        unless new_record?
-          reloaded_object = self.class.find(client, primary_key, scope_parameters, conditions)
-          self.attributes.clear
-          self.attributes = reloaded_object.attributes
-          mark_as_saved!
-        end
+      def select_update_attributes
+        attributes = updatable_attributes
+        attributes = custom_attributes.merge(attributes) if respond_to?(:custom_attributes)
+        self.class.map_attributes_values(attributes)
+      end
 
-        self
+      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 :syncano_model_name, :scope_parameters, :crud_class_methods, :crud_instance_methods, :primary_key
-
-      self.syncano_model_name = nil
-      self.scope_parameters = []
-      self.crud_class_methods = [:all, :find, :new, :create, :count]
-      self.crud_instance_methods = [:save, :update, :destroy]
-      self.primary_key = :id
-
-      attr_accessor :client, :saved_attributes
-      attr_writer :id, :destroyed
-
-      # Executes proper all request
-      # @param [Syncano::Clients::Base] client
-      # @param [Hash] scope_parameters
-      # @param [Hash] conditions
-      # @return [Syncano::Response]
-      def self.perform_all(client, scope_parameters, conditions)
-        check_class_method_existance!(:all)
-        make_request(client, nil, :all, conditions.merge(scope_parameters))
-      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)
-        check_class_method_existance!(:count)
-        all(client, scope_parameters, conditions).count
-      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)
-        check_class_method_existance!(:find)
-        make_request(client, nil, :find, conditions.merge(scope_parameters.merge(key_name.to_sym => key)))
-      end
-
-      # Executes proper create request
-      # @param [Syncano::Clients::Base] client
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] attributes
-      # @return [Syncano::Response]
-      def self.perform_create(client, batch_client, attributes)
-        check_class_method_existance!(:create)
-        make_request(client, batch_client, :create, attributes_to_sync(attributes))
-      end
-
-      # Executes proper update request
-      # @param [Jimson::BatchClient] batch_client
-      # @param [Hash] attributes
-      # @return [Syncano::Response]
-      def perform_update(batch_client, attributes)
-        check_instance_method_existance!(:update)
-        self.class.make_request(client, batch_client, :update, scope_parameters.merge(self.class.attributes_to_sync(attributes).merge(self.class.primary_key_name => primary_key)))
-      end
-
-      # Executes proper save request
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def perform_save(batch_client)
-        check_instance_method_existance!(:save)
+      class_attribute :resource_definition, :create_writable_attributes, :update_writable_attributes
+      attr_accessor :connection, :association_paths, :member_path, :scope_parameters, :destroyed
 
-        if new_record?
-          self.class.perform_create(client, batch_client, attributes)
-        else
-          perform_update(batch_client, attributes)
+      def initialize!(attributes = {}, from_database = false)
+        attributes = HashWithIndifferentAccess.new(attributes)
+
+        initialize_routing(attributes)
+        initialize_associations(attributes)
+
+        self.attributes.clear
+        self.attributes = attributes.except!(:links)
+
+        if from_database && self.class.attributes.keys.include?('custom_attributes')
+          self.custom_attributes = attributes.select{ |k, v| !self.attributes.keys.include?(k) }
+        end
+
+        apply_defaults
+
+        mark_as_saved! if !new_record? && from_database
+
+        self
+      end
+
+      def initialize_associations(attributes)
+        self.association_paths = HashWithIndifferentAccess.new
+
+        if attributes[:links].present?
+          attributes[:links].keys.each do |key|
+            association_paths[key] = attributes[:links][key]
+          end
         end
       end
 
-      # Executes proper destroy request
-      # @param [Jimson::BatchClient] batch_client
-      # @return [Syncano::Response]
-      def perform_destroy(batch_client)
-        check_instance_method_existance!(:destroy)
-        self.class.make_request(client, batch_client, :destroy, scope_parameters.merge({ self.class.primary_key_name => primary_key }))
+      def initialize_routing(attributes)
+        self.member_path = attributes[:links].try(:[], :self)
       end
 
-      # Converts resource class name to corresponding Syncano resource name
-      # @return [String]
-      def self.api_resource
-        syncano_model_name || to_s.split('::').last.downcase
+      def self.map_member_name_to_resource_class(name)
+        name = 'code_box' if name == 'codebox'
+        "::Syncano::Resources::#{name.camelize}".constantize
       end
 
-      # Converts Syncano gem method to corresponding Syncano api method
-      # @param [String] method_name
-      # @return [String]
-      def self.api_method(method_name)
-        mapping = { all: :get, find: :get_one, create: :new, update: :update, destroy: :delete }
+      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
 
-        method_name = method_name.to_s.gsub('batch_', '')
-        mapping.keys.include?(method_name.to_sym) ? mapping[method_name.to_sym] : method_name
+        map_member_name_to_resource_class(name.singularize)
       end
 
-      # Calls request to api through client object
-      # @param [Syncano::Clients::Base] client
-      # @param [Jimson::BatchClient] batch_client
-      # @param [String] method_name
-      # @param [Hash] attributes
-      # @param [String] response_key
-      # @return [Syncano::Response]
-      def self.make_request(client, batch_client, method_name, attributes = {}, response_key = nil)
-        if batch_client.nil?
-          client.make_request(api_resource, api_method(method_name), attributes, response_key)
-        else
-          client.make_batch_request(batch_client, api_resource, api_method(method_name), attributes)
+      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
 
-      # Returns scope parameters from provided hash with attributes
-      # @param [Hash] attributes
-      # @return [Hash]
-      def self.map_to_scope_parameters(attributes)
-        Hash[scope_parameters.map{ |sym| [sym, attributes[sym]]}]
+      def mark_as_saved!
+        raise(Syncano::Error.new('primary key is blank')) if new_record?
+
+        @previously_changed = changes
+        @changed_attributes.clear
+        self
       end
 
-      # Returns scope parameters from object's attributes
-      # @return [Hash]
-      def scope_parameters
-        self.class.map_to_scope_parameters(attributes)
+      def mark_as_destroyed!
+        self.destroyed = true
       end
 
-      # Returns name for primary key
-      # @return [Hash]
-      def self.primary_key_name
-        "#{api_resource}_#{primary_key}".to_sym
+      def has_many_association(name)
+        # TODO Implement QueryBuilders without scope parameters and adding objects to the association
+        raise(Syncano::Error.new('record not saved')) if new_record?
+
+        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
 
-      # Returns value of primary key
-      # @return [Integer, String]
-      def primary_key
-        self.class.primary_key == :id ? id : @saved_attributes[self.class.primary_key]
+      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
 
-      # Marks record as saved, by copying attributes to saved_attributes
-      # @return [Integer, String]
-      def mark_as_saved!
-        self.saved_attributes = attributes.dup
-        self
+      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 self.custom_method_http_method(method_name)
+        custom_method_definition(method_name)[:http_methods].first.to_sym
+      end
+
+      def self.collection_path_schema
+        resource_definition[:collection][:path].dup
+      end
+
+      def self.member_path_schema
+        resource_definition[:member][:path].dup
+      end
+
+      def self.custom_method_path_schema(method_name)
+        custom_method_definition(method_name)[:path].dup
+      end
+
+      def self.custom_method_definition(method_name)
+        resource_definition[:custom_methods].find do |method_definition|
+          method_definition[:name] == method_name
+        end or raise "No such method #{method_name}"
+      end
+
+      def self.scope_parameters_names
+        collection_path_schema.scan(PARAMETER_REGEXP).collect{ |matches| matches.first.to_sym }
       end
 
-      # Prepares hash with attributes used in synchronization with Syncano
-      # @param [Hash] attributes
-      # @return [Hash]
-      def self.attributes_to_sync(attributes = {})
-        attributes
+      def self.has_collection_actions?
+        resource_definition[:collection].present?
       end
 
-      # Prepares hash with attributes used in synchronization with Syncano
-      # @return [Hash]
-      def attributes_to_sync
-        self.class.attributes_to_sync(attributes)
+      def self.has_member_actions?
+        resource_definition[:member].present?
       end
 
-      # Checks whether class method is implemented in the resource class
-      def self.check_class_method_existance!(method_name)
-        raise NoMethodError.new("undefined method `#{method_name}' for #{to_s}") unless crud_class_methods.include?(method_name.to_sym)
+      def self.check_resource_method_existance!(method_name)
+        raise(NoMethodError.new) unless send("#{method_name}_implemented?")
       end
 
-      # Checks whether class method is implemented in the resource class
-      def check_instance_method_existance!(method_name)
-        raise NoMethodError.new("undefined method `#{method_name}' for #{to_s}") unless crud_instance_methods.include?(method_name.to_sym)
+      def self.primary_key_name
+        resource_definition[:member][:path].scan(PARAMETER_REGEXP).last.first if has_member_actions?
+      end
+
+      def self.custom_method_path(name, pk, scope_parameters)
+        path = custom_method_path_schema(name)
+
+        scope_parameters_names.each do |scope_parameter_name|
+          path.sub!("{#{scope_parameter_name}}", scope_parameters[scope_parameter_name])
+        end
+
+        path.sub!("{#{primary_key_name}}", pk.to_s)
+
+        path
       end
 
-      # Checks if sync connection is used
-      def self.check_if_sync_client!(client)
-        raise Syncano::BaseError.new('Operation available only for Sync client') unless client.is_a?(::Syncano::Clients::Sync)
+      def self.collection_path(scope_parameters = {})
+        path = collection_path_schema
+
+        scope_parameters_names.each do |scope_parameter_name|
+          path.sub!("{#{scope_parameter_name}}", scope_parameters[scope_parameter_name])
+        end
+
+        path
       end
 
-      # Checks if object uses sync connection
-      def check_if_sync_client!
-        self.class.check_if_sync_client!(client)
+      def self.member_path(pk, scope_parameters = {})
+        path = member_path_schema
+
+        scope_parameters_names.each do |scope_parameter_name|
+          path.sub!("{#{scope_parameter_name}}", scope_parameters[scope_parameter_name])
+        end
+
+        path.sub!("{#{primary_key_name}}", pk.to_s)
+
+        path
+      end
+
+      def collection_path
+        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
+
+      {
+        index: { type: :collection, method: :get },
+        create: { type: :collection, method: :post },
+        show: { type: :member, method: :get },
+        update: { type: :member, method: :put },
+        destroy: { type: :member, method: :delete }
+      }.each do |name, parameters|
+
+        define_singleton_method(name.to_s + '_implemented?') do
+          send("has_#{parameters[:type]}_actions?") and resource_definition[parameters[:type]][:http_methods].include?(parameters[:method].to_s)
+        end
       end
     end
   end
-end
+end