garland 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a00d71fb025dd71c34da87926327385c4278a2a6
-  data.tar.gz: 09a6733560c52e47f1065e35900ad4bbfd4a15c0
+  metadata.gz: 89056f6fadd0309a8e4829b17bdd788cd0643bc9
+  data.tar.gz: 33567da54c9bae23ffa87d26bb95ed3fc95795b0
 SHA512:
-  metadata.gz: 04640cac5d39141ef5030df7d1b2b3b1e56c3b2b4e4ee31550ac9056675cdd55da7451e0332bc4a8b4e16e8998af9855b4c098ffdcf935afb9d17507c6af8a58
-  data.tar.gz: ad3318e2a4b883b3cfe199870b30522c2e471088271eee39b58e9cc021c73d4f979dd164e41ae36493ec62fe7581c8e0f74ef0789c84010c28455dc8aa760c4d
+  metadata.gz: 17f6eec112cd6888fb8e2eac3bf654facaaf1195658739ee39ad1f2ccc2d834dc491e78b42dc92bc3516a8b62e9d655f27f70a7469318e8ce01c5cc44ceea812
+  data.tar.gz: 811a1222362482f420e5fc4db1b915a2a15f60da6a9b84ce39c66d2398c4db02b144167ca69577888d0fd5bd37d7986bf5c575abdca2022059eea54aea5195ce

data/lib/garland_rails.rb

@@ -1,267 +1,10 @@
 module GarlandRails
   DIFF = true
   SNAPSHOT = false
-
-  module Extend
-    def self.included(base)
-      base.extend(self)
-    end
-
-    def has_many(name, scope = nil, options = {}, &extension)
-      name_superclass = name.to_s.classify.constantize.superclass
-      if name_superclass == GarlandRails::Base
-        # if there are no scope and there are some options,
-        # scope will contain options, and we need to swap them
-        if scope.class == Hash
-          options = scope
-          scope = nil
-        end
-
-        belongs_to_type = self.name
-        scope = -> { where(belongs_to_type: belongs_to_type) }
-        options = options.merge(foreign_key: "belongs_to_id")
-      end
-
-      super(name, scope, options, &extension)
-    end
-  end
-
-  class Base < Garland
-    self.table_name = "garlands"
-
-    validates :entity, presence: true
-    validates_inclusion_of :entity_type, in: [DIFF, SNAPSHOT]
-
-    # for given parent object, described by "belongs_to_id" and "belongs_to_type",
-    # there are only one record of each type which is head or tail
-    validates_uniqueness_of :type, scope: [
-      :belongs_to_id,
-      :belongs_to_type,
-      :next_id,
-    ], conditions: -> { where("next_id IS NULL OR previous_id IS NULL") }
-
-    # everything seems to work without `polymorphic: true`,
-    # but we will set it just for accordance to docs
-    def self.belongs_to(name, scope = nil, options = {}, &extension)
-      if scope.class == Hash
-        options = scope
-        scope = nil
-      end
-      options = options.merge(foreign_key: "belongs_to_id")
-
-      super(name, scope, options, &extension)
-    end
-
-    def self.push(args)
-      return nil unless args.class == Hash
-
-      if args[:hash]
-        hash = args[:hash]
-        return nil unless hash.class == Hash
-
-        belongs_to = args[:belongs_to]
-        if belongs_to
-          belongs_to_params = self._split_belongs_to(belongs_to)
-          belongs_to_id, belongs_to_type =
-            belongs_to_params.values_at(:belongs_to_id, :belongs_to_type)
-        end
-      else
-        hash = args
-        belongs_to = nil
-        belongs_to_id = nil
-        belongs_to_type = nil
-      end
-
-      head = self.head(belongs_to)
-      if head
-        diff = self.insert_diff(hash, belongs_to)
-      else
-        diff = self.init(hash, belongs_to)
-      end
-
-      diff
-    end
-
-    def self.thread(belongs_to = nil)
-      if belongs_to
-        return self.where(
-          "belongs_to_id = ? AND belongs_to_type = ?",
-          belongs_to.id, table_type(belongs_to)
-        )
-      else
-        return self.where("belongs_to_id is null AND belongs_to_type is null")
-      end
-    end
-
-    def self.tail(belongs_to = nil)
-      self.thread(belongs_to).find_by(previous_id: nil)
-    end
-
-    def self.head(belongs_to = nil)
-      self.thread(belongs_to).find_by(next_id: nil)
-    end
-
-    def self.last_diff(belongs_to = nil)
-      head = self.head(belongs_to)
-      return nil unless head
-
-      head.previous
-    end
-
-    def next
-      Garland.find(self.next_id) if self.next_id
-    end
-
-    def previous
-      Garland.find(self.previous_id) if self.previous_id
-    end
-
-    def safe_eval_entity
-      return nil unless self.entity =~ /\[.*\]/ || self.entity =~ /{.*}/
-
-      eval(self.entity)
-    end
-
-    def self.table_type(record)
-      record.class.name
-    end
-
-    def self.any?(belongs_to = nil)
-      self.thread(belongs_to).any?
-    end
-
-    def self.init(hash, belongs_to = nil)
-      common_props = self._split_belongs_to(belongs_to)
-
-      tail_props = common_props.merge(entity: {}.to_s, entity_type: SNAPSHOT)
-      brand_new_tail = self.new(tail_props)
-
-      diff = HashDiffSym.diff({}, hash)
-      first_diff_props = common_props.merge(entity: diff.to_s, entity_type: DIFF)
-      first_diff = self.new(first_diff_props)
-
-      head_props = common_props.merge(entity: hash.to_s, entity_type: SNAPSHOT)
-      brand_new_head = self.new(head_props)
-
-      self.transaction do
-         ActiveRecord::Base.connection.create_savepoint("savepoint_before_init")
-
-         # first id: tail ({})
-         # second id: head (latest snapshot)
-         # third+: diffs
-         unless brand_new_tail.save
-           Rails.logger.error("Unable to create new tail with props '#{tail_props}'")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-
-         # belongs_to validations were in `brand_new_tail.save`
-         # here and below validations may be skipped as long as we check for continuity later
-         brand_new_head.save(validate: false)
-         first_diff.save(validate: false)
-         brand_new_tail.update_attribute(:next_id, first_diff.id)
-         first_diff.update_attribute(:previous_id, brand_new_tail.id)
-         first_diff.update_attribute(:next_id, brand_new_head.id)
-         brand_new_head.update_attribute(:previous_id, first_diff.id)
-
-         unless self.continuous?(belongs_to)
-           Rails.logger.error("Initialized garland is not continuous")
-           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_init")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-      end
-
-      first_diff
-    end
-
-    def self.insert_diff(hash, belongs_to = nil)
-      head = self.head(belongs_to)
-      last_diff = self.find_by(id: head.previous_id)
-      common_props = self._split_belongs_to(belongs_to)
-
-      diff = HashDiffSym.diff(head.safe_eval_entity, hash)
-      return unless diff.any?
-
-      new_diff_props = common_props.merge(
-        entity: diff.to_s,
-        entity_type: DIFF,
-        previous_id: last_diff.id,
-        next_id: head.id,
-      )
-      new_diff = self.new(new_diff_props)
-
-      self.transaction do
-         ActiveRecord::Base.connection.create_savepoint("savepoint_before_insert_diff")
-
-         # insert_diff should not use skipping valudatuons methods
-         # because we don't want to check for continuity on every push
-         unless new_diff.save
-           Rails.logger.error("Unable to create new_diff with props '#{new_diff_props}'")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-
-         last_diff.next_id = new_diff.id
-         unless last_diff.save
-           Rails.logger.error("Unable to save last_diff with 'next_id' = '#{new_diff.id}'")
-           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-
-         head.previous_id = new_diff.id
-         unless head.save
-           Rails.logger.error("Unable to save head with 'previous_id' = '#{new_diff.id}'")
-           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-
-         head.entity = hash.to_s
-         unless head.save
-           Rails.logger.error("Unable to save head with 'entity' = '#{hash}'")
-           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
-           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
-           return nil
-         end
-      end
-
-      new_diff
-    end
-
-    def self.continuous?(belongs_to = nil)
-      tail = self.tail(belongs_to)
-      head = self.head(belongs_to)
-      return false unless tail && head
-
-      current_bulb = tail
-      current_hash = tail.safe_eval_entity
-      items_counted = 1
-      while current_bulb.next_id do
-        items_counted += 1
-        current_bulb = current_bulb.next
-        if current_bulb.entity_type == DIFF
-          current_hash = HashDiffSym.patch!(current_hash, current_bulb.safe_eval_entity)
-        else
-          break
-        end
-      end
-
-      items_counted == self.thread(belongs_to).size && current_hash == head.safe_eval_entity
-    end
-
-    private
-      def self._split_belongs_to(belongs_to)
-        if belongs_to
-          belongs_to_id = belongs_to.id
-          belongs_to_type = table_type(belongs_to)
-        else
-          belongs_to_id = nil
-          belongs_to_type = nil
-        end
-
-        { belongs_to_id: belongs_to_id, belongs_to_type: belongs_to_type }
-      end
-  end
 end
+
+require "garland_rails/extend.rb"
+require "garland_rails/base.rb"
+require "garland_rails/utils.rb"
+require "garland_rails/snapshot.rb"
+require "garland_rails/push.rb"

data/lib/garland_rails/base.rb

@@ -0,0 +1,34 @@
+module GarlandRails
+  class Base < Garland
+    self.table_name = "garlands"
+
+    validates :entity, presence: true
+    validates_inclusion_of :entity_type, in: [DIFF, SNAPSHOT]
+
+    # for given parent object, described by "belongs_to_id" and "belongs_to_type",
+    # there are only one record of each type which is head or tail
+    validates_uniqueness_of :type, scope: [
+      :belongs_to_id,
+      :belongs_to_type,
+      :next_id,
+    ], conditions: -> { where("next_id IS NULL OR previous_id IS NULL") }
+
+    # Minitest raises "No visible difference in the *#inspect output" error
+    # while comparing Garland objects without this.
+    def ==(other)
+      self.attributes == other.attributes
+    end
+
+    # everything seems to work without `polymorphic: true`,
+    # but we will set it just for accordance to docs
+    def self.belongs_to(name, scope = nil, options = {}, &extension)
+      if scope.class == Hash
+        options = scope
+        scope = nil
+      end
+      options = options.merge(foreign_key: "belongs_to_id")
+
+      super(name, scope, options, &extension)
+    end
+  end
+end

data/lib/garland_rails/extend.rb

@@ -0,0 +1,25 @@
+module GarlandRails
+  module Extend
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def has_many(name, scope = nil, options = {}, &extension)
+      name_superclass = name.to_s.classify.constantize.superclass
+      if name_superclass == GarlandRails::Base
+        # if there are no scope and there are some options,
+        # scope will contain options, and we need to swap them
+        if scope.class == Hash
+          options = scope
+          scope = nil
+        end
+
+        belongs_to_type = self.name
+        scope = -> { where(belongs_to_type: belongs_to_type) }
+        options = options.merge(foreign_key: "belongs_to_id")
+      end
+
+      super(name, scope, options, &extension)
+    end
+  end
+end

data/lib/garland_rails/push.rb

@@ -0,0 +1,133 @@
+module GarlandRails
+  class Base < Garland
+    def self.push(args)
+      return nil unless args.class == Hash
+
+      if args[:hash]
+        hash = args[:hash]
+        return nil unless hash.class == Hash
+
+        belongs_to = args[:belongs_to]
+        if belongs_to
+          belongs_to_params = self._split_belongs_to(belongs_to)
+          belongs_to_id, belongs_to_type =
+            belongs_to_params.values_at(:belongs_to_id, :belongs_to_type)
+        end
+      else
+        hash = args
+        belongs_to = nil
+        belongs_to_id = nil
+        belongs_to_type = nil
+      end
+
+      head = self.head(belongs_to)
+      if head
+        diff = self.insert_diff(hash, belongs_to)
+      else
+        diff = self.init(hash, belongs_to)
+      end
+
+      diff
+    end
+
+    def self.init(hash, belongs_to = nil)
+      common_props = self._split_belongs_to(belongs_to)
+
+      tail_props = common_props.merge(entity: {}.to_s, entity_type: SNAPSHOT)
+      brand_new_tail = self.new(tail_props)
+
+      diff = HashDiffSym.diff({}, hash)
+      first_diff_props = common_props.merge(entity: diff.to_s, entity_type: DIFF)
+      first_diff = self.new(first_diff_props)
+
+      head_props = common_props.merge(entity: hash.to_s, entity_type: SNAPSHOT)
+      brand_new_head = self.new(head_props)
+
+      self.transaction do
+         ActiveRecord::Base.connection.create_savepoint("savepoint_before_init")
+
+         # first id: tail ({})
+         # second id: head (latest snapshot)
+         # third+: diffs
+         unless brand_new_tail.save
+           Rails.logger.error("Unable to create new tail with props '#{tail_props}'")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+
+         # belongs_to validations were in `brand_new_tail.save`
+         # here and below validations may be skipped as long as we check for continuity later
+         brand_new_head.save(validate: false)
+         first_diff.save(validate: false)
+         brand_new_tail.update_attribute(:next_id, first_diff.id)
+         first_diff.update_attribute(:previous_id, brand_new_tail.id)
+         first_diff.update_attribute(:next_id, brand_new_head.id)
+         brand_new_head.update_attribute(:previous_id, first_diff.id)
+
+         unless self.continuous?(belongs_to)
+           Rails.logger.error("Initialized garland is not continuous")
+           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_init")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+      end
+
+      first_diff
+    end
+
+    def self.insert_diff(hash, belongs_to = nil)
+      head = self.head(belongs_to)
+      last_diff = self.find_by(id: head.previous_id)
+      common_props = self._split_belongs_to(belongs_to)
+
+      diff = HashDiffSym.diff(head.safe_eval_entity, hash)
+      return unless diff.any?
+
+      new_diff_props = common_props.merge(
+        entity: diff.to_s,
+        entity_type: DIFF,
+        previous_id: last_diff.id,
+        next_id: head.id,
+      )
+      new_diff = self.new(new_diff_props)
+
+      self.transaction do
+         ActiveRecord::Base.connection.create_savepoint("savepoint_before_insert_diff")
+
+         # insert_diff should not use skipping valudatuons methods
+         # because we don't want to check for continuity on every push
+         unless new_diff.save
+           Rails.logger.error("Unable to create new_diff with props '#{new_diff_props}'")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+
+         last_diff.next_id = new_diff.id
+         unless last_diff.save
+           Rails.logger.error("Unable to save last_diff with 'next_id' = '#{new_diff.id}'")
+           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+
+         head.previous_id = new_diff.id
+         unless head.save
+           Rails.logger.error("Unable to save head with 'previous_id' = '#{new_diff.id}'")
+           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+
+         head.entity = hash.to_s
+         unless head.save
+           Rails.logger.error("Unable to save head with 'entity' = '#{hash}'")
+           ActiveRecord::Base.connection.exec_rollback_to_savepoint("savepoint_before_insert_diff")
+           ActiveRecord::Base.connection.release_savepoint("savepoint_before_init")
+           return nil
+         end
+      end
+
+      new_diff
+    end
+  end
+end

data/lib/garland_rails/snapshot.rb

@@ -0,0 +1,53 @@
+module GarlandRails
+  class Base < Garland
+    def snapshot(patch_direction = :backward)
+      case patch_direction
+      when :forward
+        approach_nearest_snapshot_method = :previous
+        back_method = :next
+        patch_method = :patch!
+      when :backward
+        approach_nearest_snapshot_method = :next
+        back_method = :previous
+        patch_method = :unpatch!
+      end
+
+      if self.entity_type == SNAPSHOT
+        snapshot = self.safe_eval_entity
+      else
+        nearest_snapshot = self
+        while nearest_snapshot.entity_type != SNAPSHOT do
+          nearest_snapshot = nearest_snapshot.send(approach_nearest_snapshot_method)
+        end
+
+        snapshot = nearest_snapshot.safe_eval_entity
+        current_bulb = nearest_snapshot.send(back_method)
+        loop do
+          break if current_bulb == self
+          HashDiffSym.send(patch_method, snapshot, current_bulb.safe_eval_entity)
+          current_bulb = current_bulb.send(back_method)
+        end
+
+        # this comes from asymmetry of Garland model
+        #
+        # entity => producing snapshot:
+        #
+        # tail  => {}
+        # diff1 => hash1
+        # diff2 => hash2
+        # diff3 => hash3
+        # head  => hash3
+        if patch_direction == :forward
+          HashDiffSym.send(patch_method, snapshot, current_bulb.safe_eval_entity)
+        end
+      end
+
+      Garland.new(
+        entity_type: SNAPSHOT,
+        entity: snapshot.to_s,
+        created_at: self.created_at,
+        type: self.type,
+      )
+    end
+  end
+end

data/lib/garland_rails/utils.rb

@@ -0,0 +1,86 @@
+module GarlandRails
+  class Base < Garland
+    # REVIEW: shouldn't thread(), tail() and head() have the same args as push()?
+    def self.thread(belongs_to = nil)
+      if belongs_to
+        return self.where(
+          "belongs_to_id = ? AND belongs_to_type = ?",
+          belongs_to.id, table_type(belongs_to)
+        )
+      else
+        return self.where("belongs_to_id is null AND belongs_to_type is null")
+      end
+    end
+
+    def self.tail(belongs_to = nil)
+      self.thread(belongs_to).find_by(previous_id: nil)
+    end
+
+    def self.head(belongs_to = nil)
+      self.thread(belongs_to).find_by(next_id: nil)
+    end
+
+    def self.last_diff(belongs_to = nil)
+      head = self.head(belongs_to)
+      return nil unless head
+
+      head.previous
+    end
+
+    def self.continuous?(belongs_to = nil)
+      tail = self.tail(belongs_to)
+      head = self.head(belongs_to)
+      return false unless tail && head
+
+      current_bulb = tail
+      current_hash = tail.safe_eval_entity
+      items_counted = 1
+      while current_bulb.next_id do
+        items_counted += 1
+        current_bulb = current_bulb.next
+        if current_bulb.entity_type == DIFF
+          current_hash = HashDiffSym.patch!(current_hash, current_bulb.safe_eval_entity)
+        else
+          break
+        end
+      end
+
+      items_counted == self.thread(belongs_to).size && current_hash == head.safe_eval_entity
+    end
+    
+    def self.table_type(record)
+      record.class.name
+    end
+
+    def self.any?(belongs_to = nil)
+      self.thread(belongs_to).any?
+    end
+
+    def next
+      Garland.find(self.next_id) if self.next_id
+    end
+
+    def previous
+      Garland.find(self.previous_id) if self.previous_id
+    end
+
+    def safe_eval_entity
+      return nil unless self.entity =~ /\[.*\]/ || self.entity =~ /{.*}/
+
+      eval(self.entity)
+    end
+
+    private
+      def self._split_belongs_to(belongs_to)
+        if belongs_to
+          belongs_to_id = belongs_to.id
+          belongs_to_type = table_type(belongs_to)
+        else
+          belongs_to_id = nil
+          belongs_to_type = nil
+        end
+
+        { belongs_to_id: belongs_to_id, belongs_to_type: belongs_to_type }
+      end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: garland
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Alexander Morozov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashdiff_sym
@@ -33,6 +33,11 @@ extra_rdoc_files: []
 files:
 - lib/garland.rb
 - lib/garland_rails.rb
+- lib/garland_rails/base.rb
+- lib/garland_rails/extend.rb
+- lib/garland_rails/push.rb
+- lib/garland_rails/snapshot.rb
+- lib/garland_rails/utils.rb
 - lib/generators/garland_rails/install_generator.rb
 - lib/generators/garland_rails/templates/install_migration.rb
 - lib/generators/garland_rails/templates/uninstall_migration.rb
@@ -59,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: HashDiff Rails storage