syncano 3.1.4 → 4.0.0.alpha

data/Rakefile

@@ -1,7 +1,50 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rake/testtask'
 
-RSpec::Core::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+task default: [:ci]
 
-task default: :spec
-task test: :spec
+desc 'Run specs in isolation'
+task :"spec:isolation" do
+  FileList['spec/**/*_spec.rb'].each do |spec|
+    sh 'rspec', spec
+  end
+end
+
+desc 'Run CI tasks'
+task ci: [:spec, :lint, :"spec:isolation"]
+
+Rake::TestTask.new(:lint) do |test|
+  test.description = 'Run adapter lint tests against memory adapter'
+  test.test_files = FileList.new('spec/test/*_test.rb')
+  test.libs << 'test'
+  test.verbose = true
+end
+
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names' << '--lint'
+  end
+end
+
+desc 'Run mutant against a specific subject'
+task :mutant do
+  subject = ARGV.last
+  if subject == 'mutant'
+    abort "usage: rake mutant SUBJECT\nexample: rake mutant Syncano::API"
+  else
+    opts = {
+      'include' => 'lib',
+      'require' => 'syncano',
+      'use' => 'rspec',
+      'ignore-subject' => "#{subject}#respond_to_missing?"
+    }.to_a.map { |k, v| "--#{k} #{v}" }.join(' ')
+
+    exec("bundle exec mutant #{opts} #{subject}")
+  end
+end

data/circle.yml

@@ -0,0 +1,10 @@
+machine:
+  ruby:
+    version: 2.1.5
+  environment:
+    API_ROOT: https://v4.hydraengine.com
+dependencies:
+  override:
+    - gem install bundler -v 1.7
+    - bundle install
+

data/lib/active_attr/dirty.rb

@@ -1,4 +1,4 @@
-require 'active_support'
+require 'active_support/concern'
 require 'active_model/dirty'
 require 'active_attr'
 
@@ -14,7 +14,7 @@ module ActiveAttr
       # Overwritten attribute! method
       # @param [Symbol] name
       # @param [Hash] options
-      def attribute!(name, options={})
+      def attribute!(name, options = {})
         super(name, options)
         define_method("#{name}=") do |value|
           send("#{name}_will_change!") unless value == read_attribute(name)
@@ -22,19 +22,5 @@ module ActiveAttr
         end
       end
     end
-
-    # Overwritten constructor
-    # @param [Hash] attributes
-    # @param [Hash] options
-    def initialize(attributes = nil, options = {})
-      super(attributes, options)
-      (@changed_attributes || {}).clear unless new_record?
-    end
-
-    # Overwritten save method
-    def save
-      @previously_changed = changes
-      @changed_attributes.clear
-    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,107 +1,68 @@
+$: << Dir.pwd
+
+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 'syncano/version'
+require 'syncano/api'
+require 'syncano/connection'
+require 'syncano/schema'
+require 'syncano/scope'
+require 'syncano/resources'
+require 'syncano/resources/base'
+require 'syncano/resources/collection'
+require 'syncano/resources/space'
+require 'syncano/query_builder'
+require 'syncano/model/base'
 
-# Main class used for instantizing clients and as scope for other classes
-class Syncano
-  # Used for initializing Syncano Rest Client
-  # @param [Hash] options with keys: instance_name, api_key which can be also provided as constants in the initializer
-  # @return [Syncano::Clients::Rest] Syncano client.
-  def self.client(options = {})
-    auth_data = self.auth_data(options)
-    client = Syncano::Clients::Rest.new(auth_data[:instance_name], auth_data[:api_key], auth_data[:auth_key])
-    client.login(options[:username], options[:password]) if client.auth_key.nil? && options[:username].present?
-    client
-  end
+module Syncano
+  class << self
+    def connect(options = {})
+      connection = Connection.new(
+          options.reverse_merge(api_key: ENV['SYNCANO_API_KEY']))
+      connection.authenticate! unless connection.authenticated?
 
-  # Used for initializing Syncano Sync Client
-  # @param [Hash] options with keys: instance_name, api_key which can be also provided as constants in the initializer
-  # @return [Syncano::Clients::Rest] Syncano client.
-  def self.sync_client(options = {})
-    auth_data = self.auth_data(options)
-    client = Syncano::Clients::Sync.instance(auth_data[:instance_name], auth_data[:api_key], auth_data[:auth_key])
-    client.login(options[:username], options[:password]) if client.auth_key.nil? && options[:username].present?
-    client.reconnect
-    client
+      API.new connection
+    end
   end
 
-  private
-
-  # Prepares hash with auth data from options or constants in initializer
-  # @param [Hash] options with keys: instance_name, api_key which can be also provided as constants in the initializer
-  # @return [Hash]
-  def self.auth_data(options = {})
-    instance_name = options[:instance_name] || ::SYNCANO_INSTANCE_NAME
-    raise 'Syncano instance name cannot be blank!' if instance_name.nil?
+  class Error < StandardError; end
 
-    api_key = options[:api_key] || ::SYNCANO_API_KEY
-    raise 'Syncano api key cannot be blank!' if api_key.nil?
+  class RuntimeError < StandardError; end
 
-    { instance_name: instance_name, api_key: api_key, auth_key: options[:auth_key] }
-  end
-end
+  class HTTPError < StandardError
+    attr_accessor :body, :original_response
 
-# Jimson client
-require 'jimson/client'
-require 'syncano/jimson_client'
+    def initialize(body, original_response)
+      self.body = body
+      self.original_response = original_response
+    end
 
-# Multi Json
-require 'multi_json'
+    def inspect
+      "<#{self.class.name} #{body} #{original_response}>"
+    end
 
-# Eventmachine
-require 'eventmachine'
+    alias :to_s :inspect
+  end
 
-# Singleton
-require 'singleton'
+  class ClientError < HTTPError; end
+  class ServerError < HTTPError; end
 
-# ActiveSupport
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/class/attribute.rb'
-require 'active_support/core_ext/object/blank.rb'
-require 'active_support/json/decoding.rb'
-require 'active_support/json/encoding.rb'
-require 'active_support/time_with_zone.rb'
-require 'active_support/concern'
-require 'active_support/inflector/inflections'
+  class UnsupportedStatusError < StandardError
+    attr_accessor :original_response
 
-# ActiveModel
-require 'active_model/forbidden_attributes_protection'
-require 'active_model/attribute_methods'
-require 'active_model/dirty'
+    def initialize(original_response)
+      self.original_response = original_response
+    end
 
-# ActiveAttr
-require 'active_attr/model'
-require 'active_attr/dirty'
+    def inspect
+      "The server returned unsupported status code #{original_response.status}"
+    end
 
-# Syncano
-require 'syncano/errors'
-require 'syncano/clients/base'
-require 'syncano/clients/rest'
-require 'syncano/clients/sync'
-require 'syncano/sync_connection'
-require 'syncano/query_builder'
-require 'syncano/batch_queue'
-require 'syncano/batch_queue_element'
-require 'syncano/response'
-require 'syncano/resources/base'
-require 'syncano/resources/admin'
-require 'syncano/resources/api_key'
-require 'syncano/resources/data_object'
-require 'syncano/resources/collection'
-require 'syncano/resources/folder'
-require 'syncano/resources/project'
-require 'syncano/resources/role'
-require 'syncano/resources/subscription'
-require 'syncano/resources/user'
-require 'syncano/packets/base'
-require 'syncano/packets/auth'
-require 'syncano/packets/call'
-require 'syncano/packets/call_response'
-require 'syncano/packets/error'
-require 'syncano/packets/message'
-require 'syncano/packets/notification'
-require 'syncano/packets/ping'
-require 'syncano/resources/notifications/base'
-require 'syncano/resources/notifications/create'
-require 'syncano/resources/notifications/update'
-require 'syncano/resources/notifications/destroy'
-require 'syncano/resources/notifications/message'
-require 'syncano/active_record/base'
+    alias :to_s :inspect
+  end
+end

data/lib/syncano/api.rb

@@ -0,0 +1,13 @@
+module Syncano
+  class API
+    def initialize(connection)
+      self.connection = connection
+      schema = ::Syncano::Schema.new(connection)
+      schema.process!
+    end
+
+    private
+
+    attr_accessor :connection
+  end
+end

data/lib/syncano/connection.rb

@@ -0,0 +1,97 @@
+require 'json'
+
+module Syncano
+  class Connection
+    API_VERSION = 'v1'
+    AUTH_PATH = 'account/auth/'
+    METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
+
+    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]
+
+      # 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(email, password)
+      self.email = email
+      self.password = password
+      authenticate!
+    end
+
+    def authenticate!
+      response = conn.post(AUTH_PATH, email: email, password: password)
+      body = parse_response(response)
+
+      case response
+        when Status.successful
+          self.api_key = body['account_key']
+        when Status.client_error
+          raise ClientError.new(body, response)
+      end
+    end
+
+    def request(method, path, params = {})
+      raise %{Unsupported method "#{method}"} unless METHODS.include? method
+      conn.headers['X-API-KEY'] = api_key
+      conn.headers['User-Agent'] = "Syncano Ruby Gem #{Syncano::VERSION}"
+      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 exception on not found or not
+          raise ClientError.new(response.body, response)
+        when Status.server_error
+          raise ServerError.new(response.body, response)
+        else
+          raise UnsupportedStatusError.new(response)
+      end
+    end
+
+    private
+
+    def parse_response(response)
+      JSON.parse(response.body)
+    end
+
+    class Status
+      class << self
+        def successful
+          ->(response) { (200...300).include? response.status }
+        end
+
+        def client_error
+          ->(response) { (400...500).include? response.status }
+        end
+
+        def no_content
+          ->(response) { response.status == 204 }
+        end
+
+        def server_error
+          ->(response) { response.status >= 500 }
+        end
+      end
+    end
+
+    attr_accessor :api_key
+    attr_accessor :api_root
+    attr_accessor :email
+    attr_accessor :password
+    attr_accessor :conn
+  end
+end

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