syncano 4.0.0.alpha4 → 4.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 287313441ace89449cf5ee73f1898c02aa01e976
-  data.tar.gz: 309aea98ddc29cc1f4ff5113a68e054a4316c62a
+  metadata.gz: 29165fa581b83fb889acd45abf0f730e047038a0
+  data.tar.gz: dc7f5504c6d99d6710c15216d8fa743dd245d6b9
 SHA512:
-  metadata.gz: c33792ed712d4df96439c58d85199230fc20141c8ac6f91bf2352f90fb1e58248ad7bc819fa9a2c0584bc2c8ac80e5a404309e5ced9abd991c6dbe20f84b3246
-  data.tar.gz: e9b22b114d55855ba23ce49bf0a343b0b30ae270558b87f699eddb3f3d361bd010a547c7ec8d0e63798c3d9ca27c634992860265ad38a307c1e3f90e290031de
+  metadata.gz: cb9d843a8201bddf2e3b302c70547c23d6155003bbd1ad2654ee922d6c83db58454bf0d9f604b38a09ab4f903c2eb6a823f533c26d9f2a4efe0ccdc6aef0798a
+  data.tar.gz: e8e95b8073d24d819ba9e070d5aa6513ca2ea6c4d30356378b172684a1b6a41a46e5a255dba1e6f2feacda10d5215182a903eeae228207d218056e08c2e89dfc

data/.ruby-version

@@ -1 +1 @@
-2.2.3
+ruby-2.1.5

data/README.md

@@ -1,18 +1,6 @@
-# Syncano 4.0 Ruby Gem
-
-## Ruby QuickStart Guide
----
-
-Syncano ruby gem provides communication with Syncano platform - ([www.syncano.io](http://www.syncano.io/?utm_source=github&utm_medium=readme&utm_campaign=syncano-ruby))
-
-You can find quick start on installing and using Syncano's Ruby library in our [documentation](http://docs.syncano.io/docs/ruby/?utm_source=github&utm_medium=readme&utm_campaign=syncano-js).
-
-For more detailed information on how to use Syncano and its features - our [Developer Manual](http://docs.syncano.io/docs/getting-started-with-syncano/?utm_source=github&utm_medium=readme&utm_campaign=syncano-js) should be very helpful.
-
-In case you need help working with the library - email us at libraries@syncano.com - we will be happy to help!
+# Syncano 4.0 ruby gem
 
 ## Contributing
----
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/circle.yml

@@ -2,7 +2,7 @@ machine:
   ruby:
     version: 2.1.5
   environment:
-    API_ROOT: https://api.syncano.rocks
+    API_ROOT: https://v4.hydraengine.com
 dependencies:
   override:
     - gem install bundler -v 1.7

data/lib/active_attr/dirty.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+require 'active_model/dirty'
+require 'active_attr'
+
+# Overwritting ActiveAttr module
+module ActiveAttr
+  # Overwritting ActiveAttr::Dirty module
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    # Class methods for ActiveAttr::Dirty module
+    module ClassMethods
+      # Overwritten attribute! method
+      # @param [Symbol] name
+      # @param [Hash] options
+      def attribute!(name, options = {})
+        super(name, options)
+        define_method("#{name}=") do |value|
+          send("#{name}_will_change!") unless value == read_attribute(name)
+          super(value)
+        end
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/hash_typecaster.rb

@@ -0,0 +1,34 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveAttr
+  module Typecasting
+    # Typecasts an Object to a HashWithInddifferentAccess
+    #
+    # @example Usage
+    #   typecaster = HashTypecaster.new
+    #   typecaster.call([[:foo, :bar]]) #=> { foo: :bar }
+    #
+    # @since 0.5.0
+    class HashTypecaster
+      # Typecasts an object to a HashWithInddifferentAccess
+      #
+      # Attempts to convert using #to_h.
+      #
+      # @example Typecast an Array
+      #   typecaster.call([[:foo, :bar]]) #=> { foo: :bar }
+      #
+      # @param [Object, #to_h] value The object to typecast
+      #
+      # @return [HashWithInddifferentAccess] The result of typecasting
+      #
+      # @since 0.5.0
+      def call(value)
+        if value.respond_to? :to_h
+          HashWithIndifferentAccess.new(value.to_h)
+        else
+          HashWithIndifferentAccess.new
+        end
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting_override.rb

@@ -0,0 +1,29 @@
+require 'active_attr/typecasting/big_decimal_typecaster'
+require 'active_attr/typecasting/boolean'
+require 'active_attr/typecasting/boolean_typecaster'
+require 'active_attr/typecasting/date_time_typecaster'
+require 'active_attr/typecasting/date_typecaster'
+require 'active_attr/typecasting/float_typecaster'
+require 'active_attr/typecasting/integer_typecaster'
+require 'active_attr/typecasting/object_typecaster'
+require 'active_attr/typecasting/string_typecaster'
+require 'active_attr/typecasting/hash_typecaster'
+require 'active_attr/typecasting/unknown_typecaster_error'
+
+module ActiveAttr
+  module Typecasting
+    remove_const(:TYPECASTER_MAP) if defined?(TYPECASTER_MAP)
+
+    TYPECASTER_MAP = {
+      BigDecimal => BigDecimalTypecaster,
+      Boolean    => BooleanTypecaster,
+      Date       => DateTypecaster,
+      DateTime   => DateTimeTypecaster,
+      Float      => FloatTypecaster,
+      Integer    => IntegerTypecaster,
+      Object     => ObjectTypecaster,
+      String     => StringTypecaster,
+      Hash       => HashTypecaster
+    }.freeze
+  end
+end

data/lib/syncano.rb

@@ -1,42 +1,28 @@
 $: << Dir.pwd
 
-require 'active_attr'
-require 'active_model'
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute.rb'
+require 'faraday'
+require 'active_attr/model'
+require 'active_attr/dirty'
+require 'active_attr/typecasting_override'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/class/attribute.rb'
 require 'active_support/inflector'
-require 'celluloid/future'
-require 'celluloid/io'
-require 'faraday'
-require 'http'
-require 'yaml'
-require 'mimetype_fu'
-
-require 'syncano/query_builder'
 require 'syncano/version'
 require 'syncano/api'
-require 'syncano/api/endpoints'
 require 'syncano/connection'
 require 'syncano/schema'
 require 'syncano/scope'
-require 'syncano/poller'
-require 'syncano/resources'
 require 'syncano/resources/base'
 require 'syncano/resources/collection'
-require 'syncano/resources/paths'
-require 'syncano/resources/resource_invalid'
 require 'syncano/resources/space'
-require 'syncano/response'
-require 'syncano/upload_io'
 require 'syncano/query_builder'
+require 'syncano/model/base'
 
 module Syncano
   class << self
     def connect(options = {})
-      connection = Connection.new(
-          options.reverse_merge(api_key: ENV['SYNCANO_API_KEY']))
-      connection.authenticate unless connection.authenticated?
+      connection = Connection.new(options)
+      connection.authenticate! unless connection.authenticated?
 
       API.new connection
     end
@@ -46,24 +32,7 @@ module Syncano
 
   class RuntimeError < StandardError; end
 
-  class HTTPError < StandardError
-  end
-
-  class NotFound < HTTPError
-    attr_accessor :path, :method_name
-
-    def initialize(path, method_name)
-      self.path = path
-      self.method_name = method_name
-    end
-
-    def inspect
-      %{#{self.class.name} path: "#{path}" method: "#{method_name}"}
-    end
-  end
-
-  class HTTPErrorWithBody < HTTPError
-
+  class ClientError < StandardError
     attr_accessor :body, :original_response
 
     def initialize(body, original_response)
@@ -77,19 +46,4 @@ module Syncano
 
     alias :to_s :inspect
   end
-
-  class ClientError < HTTPErrorWithBody; end
-  class ServerError < HTTPErrorWithBody; end
-
-  class UnsupportedStatusError < StandardError
-    attr_accessor :original_response
-
-    def initialize(original_response)
-      self.original_response = original_response
-    end
-
-    def inspect
-      "The server returned unsupported status code #{original_response.status}"
-    end
-  end
 end

data/lib/syncano/api.rb

@@ -1,31 +1,13 @@
 module Syncano
   class API
-
     def initialize(connection)
       self.connection = connection
-
-      self.class.initialize(connection) unless self.class.initialized?
-    end
-
-    class << self
-      def initialize(connection)
-        endpoints = Schema::EndpointsWhitelist.new(Schema.new(connection))
-
-        resources_definitions = Resources.build_definitions(endpoints)
-
-        include Syncano::API::Endpoints.definition(resources_definitions)
-
-        self.initialized = true
-      end
-
-      def initialized?
-        initialized
-      end
+      schema = ::Syncano::Schema.new(connection)
+      schema.process!
     end
 
     private
 
     attr_accessor :connection
-    cattr_accessor :initialized
   end
 end

data/lib/syncano/connection.rb

@@ -6,81 +6,80 @@ module Syncano
     AUTH_PATH = 'account/auth/'
     METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
 
-    attr_accessor :api_key
-    attr_accessor :user_key
-
-    class << self
-      def api_root
-        "https://api.syncano.io"
-      end
-    end
-
-    def http_fetcher
-      HttpFetcher.new api_key, user_key
+    def self.api_root
+      ENV['API_ROOT']
     end
 
     def initialize(options = {})
       self.api_key = options[:api_key]
       self.email = options[:email]
       self.password = options[:password]
-      self.user_key = options[:user_key]
-      self.conn = Faraday.new(self.class.api_root) do |faraday|
-        faraday.path_prefix = API_VERSION
-        faraday.request :multipart
-        faraday.request :url_encoded
-        faraday.adapter Faraday.default_adapter
-      end
+
+      # TODO: take it easy with SSL for development only, temporary solution
+      self.conn = Faraday.new(self.class.api_root, ssl: { verify: false })
+      conn.path_prefix = API_VERSION
+      conn.request :url_encoded
     end
 
     def authenticated?
       !api_key.nil?
     end
 
-    def authenticate
-      api_key = request(:post, AUTH_PATH,
-                        email: email,
-                        password: password)['account_key']
-      self.api_key = api_key
+    def authenticate(email, password)
+      self.email = email
+      self.password = password
+      authenticate!
     end
 
-    def request(method, path, params = {})
-      raise %{Unsupported method "#{method}"} unless METHODS.include? method
-
-      conn.headers['X-API-KEY'] = api_key if api_key
-      conn.headers['X-USER-KEY'] = user_key if user_key
-      conn.headers['User-Agent'] = "Syncano Ruby Gem #{Syncano::VERSION}"
-
-      raw_response = conn.send(method, path, params)
+    def authenticate!
+      response = conn.post(AUTH_PATH, email: email, password: password)
+      body = parse_response(response)
 
-      Syncano::Response.handle ResponseWrapper.new(raw_response)
+      case response
+        when Status.successful
+          self.api_key = body['account_key']
+        when Status.client_error
+          raise ClientError.new(body, response)
+      end
     end
 
-    private
-
-    class ResponseWrapper < BasicObject
-      def initialize(response)
-        @response = response
+    def request(method, path, params = {})
+      raise %{Unsupported method "#{method}"} unless METHODS.include? method
+      conn.headers['X-API-KEY'] = api_key
+      response = conn.send(method, path, params)
+
+      case response
+        when Status.no_content
+        when Status.successful
+          parse_response response
+        when Status.client_error # TODO figure out if we want to raise an excpetion on not found or not
+          raise ClientError.new(response.body, response)
       end
+    end
 
-      def method_missing(name, *args, &block)
-        @response.__send__(name, *args, &block)
-      end
+    private
 
-      def status
-        Status.new @response.status
-      end
+    def parse_response(response)
+      JSON.parse(response.body)
+    end
 
-      private
+    class Status
+      class << self
+        def successful
+          ->(response) { (200...300).include? response.status }
+        end
 
-      class Status
-        attr_accessor :code
+        def client_error
+          ->(response) { (400...500).include? response.status }
+        end
 
-        def initialize(code)
-          self.code = code
+        def no_content
+          ->(response) { response.status == 204 }
         end
       end
     end
 
+    attr_accessor :api_key
     attr_accessor :api_root
     attr_accessor :email
     attr_accessor :password

data/lib/syncano/model/associations.rb

@@ -0,0 +1,121 @@
+require 'syncano/model/associations/belongs_to'
+require 'syncano/model/associations/has_many'
+require 'syncano/model/associations/has_one'
+
+module Syncano
+  module Model
+    # Module with associations functionality for Syncano::Model
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        private
+
+        class_attribute :_associations
+      end
+
+      # Class methods for Syncano::Model::Associations module
+      module ClassMethods
+        # Lists hash with associations
+        # @return [HashWithIndifferentAccess]
+        def associations
+          self._associations ||= HashWithIndifferentAccess.new
+        end
+
+        private
+
+        # Defines belongs_to association
+        # @param [Symbol] object_name
+        def belongs_to(object_name, options = {})
+          association = Syncano::Model::Association::BelongsTo.new(self, object_name, options)
+          associations[object_name] = association
+
+          define_method(object_name) do
+            association = self.class.associations[object_name]
+            id = send(association.foreign_key)
+            scope = scope_builder(association.associated_model).find(id)
+          end
+
+          define_method("#{object_name}=") do |object|
+            association = self.class.associations[object_name]
+
+            unless object.is_a?(association.associated_model)
+              raise "Object should be an instance of #{association.associated_model} class"
+            end
+            send("#{association.foreign_key}=", object.try(:id))
+          end
+        end
+
+        # Defines has_one association
+        # @param [Symbol] object_name
+        def has_one(object_name, options = {})
+          association = Syncano::Model::Association::HasOne.new(self, object_name, options)
+          associations[object_name] = association
+
+          define_method(object_name) do
+            association = self.class.associations[object_name]
+
+            scope = scope_builder.new(association.associated_model)
+            scope.where("#{association.foreign_key} = ?", id).first if id.present?
+          end
+
+          define_method("#{object_name}=") do |object|
+            association = self.class.associations[object_name]
+
+            unless object.is_a?(association.associated_model)
+              raise "Object should be an instance of #{association.associated_model} class"
+            end
+
+            object.send("#{association.foreign_key}=", id)
+            object.save unless object.new_record?
+            object
+          end
+
+          define_method("build_#{object_name}") do |attributes = {}|
+            association = self.class.associations[object_name]
+            association.associated_model.new(attributes)
+          end
+
+          define_method("create_#{object_name}") do |attributes = {}|
+            association = self.class.associations[object_name]
+            association.associated_model.create(attributes)
+          end
+        end
+
+        # Defines has_many association
+        # @param [Symbol] collection_name
+        def has_many(collection_name, options = {})
+          association = Syncano::Model::Association::HasMany.new(self, collection_name, options)
+          associations[collection_name] = association
+
+          define_method(collection_name) do
+            association = self.class.associations[collection_name]
+            association.scope_builder(self)
+          end
+
+          define_method("#{collection_name}=") do |collection|
+            association = self.class.associations[collection_name]
+            objects_ids = {}
+
+            collection.each do |object|
+              "Object should be an instance of #{association.associated_model} class" unless object.is_a?(association.associated_model)
+              objects_ids[object.id] = true
+            end
+
+            send(collection_name).all.each do |object|
+              unless objects_ids[object.id]
+                object.send("#{association.foreign_key}=", nil)
+                object.save unless object.new_record?
+              end
+            end
+
+            collection.each do |object|
+              object.send("#{association.foreign_key}=", id)
+              object.save unless object.new_record?
+            end
+          end
+        end
+      end
+    end
+  end
+end