syncano 4.0.0.alpha1 → 4.0.0.alpha2

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

@@ -1,22 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

data/lib/syncano/model/scope_builder.rb

@@ -1,158 +0,0 @@
-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::Model::Base' unless model <= Syncano::Model::Base
-
-        self.model = model
-        self.query = HashWithIndifferentAccess.new
-      end
-
-      # Returns collection of objects
-      # @return [Array]
-      def all
-        model.syncano_class.objects.all(parameters).collect do |data_object|
-          model.new(data_object)
-        end
-      end
-
-      # Returns one object found by id
-      # @param [Integer] id
-      # @return [Object]
-      def find(id)
-        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
-      # @param [Integer] amount
-      # @return [Object, Array]
-      def first(amount = nil)
-        objects = all.first(amount || 1)
-        amount.nil? ? objects.first : objects
-      end
-
-      # Returns last object or last x objects
-      # @param [Integer] amount
-      # @return [Object, Array]
-      def last(amount)
-        objects = all.last(amount || 1)
-        amount.nil? ? objects.first : objects
-      end
-
-      # Adds to the current scope builder condition to the scope builder
-      # @param [String] condition
-      # @param [Array] params
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def where(conditions, *params)
-        raise 'Invalid params count in where clause!' unless conditions.count('?') == params.count
-
-        params = params.dup
-
-        conditions.gsub(/\s+/, ' ').split(/and/i).each do |condition|
-          if condition.ends_with?('?')
-            value = params.shift
-            condition.gsub!('?', '').strip!
-          else
-            value = true
-          end
-
-          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)
-
-          operator = self.class.where_mapping[operator]
-
-          query[attribute] = HashWithIndifferentAccess.new if query[attribute].nil?
-          query[attribute][operator] = value
-        end
-
-        self
-      end
-
-      # Adds to the current scope builder order clause
-      # @param [String] order
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def order(order)
-        if order.is_a?(Hash)
-          attribute = order.keys.first
-          order_type = order[attribute]
-        else
-          attribute, order_type = order.gsub(/\s+/, ' ').split(' ')
-        end
-
-        raise 'Invalid attribute in order clause' unless (model.attributes.keys).include?(attribute)
-
-        self.order_clause = order_type.to_s.downcase == 'desc' ? "-#{attribute}" : attribute
-
-        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 :order_clause, :query, :model, :scopes
-
-      # Returns Syncano::Resource class for current model
-      # @return [Syncano::Resources::Folder]
-      def syncano_class
-        model.syncano_class
-      end
-
-      # Returns scopes for current model
-      # @return [HashWithIndifferentAccess]
-      def scopes
-        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', 'IS NOT NULL' => '_exists', 'IN' => '_in' }
-      end
-
-      # Applies scope to the current scope builder
-      # @param [Symbol] name
-      # @param [Array] args
-      # @return [Syncano::ActiveRecord::ScopeBuilder]
-      def execute_scope(name, *args)
-        procedure = scopes[name]
-        instance_exec(*args, &procedure)
-        self
-      end
-
-      # Overwritten method_missing for handling calling defined scopes
-      # @param [String] name
-      # @param [Array] args
-      def method_missing(name, *args)
-        if scopes[name].nil?
-          super
-        else
-          execute_scope(name, *args)
-        end
-      end
-    end
-  end
-end