syncano 4.0.0.alpha1 → 4.0.0.alpha2

data/lib/syncano/poller.rb

@@ -0,0 +1,55 @@
+module Syncano
+  class Poller
+    include Celluloid::IO
+
+    attr_accessor :connection, :method_name, :path, :responses
+
+
+    def initialize(connection, method_name, path)
+      self.connection = connection
+      self.method_name = method_name
+      self.path = path
+      self.responses = []
+    end
+
+    def poll
+      loop do
+        responses << http_fetcher.get(path)
+      end
+    end
+
+    def last_response
+      responses.last
+    end
+
+    private
+
+    def http_fetcher
+      HttpFetcher.new connection.api_key, connection.user_key
+    end
+
+    class HttpFetcher
+      attr_accessor :api_key, :user_key
+
+      def initialize(api_key, user_key)
+        self.api_key = api_key
+        self.user_key = user_key
+      end
+
+      def get(path, params = {})
+        url = Syncano::Connection.api_root + path
+
+        response = HTTP.
+          with_headers('X-API-KEY' => api_key,
+                       'X-USER-KEY' => user_key,
+                       'User-Agent' => "Syncano Ruby Gem #{Syncano::VERSION}").
+          get(url,
+              params: params,
+              ssl_socket_class: Celluloid::IO::SSLSocket,
+              socket_class: Celluloid::IO::TCPSocket)
+
+        response
+      end
+    end
+  end
+end

data/lib/syncano/resources.rb

@@ -3,8 +3,30 @@ require 'dirty_hashy'
 module Syncano
   module Resources
     class << self
+      def build_definitions(schema_definition)
+        schema_definition.map do |name, raw_resource_definition|
+          ::Syncano::Schema::ResourceDefinition.new(name, raw_resource_definition)
+        end
+      end
+
       def define_resource_class(resource_definition)
-        const_set resource_definition.name, new_resource_class(resource_definition)
+        resource_class = new_resource_class(resource_definition)
+
+        const_set resource_definition.name, resource_class
+
+        if resource_definition[:collection]
+          resources_paths.collections.define resource_definition[:collection][:path], resource_class
+        end
+
+        if resource_definition[:member]
+          resources_paths.members.define resource_definition[:member][:path], resource_class
+        end
+
+        resource_class
+      end
+
+      def resources_paths
+        ::Syncano::Resources::Paths.instance
       end
 
       def new_resource_class(definition)
@@ -15,12 +37,21 @@ module Syncano
           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?
+                      default: attribute_definition.default
+
+            # TODO extract to a dynamically defined module
+            define_method("#{attribute_definition.name}=") do |new_value|
+              if new_value != read_attribute(attribute_definition.name)
+                send("#{attribute_definition.name}_will_change!")
+              end
 
-            if attribute_definition.required?
+              super new_value
+            end
+
+            if attribute_definition.validate?
               validates attribute_definition.name, presence: true
             end
 
@@ -100,18 +131,19 @@ module Syncano
           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
+            case association_schema['type']
+              when 'list'
+                define_method(association_schema['name']) do
+                  has_many_association(association_schema['name'])
+                end
+              when 'run'
+                define_method(association_schema['name']) do |config = nil|
+                  custom_method association_schema['name'], config
+                end
+              when 'poll'
+                define_method(association_schema['name']) do |config = nil|
+                  async_method association_schema['name'], config
+                end
             end
           end
 

data/lib/syncano/resources/base.rb

@@ -2,7 +2,7 @@ module Syncano
   module Resources
     class Base
       include ActiveAttr::Model
-      include ActiveAttr::Dirty
+      include ActiveModel::Dirty
 
       PARAMETER_REGEXP = /\{([^}]+)\}/
 
@@ -34,7 +34,15 @@ module Syncano
         def create(connection, scope_parameters, attributes)
           check_resource_method_existance!(:create)
 
-          new(connection, scope_parameters, attributes).save
+          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)
@@ -95,7 +103,7 @@ module Syncano
       end
 
       def new_record?
-        primary_key.blank?
+        new_record
       end
 
       def saved?
@@ -111,21 +119,31 @@ module Syncano
       end
 
       def save
-        # TODO: Call validation here
+        return false unless valid?
 
+        commit_save
+      end
+
+      def save!
+        raise Syncano::Resources::ResourceInvalid.new(self) unless valid?
+
+        commit_save
+      end
+
+      def commit_save
         if new_record?
-          apply_forced_defaults!
           response = connection.request(:post, collection_path, select_create_attributes)
         else
-          response = connection.request(:patch, member_path, select_changed_attributes)
+          response = connection.request(:patch, self_path, select_changed_attributes)
         end
 
         initialize!(response, true)
+
       end
 
       def destroy
         check_resource_method_existance!(:destroy)
-        connection.request(:delete, member_path)
+        connection.request(:delete, self_path)
         mark_as_destroyed!
       end
 
@@ -136,7 +154,7 @@ module Syncano
       def reload!
         raise(Syncano::Error.new('record is not saved')) if new_record?
 
-        response = connection.request(:get, member_path)
+        response = connection.request(:get, self_path)
         initialize!(response)
       end
 
@@ -183,13 +201,18 @@ module Syncano
 
       private
 
-      class_attribute :resource_definition, :create_writable_attributes, :update_writable_attributes
-      attr_accessor :connection, :association_paths, :member_path, :scope_parameters, :destroyed
+      class_attribute :resource_definition, :create_writable_attributes,
+                      :update_writable_attributes
+      attr_accessor :connection, :association_paths, :member_path,
+                    :scope_parameters, :destroyed, :self_path, :new_record
 
       def initialize!(attributes = {}, from_database = false)
         attributes = HashWithIndifferentAccess.new(attributes)
 
-        initialize_routing(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_associations(attributes)
 
         self.attributes.clear
@@ -216,37 +239,8 @@ module Syncano
         end
       end
 
-      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
+      def map_collection_name_to_resource_class(name)
+        ::Syncano::Resources::Paths.instance.collections.match(association_paths[name])
       end
 
       def mark_as_saved!
@@ -265,26 +259,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 = self.class.map_collection_name_to_resource_class(name)
+        resource_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
@@ -365,10 +359,6 @@ 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
@@ -377,7 +367,7 @@ module Syncano
         index: { type: :collection, method: :get },
         create: { type: :collection, method: :post },
         show: { type: :member, method: :get },
-        update: { type: :member, method: :put },
+        update: { type: :member, method: :patch },
         destroy: { type: :member, method: :delete }
       }.each do |name, parameters|
 

data/lib/syncano/resources/paths.rb

@@ -0,0 +1,48 @@
+require 'singleton'
+
+module Syncano
+  module Resources
+    class Paths
+      include Singleton
+
+      attr_accessor :collections, :members
+
+      def initialize
+        self.collections = self.class::Collection.new
+        self.members = self.class::Member.new
+      end
+
+      private
+
+      class Collection
+        def initialize
+          @map = {}
+        end
+
+        def define(path, resource)
+          @map[Regexp.new("\\A#{path.gsub(/{[^}]*}/, '([^\/]+)')}\\z")] = resource
+        end
+
+        def match(path)
+          _, resouce = @map.find { |pattern, _| pattern =~ path }
+          resouce
+        end
+      end
+
+      class Member
+        def initialize
+          @map = {}
+        end
+
+        def define(path, resource)
+          resource_name = resource.name
+          @map[resource_name] = path
+        end
+
+        def find(resource)
+          @map[resource.name]
+        end
+      end
+    end
+  end
+end

data/lib/syncano/resources/resource_invalid.rb

@@ -0,0 +1,15 @@
+module Syncano
+  module Resources
+    class ResourceInvalid < StandardError
+      attr_accessor :resource
+
+      def initialize(resource)
+        self.resource = resource
+      end
+
+      def to_s
+        "#{self.class.name} <#{resource.class.name} #{resource.errors.full_messages}>"
+      end
+    end
+  end
+end

data/lib/syncano/response.rb

@@ -0,0 +1,55 @@
+module Syncano
+  class Response
+    class << self
+      def handle(raw_response)
+        code = unify_code(raw_response)
+
+        case code
+          when Status.no_content
+          when Status.successful
+            parse_response raw_response
+          when Status.not_found
+            raise NotFound.new(raw_response.env.url, raw_response.env.method)
+          when Status.client_error
+            raise ClientError.new raw_response.body, raw_response
+          when Status.server_error
+            raise ServerError.new raw_response.body, raw_response
+          else
+            raise UnsupportedStatusError.new raw_response
+        end
+      end
+
+      def parse_response(raw_response)
+        JSON.parse(raw_response.body)
+      end
+
+      def unify_code(raw_response)
+        raw_response.status.code
+      end
+    end
+
+    class Status
+      class << self
+        def successful
+          ->(code) { (200...300).include? code }
+        end
+
+        def client_error
+          ->(code) { (400...500).include? code }
+        end
+
+        def no_content
+          ->(code) { code == 204 }
+        end
+
+        def server_error
+          ->(code) { code >= 500 }
+        end
+
+        def not_found
+          ->(code) { code == 404 }
+        end
+      end
+    end
+  end
+end