syncano 4.0.0.alpha4 → 4.0.0.pre

data/lib/syncano/model/associations/base.rb

@@ -0,0 +1,38 @@
+require 'syncano/model/scope_builder'
+
+module Syncano
+  module Model
+    # Module with associations functionality for Syncano::ActiveRecord
+    module Association
+      # Base class for all associations
+      class Base
+        # Constructor for association
+        # @param [Class] source_model
+        # @param [Symbol] name
+        def initialize(source_model, name, options = {})
+          self.source_model = source_model
+          self.associated_model = name.to_s.classify.constantize
+          self.foreign_key = options[:foreign_key] || source_model.name.foreign_key
+        end
+
+        # Checks if association is belongs_to type
+        # @return [FalseClass]
+        def belongs_to?
+          false
+        end
+
+        # Checks if association is has_one type
+        # @return [FalseClass]
+        def has_one?
+          false
+        end
+
+        # Checks if association is has_many type
+        # @return [FalseClass]
+        def has_many?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/syncano/model/associations/belongs_to.rb

@@ -0,0 +1,30 @@
+require 'syncano/model/associations/base'
+
+module Syncano
+  module Model
+    module Association
+      # Class for belongs to association
+      class BelongsTo < Syncano::Model::Association::Base
+        attr_reader :associated_model, :foreign_key, :source_model
+
+        # Constructor for belongs_to association
+        # @param [Class] source_model
+        # @param [Symbol] name
+        def initialize(source_model, name, options = {})
+          super
+          self.foreign_key = options[:foreign_key] || associated_model.name.foreign_key
+        end
+
+        # Checks if association is belongs_to type
+        # @return [TrueClass]
+        def belongs_to?
+          true
+        end
+
+        private
+
+        attr_writer :associated_model, :foreign_key, :source_model
+      end
+    end
+  end
+end

data/lib/syncano/model/associations/has_many.rb

@@ -0,0 +1,75 @@
+require 'syncano/model/associations/base'
+
+module Syncano
+  module Model
+    module Association
+      # Class for has many association
+      class HasMany < Syncano::Model::Association::Base
+        attr_reader :associated_model, :foreign_key, :source_model
+
+        # Checks if association is has_many type
+        # @return [TrueClass]
+        def has_many?
+          true
+        end
+
+        # Returns new associaton object with source object set
+        # @param [Object] source
+        # @return [Syncano::ActiveRecord::Association::HasMany]
+        def scope_builder(source)
+          association = self.dup
+          association.source = source
+          association
+        end
+
+        # Builds new associated object
+        # @return [Object]
+        def build(attributes = {})
+          new(attributes)
+        end
+
+        def new(attributes = {})
+          associated_model.new(attributes.merge(foreign_key => source.id))
+        end
+
+        # Creates new associated object
+        # @return [Object]
+        def create(attributes = {})
+          associated_model.create(attributes.merge(foreign_key => source.id))
+        end
+
+        # Adds object to the related collection by setting foreign key
+        # @param [Object] object
+        # @return [Object]
+        def <<(object)
+          "Object should be an instance of #{associated_model} class" unless object.is_a?(associated_model)
+
+          object.send("#{foreign_key}=", source.id)
+          object.save unless object.new_record?
+          object
+        end
+
+        protected
+
+        attr_accessor :source
+
+        private
+
+        attr_writer :associated_model, :foreign_key, :source_model
+
+        # Overwritten method_missing for handling scope methods
+        # @param [String] name
+        # @param [Array] args
+        def method_missing(name, *args)
+          scope_builder = Syncano::Model::ScopeBuilder.new(associated_model).where("#{foreign_key} = ?", source.id)
+
+          if scope_builder.respond_to?(name) || !source.scopes[name].nil?
+            scope_builder.send(name, *args)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syncano/model/associations/has_one.rb

@@ -0,0 +1,22 @@
+require 'syncano/model/associations/base'
+
+module Syncano
+  module Model
+    module Association
+      # Class for has one association
+      class HasOne < Syncano::Model::Association::Base
+        attr_reader :associated_model, :foreign_key, :source_model
+
+        # Checks if association is has_one type
+        # @return [TrueClass]
+        def has_one?
+          true
+        end
+
+        private
+
+        attr_writer :associated_model, :foreign_key, :source_model
+      end
+    end
+  end
+end

data/lib/syncano/model/base.rb

@@ -0,0 +1,257 @@
+require 'syncano/model/scope_builder'
+require 'syncano/model/associations'
+require 'syncano/model/callbacks'
+
+module Syncano
+  # Scope for modules and classes integrating ActiveRecord functionality
+  module Model
+    # Class for integrating ActiveRecord functionality
+    class Base
+      include ActiveAttr::Model
+      include ActiveAttr::Dirty
+
+      include ActiveModel::ForbiddenAttributesProtection
+      include Syncano::Model::Associations
+      include Syncano::Model::Callbacks
+
+      attribute :id, type: Integer
+      attribute :created_at, type: DateTime
+      attribute :updated_at, type: DateTime
+
+      # Constructor for model
+      # @param [Hash] params
+      def initialize(params = {})
+        if params.is_a?(Syncano::Resources::Object)
+          self.syncano_object = params
+          self.attributes = syncano_object_merged_attributes
+          mark_as_saved!
+        else
+          self.syncano_object = self.class.syncano_class.objects.new
+          self.attributes = params
+        end
+      end
+
+      # Gets collection with all objects
+      # @return [Array]
+      def self.all
+        scope_builder.all
+      end
+
+      # Returns first object or collection of first x objects
+      # @param [Integer] amount
+      # @return [Object, Array]
+      def self.first(amount = nil)
+        scope_builder.first(amount)
+      end
+
+      # Returns last object or collection of last x objects
+      # @param [Integer] amount
+      # @return [Object, Array]
+      def self.last(amount = nil)
+        scope_builder.last(amount)
+      end
+
+      # Returns scope builder with condition passed as arguments
+      # @param [String] condition
+      # @param [Array] params
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.where(condition, *params)
+        scope_builder.where(condition, *params)
+      end
+
+      # Returns scope builder with order passed as first argument
+      # @param [String] order
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.order(order)
+        scope_builder.order(order)
+      end
+
+      # Returns one object found by id
+      # @param [Integer] id
+      # @return [Object]
+      def self.find(id)
+        scope_builder.find(id)
+      end
+
+      def reload!
+        syncano_object.reload!
+        self.attributes = syncano_object_merged_attributes
+        mark_as_saved!
+        self
+      end
+
+      # Creates new object with specified attributes
+      # @param [Hash] attributes
+      # @return [Object]
+      def self.create(attributes)
+        new_object = self.new(attributes)
+        new_object.save
+        new_object
+      end
+
+      # Saves object in Syncano
+      # @return [TrueClass, FalseClass]
+      def save
+        if valid?
+          was_persisted = persisted?
+
+          process_callbacks(:before_save)
+          process_callbacks(was_persisted ? :before_update : :before_create)
+
+          syncano_object.custom_attributes = attributes_to_sync
+          syncano_object.save
+          self.attributes = syncano_object_merged_attributes
+          mark_as_saved!
+
+          process_callbacks(was_persisted ? :after_update : :after_create)
+          process_callbacks(:after_save)
+        end
+
+        saved?
+      end
+
+      def self.syncano_class
+        syncano_class
+      end
+
+      # Updates object with specified attributes
+      # @param [Hash] attributes
+      # @return [TrueClass, FalseClass]
+      def update_attributes(attributes)
+        self.attributes = attributes
+        self.save
+      end
+
+      # Returns scope builder with limit parameter set to parameter
+      # @param [Integer] amount
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.limit(amount)
+        scope_builder.limit(amount)
+      end
+
+      # Returns hash with scopes
+      # @return [HashWithIndifferentAccess]
+      def self.scopes
+        self._scopes ||= HashWithIndifferentAccess.new
+      end
+
+      # Overwritten equality operator
+      # @param [Object] object
+      # @return [TrueClass, FalseClass]
+      def ==(object)
+        self.class == object.class && id == object.id
+      end
+
+      # Performs validations
+      # @return [TrueClass, FalseClass]
+      def valid?
+        process_callbacks(:before_validation)
+        process_callbacks(:after_validation) if result = super
+        result
+      end
+
+      # Deletes object from Syncano
+      # @return [TrueClass, FalseClass]
+      def destroy
+        process_callbacks(:before_destroy)
+        syncano_object.destroy
+        process_callbacks(:after_destroy) if syncano_object.destroyed?
+      end
+
+      def destroyed?
+        syncano_object.destroyed?
+      end
+
+      # Checks if object has not been saved in Syncano yet
+      # @return [TrueClass, FalseClass]
+      def new_record?
+        !persisted?
+      end
+
+      # Checks if object has been already saved in Syncano
+      # @return [TrueClass, FalseClass]
+      def persisted?
+        !syncano_object.new_record?
+      end
+
+      def saved?
+        !new_record? && !changed?
+      end
+
+      private
+
+      class_attribute :syncano_class, :_scopes
+      attr_accessor :syncano_object
+
+      def mark_as_saved!
+        raise(Syncano::Error.new('primary key is blank')) if new_record?
+
+        @previously_changed = changes
+        @changed_attributes.clear
+        self
+      end
+
+      # Setter for scopes attribute
+      def self.scopes=(hash)
+        self._scopes = hash
+      end
+
+      # Returns scope builder for current model
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.scope_builder
+        Syncano::Model::ScopeBuilder.new(self)
+      end
+
+      # Defines model scope
+      # @param [Symbol] name
+      # @param [Proc] procedure
+      def self.scope(name, procedure)
+        scopes[name] = procedure
+      end
+
+      # Overwritten method_missing for handling calling defined scopes
+      # @param [String] name
+      # @param [Array] args
+      def self.method_missing(name, *args)
+        if scopes[name].nil?
+          super
+        else
+          scope_builder.send(name.to_sym, *args)
+        end
+      end
+
+      # Returns scope builder for specified class
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def scope_builder(object_class)
+        Syncano::Model::ScopeBuilder.new(object_class)
+      end
+
+      def attributes_to_sync
+        attributes_names = self.class.attributes_to_sync
+        attributes.select{ |name, value| attributes_names.include?(name.to_sym) }
+      end
+
+      def self.attributes_to_sync
+        syncano_class.schema.collect{ |attribute| attribute[:name].to_sym }
+      end
+
+      def syncano_object_merged_attributes
+        syncano_object.attributes.except(:custom_attributes).merge(syncano_object.custom_attributes)
+      end
+
+      def self.inherited(child_class)
+        # Load schema and generate attributes
+        child_class_name = child_class.name.demodulize.tableize.singularize
+        syncano_class = MODEL_SCHEMA.find{ |syncano_class| syncano_class.name == child_class_name }
+
+        syncano_class.schema.each do |attribute_schema|
+          attribute attribute_schema['name'], type: String
+        end
+
+        child_class.syncano_class = syncano_class
+
+        super
+      end
+    end
+  end
+end

data/lib/syncano/model/callbacks.rb

@@ -0,0 +1,49 @@
+module Syncano
+  module Model
+    # Module with callbacks functionality for Syncano::ActiveRecord
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      # Class methods for Syncano::ActiveRecord::Callbacks module
+      module ClassMethods
+        private
+
+        [:validation, :save, :create, :update, :destroy].each do |action|
+          [:before, :after].each do |type|
+            define_method("prepend_#{type}_#{action}") do |argument|
+              send("#{type}_#{action}_callbacks").unshift(argument)
+            end
+
+            define_method("#{type}_#{action}") do |argument|
+              send("#{type}_#{action}_callbacks") << argument
+            end
+          end
+        end
+
+        def inherited(subclass)
+          # Initializes chains for all types of callbacks
+          [:validation, :save, :create, :update, :destroy].each do |action|
+            [:before, :after].each do |type|
+              chain_name = "#{type}_#{action}_callbacks"
+
+              subclass.class_attribute chain_name
+              subclass.send("#{chain_name}=", [])
+            end
+          end
+
+          super
+        end
+      end
+
+      # Processes callbacks with specified type
+      # @param [Symbol, String] type
+      def process_callbacks(type)
+        if respond_to?("#{type}_callbacks")
+          send("#{type}_callbacks").each do |callback_name|
+            send(callback_name)
+          end
+        end
+      end
+    end
+  end
+end