syncano 3.1.1.beta5 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de0d4d181523b5d081bcfffad1a726be2a515cf3
-  data.tar.gz: 7bf73f1a965e8d7ad82c97dc43fa1b3e41fe3f7a
+  metadata.gz: 9c3a289c247f6654d64d2a9510acb205bce778a1
+  data.tar.gz: 23f7bc994f710dd3b4e25be3d2847358506b173d
 SHA512:
-  metadata.gz: ca1c6352decade66e64eecf110f83d9de1ff852c263468c233ce98acd1b74cc9f02deafef4091ee7579823d795fe37d49959cf897576d86048e03f23d3da929f
-  data.tar.gz: 542c9ecbb11261a19e8d49b7c17b81b281c929eafa2e4b28fa00aaaea57a4154c2f9518c8bcd12b2deb1283db56b7cfb2ab46ecbf9019721199cc9d0b12caac8
+  metadata.gz: ffc0eea9c73a2d85d04999f7d2cb7cd3cb3bd199655fa929b8360abbf76f587bacb66983f69ca8986d0879d236f417470a714fa7e00091c4861af8a55a66404f
+  data.tar.gz: 51d2312ec5ba3115266634e9e17742b6501c05232fa4cef96edb292ba95728ceb128f576502bdd1d80ab2e0f20536bf7e7a12f3ed69ba2a97a125793473c3663

data/README.md

@@ -10,7 +10,7 @@ Click here to learn more about [Syncano](http://www.syncano.com) or [create an a
 
 Add this line to your application's Gemfile:
 
-    gem 'syncano', '~> 3.1.1.beta5'
+    gem 'syncano', '~> 3.1.1'
 
 And then execute:
 
@@ -18,7 +18,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install syncano -v 3.1.1.beta5 --pre
+    $ gem install syncano -v 3.1.1
     
 At the end generate initializer with api key and api instance name:
 
@@ -337,6 +337,168 @@ This library does not implement any validations. All errors from the api will ca
 It is thought that user will create his own validation mechanisms specific not only for restrictions imposed by the Syncano, but also for his own logic.
 It can be compared to the exceptions after violating constraints in the MySQL database.
 
+### Integration with Ruby on Rails
+
+Syncano gem provides handy class for implementing model with ActiveRecord pattern. See example below: 
+
+```ruby
+class Category < Syncano::ActiveRecord::Base
+  has_many :articles
+  
+  attribute :name, type: String
+  validates :name, presence: true  
+end
+
+class Article < Syncano::ActiveRecord::Base
+  belongs_to :category
+  
+  attribute :title, type: String
+  attribute :text, type: String
+  attribute :promoted, type: Integer, filterable: :data1
+  validates :title, presence: true
+  validates :text, presence: true
+  
+  scope :promoted, -> { where('promoted = ?', 1) }
+  
+  before_save :sanitize_content
+  
+  private
+  
+  def sanitize_content
+    self.title = Sanitize.clean(title)
+    self.text = Sanitize.clean(text)
+  end
+end
+```
+
+#### Attributes
+
+As you can see above every attribute has to be declared with a type. Every ActiveRecord class has also three standard attributes:
+- :id, type: Integer
+- :created_at, type: DateTime
+- :updated_at, type: DateTime
+
+There can be up to three filterable attributes (mapped to the Syncano data1, data2, data3 attributes), which can be used in where and order clauses. They always should have Integer type.
+   
+Attributes can be validated like in standard ActiveRecord.
+
+#### Scopes and query building
+
+You can sort and filter by filterable attributes:
+
+```ruby
+where('attribute1 > ? AND attribute2 <= ?', 0, 30).order('attribute3 ASC').where('attribute 2 > ?', 5)
+```
+
+As you can see methods can be chained. 
+
+#### Callbacks
+
+There are available ten different callbacks fired in the following sequence:
+
+1. before_validation
+2. after_validation
+3. before_save
+4. before_create / before_update
+5. after_create / after_save
+6. after_save
+
+1. before_destroy
+2. after_destroy
+
+#### Associations
+
+There are three types of relations (belongs_to, has_one, has_many) which are based on Syncano parent - child mechanism.
+
+##### belongs_to :category
+
+Adds following methods:
+
+```ruby
+self.category
+self.category = Category.first
+self.category_id
+self.category_id = Category.first.id
+```
+
+Remember to always declare belongs_to association! It creates proper attribute in model.
+
+##### has_one :article
+
+```ruby
+self.article
+self.article = Article.first # this method updates article object
+self.build_article(article_attributes)
+self.create_article(article_attributes)
+```
+
+##### has_many :articles
+
+```ruby
+self.articles
+self.articles = Article.first(5) # this method updates each article object
+self.articles << Article.first # this method updates article object
+self.articles.build(article_attributes)
+self.articles.create(article_attributes)
+```
+
+You can also call scope builder methods on has_many collection:
+
+```ruby
+self.articles.promoted.all
+```
+
+#### Other useful methods in examples
+
+```ruby
+Article.promoted.find(id)
+Article.where('promoted = ?', 0).count
+Article.since(min_id).before(max_id)
+Article.since(Time.now - 10.days)
+```
+
+For all methods please see reference for Syncano::ActiveRecord::Base class.
+
+#### Collection and folders
+
+Classes which inherit from Syncano::ActiveRecord::Base needs a collection and a folders in Syncano. 
+
+Collection can be configured as constant in initializer:
+ 
+```ruby
+SYNCANO_ACTIVERECORD_COLLECTION = Syncano.client.project.first.collection.first
+```
+
+or it can be overwritten in selected model:
+
+```ruby
+class Article < Syncano::ActiveRecord::Base
+
+  private
+  
+  def self.collection
+    Syncano.client.project.first.collection.first
+  end
+end
+```
+
+Folders are used as classes - each model as his own folder (ie. Articles). Folder is automatically created and used without any additional configuration, but you can customize convention by overwriting folder_name or folder method:
+
+```ruby
+class Article < Syncano::ActiveRecord::Base
+
+  private
+  
+  def self.folder_name
+    'Posts'
+  end
+  
+  def self.folder
+    collection.folders.find_by_name(folder_name)
+  end
+end
+```
+
 ## Contributing
 
 1. Fork it

data/lib/active_attr/dirty.rb

@@ -0,0 +1,40 @@
+require 'active_support'
+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
+
+    # 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

data/lib/generators/syncano/templates/initializers/syncano.rb

@@ -1,4 +1,7 @@
 # Syncano instance name
 SYNCANO_INSTANCE_NAME = 'instance_name'
 # Syncano api key
-SYNCANO_API_KEY = 'api_key'
+SYNCANO_API_KEY = 'api_key'
+
+# Collection used for Syncano::ActiveRecord
+# SYNCANO_ACTIVERECORD_COLLECTION = Syncano.client.projects.first.collections.first

data/lib/syncano.rb

@@ -59,6 +59,16 @@ 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'
+
+# ActiveModel
+require 'active_model/forbidden_attributes_protection'
+require 'active_model/dirty'
+
+# ActiveAttr
+require 'active_attr/model'
+require 'active_attr/dirty'
 
 # Syncano
 require 'syncano/errors'
@@ -92,4 +102,5 @@ 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/resources/notifications/message'
+require 'syncano/active_record/base'

data/lib/syncano/active_record/association/base.rb

@@ -0,0 +1,38 @@
+require 'syncano/active_record/scope_builder'
+
+class Syncano
+  module ActiveRecord
+    # 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)
+          self.source_model = source_model
+          self.associated_model = name.to_s.classify.constantize
+          self.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/active_record/association/belongs_to.rb

@@ -0,0 +1,30 @@
+require 'syncano/active_record/association/base'
+
+class Syncano
+  module ActiveRecord
+    module Association
+      # Class for belongs to association
+      class BelongsTo < Syncano::ActiveRecord::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)
+          super
+          self.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/active_record/association/has_many.rb

@@ -0,0 +1,69 @@
+require 'syncano/active_record/association/base'
+
+class Syncano
+  module ActiveRecord
+    module Association
+      # Class for has many association
+      class HasMany < Syncano::ActiveRecord::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
+          associated_model.new(foreign_key => source.id)
+        end
+
+        # Creates new associated object
+        # @return [Object]
+        def create
+          associated_model.create(foreign_key => source.id)
+        end
+
+        # Adds object to the related collection by setting foreign key
+        # @param [Object] object
+        # @return [Object]
+        def <<(object)
+          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::ActiveRecord::ScopeBuilder.new(associated_model).by_parent_id(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/active_record/association/has_one.rb

@@ -0,0 +1,22 @@
+require 'syncano/active_record/association/base'
+
+class Syncano
+  module ActiveRecord
+    module Association
+      # Class for has one association
+      class HasOne < Syncano::ActiveRecord::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/active_record/associations.rb

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

data/lib/syncano/active_record/base.rb

@@ -0,0 +1,318 @@
+require 'syncano/active_record/scope_builder'
+require 'syncano/active_record/associations'
+require 'syncano/active_record/callbacks'
+
+class Syncano
+  # Scope for modules and classes integrating ActiveRecord functionality
+  module ActiveRecord
+    # Class for integrating ActiveRecord functionality
+    class Base
+      include ActiveAttr::Model
+      include ActiveAttr::Dirty
+      include ActiveModel::ForbiddenAttributesProtection
+      include Syncano::ActiveRecord::Associations
+      include Syncano::ActiveRecord::Callbacks
+
+      attribute :id, type: Integer
+      attribute :created_at, type: DateTime
+      attribute :updated_at, type: DateTime
+
+      # Gets collection with all objects
+      # @return [Array]
+      def self.all
+        scope_builder.all
+      end
+
+      # Counts all objects
+      # @return [Integer]
+      def self.count
+        scope_builder.count
+      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
+
+      # 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
+
+      # Returns scope builder with filtering by ids newer than provided
+      # @param [Integer] id
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.since(id)
+        scope_builder.since(id)
+      end
+
+      # Returns scope builder with filtering by ids older than provided
+      # @param [Integer] id
+      # @return [Syncano::ActiveRecord::ScopeBuilder]
+      def self.before(id)
+        scope_builder.before(id)
+      end
+
+      # Returns corresponding Syncano folder
+      # @return [Syncano::Resources::Folder]
+      def self.folder
+        begin
+          folder = collection.folders.find_by_name(folder_name)
+        rescue Syncano::ApiError => e
+          if e.message.starts_with?('DoesNotExist')
+            folder = collection.folders.create(name: folder_name)
+          else
+            raise e
+          end
+        end
+        folder
+      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 filterable attributes
+      # @return [HashWithIndifferentAccess]
+      def self.filterable_attributes
+        self._filterable_attributes ||= HashWithIndifferentAccess.new
+      end
+
+      # Returns hash with scopes
+      # @return [HashWithIndifferentAccess]
+      def self.scopes
+        self._scopes ||= HashWithIndifferentAccess.new
+      end
+
+      # Maps syncano attributes to corresponding model attributes
+      # @param [Hash] attributes
+      # @return [HashWithIndifferentAccess]
+      def self.map_from_syncano_attributes(attributes = {})
+        mappings = HashWithIndifferentAccess.new(filterable_attributes.invert)
+        HashWithIndifferentAccess[attributes.map {|k, v| [mappings[k] || k, v] }]
+      end
+
+      # Maps model attributes to corresponding syncano attributes
+      # @param [Hash] attributes
+      # @return [HashWithIndifferentAccess]
+      def self.map_to_syncano_attributes(attributes = {})
+        mappings = filterable_attributes
+        HashWithIndifferentAccess[attributes.map {|k, v| [mappings[k] || k, v] }]
+      end
+
+      # Maps one model attribute to corresponding syncano attribute
+      # @param [Symbol, String] attribute
+      # @return [String]
+      def self.map_to_syncano_attribute(attribute)
+        mappings = filterable_attributes
+        mappings[attribute] || attribute
+      end
+
+      # Constructor for model
+      # @param [Hash] params
+      def initialize(params = {})
+        if params.is_a?(Syncano::Resources::DataObject)
+          super(self.class.map_from_syncano_attributes(params.attributes).merge(id: params.id))
+        else
+          params.delete(:id)
+          super(self.class.map_from_syncano_attributes(params))
+        end
+      end
+
+      # Overwritten equality operator
+      # @param [Object] object
+      # @return [TrueClass, FalseClass]
+      def ==(object)
+        self.class == object.class && self.id == object.id
+      end
+
+      # Updates object with specified attributes
+      # @param [Hash] attributes
+      # @return [TrueClass, FalseClass]
+      def update_attributes(attributes)
+        self.attributes = attributes
+        self.save
+      end
+
+      # Performs validations
+      # @return [TrueClass, FalseClass]
+      def valid?
+        process_callbacks(:before_validation)
+        process_callbacks(:after_validation) if result = super
+        result
+      end
+
+      # Saves object in Syncano
+      # @return [TrueClass, FalseClass]
+      def save
+        saved = false
+
+        if valid?
+          process_callbacks(:before_save)
+          process_callbacks(persisted? ? :before_update : :before_create)
+
+          data_object = persisted? ? self.class.folder.data_objects.find(id) : self.class.folder.data_objects.new
+          data_object.attributes = self.class.map_to_syncano_attributes(attributes.except(:id, :created_at, :updated_at))
+          data_object.save
+
+          if data_object.saved?
+            self.updated_at = data_object[:updated_at]
+
+            if persisted?
+              process_callbacks(:after_update)
+            else
+              self.id = data_object.id
+              self.created_at = data_object[:created_at]
+              process_callbacks(:after_create)
+            end
+
+            self.class.associations.values.select{ |association| association.belongs_to? }.each do |association|
+              change = changes[association.foreign_key]
+
+              if change.present?
+                if change.last.nil? || association.associated_model.find(change.last).present?
+                  data_object.remove_parent(change.first) unless change.first.nil?
+                  data_object.add_parent(change.last) unless change.last.nil?
+                end
+              end
+            end
+
+            super
+
+            process_callbacks(:after_save)
+            saved = true
+          end
+        end
+
+        saved
+      end
+
+      # Deletes object from Syncano
+      # @return [TrueClass, FalseClass]
+      def destroy
+        process_callbacks(:before_destroy)
+        data_object = self.class.folder.data_objects.find(id)
+        data_object.destroy
+        process_callbacks(:after_destroy) if data_object.destroyed
+        data_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?
+        id.present?
+      end
+
+      private
+
+      class_attribute :_filterable_attributes, :_scopes
+
+      # Returns Syncano collection for storing Syncano::ActiveRecord objects
+      # @return [Syncano::Resource::Collection]
+      def self.collection
+        SYNCANO_ACTIVERECORD_COLLECTION
+      end
+
+      # Returns Syncano collection for storing Syncano::ActiveRecord objects
+      # @return [Syncano::Resource::Collection]
+      def self.folder_name
+        name.pluralize
+      end
+
+      # Setter for filterable_attributes attribute
+      def self.filterable_attributes=(hash)
+        self._filterable_attributes = hash
+      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::ActiveRecord::ScopeBuilder.new(self)
+      end
+
+      # Defines model attribute
+      # @param [Symbol] name
+      # @param [Hash] options
+      def self.attribute(name, options = {})
+        if options[:filterable].present?
+          self.filterable_attributes = HashWithIndifferentAccess.new if filterable_attributes.nil?
+          filterable_attributes[name] = options.delete(:filterable)
+        end
+        super(name, options)
+      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::ActiveRecord::ScopeBuilder.new(object_class)
+      end
+    end
+  end
+end

data/lib/syncano/active_record/callbacks.rb

@@ -0,0 +1,46 @@
+class Syncano
+  module ActiveRecord
+    # 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
+
+        [: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
+      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/active_record/scope_builder.rb

@@ -0,0 +1,174 @@
+class Syncano
+  module ActiveRecord
+    # 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
+
+        self.model = model
+        self.parameters = {}
+      end
+
+      # Returns collection of objects
+      # @return [Array]
+      def all
+        folder.data_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
+      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(condition, *params)
+        raise 'Invalid params count in where clause!' unless condition.count('?') == params.count
+
+        params.each do |param|
+          condition.sub!('?', param.to_s)
+        end
+
+        conditions = condition.gsub(/\s+/, ' ').split(/and/i)
+
+        conditions.each do |condition|
+          attribute, operator, value = condition.split(' ')
+
+          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
+
+        self
+      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
+
+      # Adds to the current scope builder order clause
+      # @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
+        else
+          self.parameters[:since_time] = id.to_time
+        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
+
+      # 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
+
+      # Returns folder for current model
+      # @return [Syncano::Resources::Folder]
+      def folder
+        model.folder
+      end
+
+      # Returns scopes for current model
+      # @return [HashWithIndifferentAccess]
+      def scopes
+        model.scopes
+      end
+
+      # Returns mapping for operators
+      # @return [Hash]
+      def self.where_mapping
+        { '=' => 'eq', '!=' => 'neq', '<>' => 'neq', '>=' => 'gte', '>' => 'gt', '<=' => 'lte', '<' => 'lt' }
+      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

data/lib/syncano/resources/base.rb

@@ -126,16 +126,18 @@ class Syncano
       # @return [Syncano::Resources::Base]
       def save
         response = perform_save(nil)
+        response_data = ActiveSupport::HashWithIndifferentAccess.new(response.data)
 
         if new_record?
-          response_data = ActiveSupport::HashWithIndifferentAccess.new(response.data)
           created_object = self.class.new(client, self.class.map_to_scope_parameters(attributes).merge(response_data))
 
           self.id = created_object.id
           self.attributes.merge!(created_object.attributes)
-          mark_as_saved!
+        else
+          self[:updated_at] = response_data[:updated_at]
         end
 
+        mark_as_saved!
         self
       end
 

data/lib/syncano/resources/data_object.rb

@@ -211,6 +211,11 @@ class Syncano
           end
         end
 
+        if attributes.keys.map(&:to_sym).include?(:folders) && !attributes.keys.map(&:to_sym).include?(:folder)
+          attributes[:folder] = attributes[:folders]
+          attributes.delete(:folders)
+        end
+
         attributes.delete(:user)
         attributes.delete(:created_at)
         attributes.delete(:updated_at)

data/lib/syncano/resources/folder.rb

@@ -5,7 +5,7 @@ class Syncano
       # Association has_many :data_objects
       # @return [Syncano::QueryBuilder] query builder for resource Syncano::Resources::DataObject
       def data_objects
-        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::DataObject, scope_parameters.merge(folder: @saved_attributes[:name]))
+        ::Syncano::QueryBuilder.new(client, ::Syncano::Resources::DataObject, scope_parameters.merge(folders: @saved_attributes[:name]))
       end
 
       # Wrapper for api "get_one" method with folder_name as a key

data/lib/syncano/version.rb

@@ -1,4 +1,4 @@
 class Syncano
   # Syncano version number
-  VERSION = '3.1.1.beta5'
+  VERSION = '3.1.1'
 end

data/syncano.gemspec

@@ -20,8 +20,10 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'jimson-client'
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'activemodel'
   spec.add_dependency 'multi_json', '~> 1.10'
   spec.add_dependency 'eventmachine'
+  spec.add_dependency 'active_attr'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syncano
 version: !ruby/object:Gem::Version
-  version: 3.1.1.beta5
+  version: 3.1.1
 platform: ruby
 authors:
 - Piotr Zadrożny
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-11 00:00:00.000000000 Z
+date: 2014-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jimson-client
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -163,9 +191,18 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/active_attr/dirty.rb
 - lib/generators/syncano/install_generator.rb
 - lib/generators/syncano/templates/initializers/syncano.rb
 - lib/syncano.rb
+- lib/syncano/active_record/association/base.rb
+- lib/syncano/active_record/association/belongs_to.rb
+- lib/syncano/active_record/association/has_many.rb
+- lib/syncano/active_record/association/has_one.rb
+- lib/syncano/active_record/associations.rb
+- lib/syncano/active_record/base.rb
+- lib/syncano/active_record/callbacks.rb
+- lib/syncano/active_record/scope_builder.rb
 - lib/syncano/batch_queue.rb
 - lib/syncano/batch_queue_element.rb
 - lib/syncano/clients/base.rb
@@ -227,9 +264,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
@@ -248,3 +285,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/sync_resources_spec.rb
 - spec/syncano_spec.rb
+has_rdoc: