syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/{active_record/association → model/associations}/base.rb

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

data/lib/syncano/{active_record/association → model/associations}/belongs_to.rb

@@ -1,18 +1,18 @@
-require 'syncano/active_record/association/base'
+require 'syncano/model/associations/base'
 
-class Syncano
-  module ActiveRecord
+module Syncano
+  module Model
     module Association
       # Class for belongs to association
-      class BelongsTo < Syncano::ActiveRecord::Association::Base
+      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)
+        def initialize(source_model, name, options = {})
           super
-          self.foreign_key = associated_model.name.foreign_key
+          self.foreign_key = options[:foreign_key] || associated_model.name.foreign_key
         end
 
         # Checks if association is belongs_to type

data/lib/syncano/{active_record/association → model/associations}/has_many.rb

@@ -1,10 +1,10 @@
-require 'syncano/active_record/association/base'
+require 'syncano/model/associations/base'
 
-class Syncano
-  module ActiveRecord
+module Syncano
+  module Model
     module Association
       # Class for has many association
-      class HasMany < Syncano::ActiveRecord::Association::Base
+      class HasMany < Syncano::Model::Association::Base
         attr_reader :associated_model, :foreign_key, :source_model
 
         # Checks if association is has_many type
@@ -24,20 +24,26 @@ class Syncano
 
         # Builds new associated object
         # @return [Object]
-        def build
-          associated_model.new(foreign_key => source.id)
+        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
-          associated_model.create(foreign_key => source.id)
+        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
@@ -55,7 +61,7 @@ class Syncano
         # @param [String] name
         # @param [Array] args
         def method_missing(name, *args)
-          scope_builder = Syncano::ActiveRecord::ScopeBuilder.new(associated_model).by_parent_id(source.id)
+          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)

data/lib/syncano/{active_record/association → model/associations}/has_one.rb

@@ -1,10 +1,10 @@
-require 'syncano/active_record/association/base'
+require 'syncano/model/associations/base'
 
-class Syncano
-  module ActiveRecord
+module Syncano
+  module Model
     module Association
       # Class for has one association
-      class HasOne < Syncano::ActiveRecord::Association::Base
+      class HasOne < Syncano::Model::Association::Base
         attr_reader :associated_model, :foreign_key, :source_model
 
         # Checks if association is has_one type

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/{active_record → model}/callbacks.rb

@@ -1,20 +1,9 @@
-class Syncano
-  module ActiveRecord
+module Syncano
+  module Model
     # Module with callbacks functionality for Syncano::ActiveRecord
     module Callbacks
       extend ActiveSupport::Concern
 
-      included do
-        # Defines chains for all types of callbacks
-        [:validation, :save, :create, :update, :destroy].each do |action|
-          [:before, :after].each do |type|
-            chain_name = "#{type}_#{action}_callbacks"
-            class_attribute chain_name
-            send("#{chain_name}=", [])
-          end
-        end
-      end
-
       # Class methods for Syncano::ActiveRecord::Callbacks module
       module ClassMethods
         private
@@ -30,6 +19,20 @@ class Syncano
             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

data/lib/syncano/{active_record → model}/scope_builder.rb

@@ -1,36 +1,30 @@
-class Syncano
-  module ActiveRecord
+module Syncano
+  module Model
     # ScopeBuilder class allows for creating and chaining more complex queries
     class ScopeBuilder
       # Constructor for ScopeBuilder
       # @param [Class] model
       def initialize(model)
-        raise 'Model should be a class extending module Syncano::ActiveRecord::Base' unless model <= Syncano::ActiveRecord::Base
+        raise 'Model should be a class extending module Syncano::Model::Base' unless model <= Syncano::Model::Base
 
         self.model = model
-        self.parameters = {}
+        self.query = HashWithIndifferentAccess.new
       end
 
       # Returns collection of objects
       # @return [Array]
       def all
-        folder.data_objects.all(parameters).collect do |data_object|
+        model.syncano_class.objects.all(parameters).collect do |data_object|
           model.new(data_object)
         end
       end
 
-      # Returns count of objects
-      # @return [Integer]
-      def count
-        folder.data_objects.all(parameters).count
-      end
-
       # Returns one object found by id
       # @param [Integer] id
       # @return [Object]
       def find(id)
-        parameters[:data_ids] = [id]
-        all.first
+        data_object = model.syncano_class.objects.find(id)
+        data_object.present? ? model.new(data_object) : nil
       end
 
       # Returns first object or collection of first x objects
@@ -53,34 +47,31 @@ class Syncano
       # @param [String] condition
       # @param [Array] params
       # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def where(condition, *params)
-        raise 'Invalid params count in where clause!' unless condition.count('?') == params.count
+      def where(conditions, *params)
+        raise 'Invalid params count in where clause!' unless conditions.count('?') == params.count
 
-        params.each do |param|
-          condition.sub!('?', param.to_s)
-        end
+        params = params.dup
 
-        conditions = condition.gsub(/\s+/, ' ').split(/and/i)
+        conditions.gsub(/\s+/, ' ').split(/and/i).each do |condition|
+          if condition.ends_with?('?')
+            value = params.shift
+            condition.gsub!('?', '').strip!
+          else
+            value = true
+          end
 
-        conditions.each do |condition|
-          attribute, operator, value = condition.split(' ')
+          attribute, operator = condition.split(' ', 2)
+          operator.upcase!
 
           raise 'Invalid attribute in where clause!' unless model.attributes.keys.include?(attribute)
           raise 'Invalid operator in where clause!' unless self.class.where_mapping.keys.include?(operator)
-          raise 'Parameter in where clause is not an integer!' if !(value =~ /\A[-+]?[0-9]+\z/)
 
-          method_name = "#{model.filterable_attributes[attribute]}__#{self.class.where_mapping[operator]}"
-          parameters[method_name] = value
-        end
+          operator = self.class.where_mapping[operator]
 
-        self
-      end
+          query[attribute] = HashWithIndifferentAccess.new if query[attribute].nil?
+          query[attribute][operator] = value
+        end
 
-      # Adds to the current scope builder condition for filtering by parent_id
-      # @param [Integer] parent_id
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def by_parent_id(parent_id)
-        parameters[:parent_ids] = parent_id
         self
       end
 
@@ -88,53 +79,36 @@ class Syncano
       # @param [String] order
       # @return [Syncano::ActiveRecord::ScopeBuilder]
       def order(order)
-        attribute, order_type = order.gsub(/\s+/, ' ').split(' ')
-        raise 'Invalid attribute in order clause' unless (model.attributes.keys + ['id', 'created_at']).include?(attribute)
-
-        attribute = model.map_to_syncano_attribute(attribute)
-        order_type = order_type.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
-
-        self.parameters.merge!({ order_by: attribute, order: order_type })
-
-        self
-      end
-
-      # Adds to the current scope builder condition for filtering by ids newer than provided
-      # @param [Integer, String] id - id or datetime
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def since(id)
-        if !(id =~ /\A[-+]?[0-9]+\z/)
-          self.parameters[:since] = id
+        if order.is_a?(Hash)
+          attribute = order.keys.first
+          order_type = order[attribute]
         else
-          self.parameters[:since_time] = id.to_time
+          attribute, order_type = order.gsub(/\s+/, ' ').split(' ')
         end
-        self
-      end
 
-      # Adds to the current scope builder condition for filtering by ids older than provided
-      # @param [Integer] id
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def before(id)
-        self.parameters[:max_id] = id
-        self
-      end
+        raise 'Invalid attribute in order clause' unless (model.attributes.keys).include?(attribute)
+
+        self.order_clause = order_type.to_s.downcase == 'desc' ? "-#{attribute}" : attribute
 
-      # Adds to the current scope builder limit clause
-      # @param [Integer] amount
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def limit(amount)
-        self.parameters[:limit] = amount
         self
       end
 
+      # # Adds to the current scope builder limit clause
+      # # @param [Integer] amount
+      # # @return [Syncano::ActiveRecord::ScopeBuilder]
+      # def limit(amount)
+      #   self.parameters[:limit] = amount
+      #   self
+      # end
+      #
       private
 
-      attr_accessor :parameters, :model, :scopes
+      attr_accessor :order_clause, :query, :model, :scopes
 
-      # Returns folder for current model
+      # Returns Syncano::Resource class for current model
       # @return [Syncano::Resources::Folder]
-      def folder
-        model.folder
+      def syncano_class
+        model.syncano_class
       end
 
       # Returns scopes for current model
@@ -143,10 +117,20 @@ class Syncano
         model.scopes
       end
 
+      def parameters
+        params = {}
+
+        params[:order_by] = order_clause if order_clause.present?
+        params[:query] = query.to_json if query.present?
+
+        params
+      end
+
       # Returns mapping for operators
       # @return [Hash]
       def self.where_mapping
-        { '=' => 'eq', '!=' => 'neq', '<>' => 'neq', '>=' => 'gte', '>' => 'gt', '<=' => 'lte', '<' => 'lt' }
+        { '=' => '_eq', '!=' => '_neq', '<>' => '_neq', '>=' => '_gte', '>' => '_gt',
+          '<=' => '_lte', '<' => '_lt', 'IS NOT NULL' => '_exists', 'IN' => '_in' }
       end
 
       # Applies scope to the current scope builder