animator 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7144168dc13c07de16022b09f83439081574c8fb
+  data.tar.gz: 6af7fba48b1b1eecce204e61d68f153958134301
+SHA512:
+  metadata.gz: 0b6a06284fb6e0642531b53b2f2cca59fd1360241f58c28340624181e20731284e57a3d5297a5059e3a5f34b52e242ce512f58e2189b2a32e08f48a545563771
+  data.tar.gz: 1f34b0ef28dfb97a39bb5d0d3379f91d941ba31d1c14183ff1c0d50197fd45450db395d3b4af2d4059bda7bfb02264056f05e3fc0334e4e2adf286b4debf2b58

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Alec Larsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,25 @@
+Animator
+========
+Inspired by the elegance of [PaperTrail](https://github.com/airblade/paper_trail), Animator is a cleanly namespaced ActiveRecord plugin that hooks into the existing model life-cycle allowing you to to restore (`Animable#reanimate`), query (`Animable.inanimate`), and inspect (`Animable#divine`) destroyed objects including associations without the tedium and ugliness of default scopes, monkey-patched methods, and complex callbacks.
+
+## Getting Started
+Animator is opinionated software that protects every model in the application right out of the box. 
+
+Add it to your `Gemfile` and run the `bundle` command.
+```ruby
+gem 'animator'
+```
+
+Once the gem is installed, run the `animator:install` generator to create the necessary migration and default initializer.
+```console
+rails g animator:install
+```
+
+> **Note:** To selectively enable Animator, delete the initializer in `config/initializers/animator.rb` and include `Animator::Animable` on the desired models manually.
+
+Finally, the database must be migrated to create the `eraminhos` table before Animator will work properly.
+```console
+rake db:migrate
+```
+
+> **Note:** In the very unlikely event that `eraminhos` needs to be preserved for use in the application, Animator may be configured to use an alternative table name by editing the migration and appending `Animator::Eraminho.table_name = 'alternative_table_name_for_eraminhos'` to the initializer.

data/animator.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name          = 'animator'
+  s.version       = '0.0.4'
+  s.platform      = Gem::Platform::RUBY
+  s.summary       = 'Animator is a cleanly namespaced ActiveRecord plugin that hooks into the existing model life-cycle allowing you to to restore (Animable#reanimate), query (Animable.inanimate), and inspect (Animable#divine) destroyed objects including associations without the tedium and ugliness of default scopes, monkey-patched methods, and complex callbacks.'
+  s.description   = s.summary
+  s.homepage      = 'https://github.com/AlecLarsen/animator'
+  s.authors       = ['Alec Larsen']
+  s.email         = 'aleclarsen42@gmail.com'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_rubygems_version = '>= 1.3.6'
+
+  s.add_dependency 'activerecord', ['>= 3.0', '< 5.0']
+  s.add_dependency 'activesupport', ['>= 3.0', '< 5.0']
+
+  s.post_install_message = <<-eos
+
+Animator will not work properly until the eraminhos table has been created. You can generate the proper migration by running `rails g animator:install`.
+
+eos
+end

data/lib/animator.rb

@@ -0,0 +1,7 @@
+require 'animator/eraminho'
+require 'animator/animable'
+require 'animator/fey_relation'
+require 'animator/reanimation_error'
+
+module Animator
+end

data/lib/animator/animable.rb

@@ -0,0 +1,117 @@
+module Animator
+  module Animable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def reanimate!(id, options = {})
+        Eraminho.find_by!(animable_class: name, animable_id: id).animable!.reanimate!(options)
+      end
+
+      def reanimate(id, options = {})
+        reanimate!(id, options) rescue nil
+      end
+
+      def divine(id, options = {}, &block)
+        options = { validate: false }.merge(options)
+
+        result = nil
+
+        transaction do
+          instance = reanimate!(id, options)
+          result = instance.instance_exec(&block)
+          raise ActiveRecord::Rollback
+        end
+
+        result
+      end
+
+      def inanimate(transaction_uuid = nil, relation = all)
+        FeyRelation.new(relation.klass, transaction_uuid).merge(relation)
+      end
+    end
+
+    def divine(options = {}, &block)
+      options = { validate: false }.merge(options)
+
+      result = nil
+      eraminho = @eraminho
+      destroyed = @destroyed
+
+      transaction do
+        reanimate!(options)
+        result = instance_exec(&block)
+        raise ActiveRecord::Rollback
+      end
+
+      @eraminho = eraminho
+      @destroyed = destroyed
+      result
+    end
+
+    def animable?
+      destroyed? && !@eraminho.nil?
+    end
+
+    def reanimate!(options = {}, validation_queue = nil)
+      klass = self.class
+      options = { force: false, transactional: true, validate: true }.merge(options)
+      
+      raise(ReanimationError, "#{inspect} is not animable.") unless animable?
+
+      transaction do
+        if validation_queue
+          run_callbacks(:reanimate) do
+            if options[:transactional]
+              Eraminho.with_transaction_uuid(@eraminho.transaction_uuid).find_each do |eraminho|
+                if options[:force]
+                  eraminho.animable!.reanimate(options.merge(transactional: false, force: false), validation_queue)
+                else
+                  eraminho.animable!.reanimate!(options.merge(transactional: false, force: false), validation_queue)
+                end
+              end
+            else
+              klass.unscoped.insert arel_attributes_with_values_for_create attribute_names
+              validation_queue << self if options[:validate]
+              @eraminho.delete
+            end
+          end
+
+          @eraminho = nil
+          @destroyed = false    
+        else
+          validation_queue = []
+
+          reanimate!(options, validation_queue)
+
+          validation_queue.each do |animable| 
+            unless animable.valid?(:reanimate)
+              raise(ActiveRecord::RecordInvalid.new(animable))
+            end
+          end
+        end
+      end
+
+      self
+    end
+
+    def reanimate(options = {}, validation_queue = nil)
+      reanimate!(options, validation_queue) rescue self
+    end
+
+    def eraminho
+      @eraminho
+    end
+
+    included do
+      define_callbacks :reanimate
+      
+      around_destroy do |animable, &block| 
+        block.call
+
+        unless animable?
+          @eraminho = Eraminho.create!(animable: animable)
+        end
+      end
+    end
+  end
+end

data/lib/animator/eraminho.rb

@@ -0,0 +1,51 @@
+require 'securerandom'
+require 'yaml'
+
+module Animator
+  class Eraminho < ActiveRecord::Base
+    scope :with_animable_id, ->(animable_id) { where(animable_id: animable_id) }
+    scope :with_animable_class, ->(animable_class) { where(animable_class: animable_class) }
+    
+    scope :with_animable_attribute, ->(attribute_name, value) { where(arel_table[:anima].matches("% #{YAML.dump(attribute_name.to_s => value).gsub(/^---\n/, '')}%")) }
+    scope :with_animable_attributes, ->(attributes) { attributes.to_a.reduce(all) { |relation, key_value_pair| relation.with_animable_attribute(*key_value_pair) } }
+    
+    scope :with_transaction_uuid, ->(transaction_uuid) { where(transaction_uuid: transaction_uuid) }
+
+    def animable=(animable)
+      if animable
+        raise(TypeError, "Attempted to set #{animable.inspect} as the animable of an Eraminho, but #{animable.class.name} has not included Animator::Animable") unless animable.is_a?(Animable)
+
+        self.animable_class = animable.class.name
+        self.animable_id = animable[animable.class.primary_key] if animable.class.primary_key
+        self.transaction_uuid = get_current_transaction_uuid(animable.class.connection)
+        self.anima = YAML.dump(animable)
+      end
+
+      @animable = animable
+    end
+
+    def animable
+      animable! rescue nil
+    end
+
+    def animable!
+      unless @animable
+        animable_class.constantize rescue nil # This is required because of ActiveSupport's lazy loading
+        @animable = YAML.load(anima)
+
+        raise(ReanimationError, "#{@animable.class.name} has not included Animator::Animable") unless @animable.is_a?(Animable)
+
+        @animable.instance_variable_set(:@destroyed, true)
+        @animable.instance_variable_set(:@eraminho, self)
+      end
+
+      @animable
+    end
+
+    private
+
+    def get_current_transaction_uuid(connection)
+      connection.current_transaction.instance_eval { @__animator_transaction_uuid__ ||= SecureRandom.uuid }
+    end
+  end
+end

data/lib/animator/fey_relation.rb

@@ -0,0 +1,249 @@
+module Animator
+  class FeyRelation
+    attr_reader :transaction_uuid
+    attr_reader :where_values_hash
+    attr_reader :klass
+
+    def initialize(klass, transaction_uuid = nil, where_values_hash = {}, &block)
+      @transaction_uuid = transaction_uuid
+      @where_values_hash = where_values_hash
+      @klass = klass
+
+      instance_exec(&block) if block
+    end
+
+    def spawn(&block)
+      self.class.new(@klass, @transaction_uuid, @where_values_hash, &block)
+    end
+
+    def where(where_values_hash, &block)
+      self.class.new(@klass, @transaction_uuid, @where_values_hash.merge(where_values_hash), &block)
+    end
+
+    def merge(relation)
+      if relation.is_a?(ActiveRecord::Relation)
+        raise(NotImplementedError, "#{self.class.name} does not support joins.") if relation.joins_values.any? || relation.includes_values.any? || relation.joined_includes_values.any?
+        raise(NotImplementedError, "#{self.class.name} does not support custom select.") if relation.select_values.any?
+        raise(NotImplementedError, "#{self.class.name} does not support aggragation.") if relation.group_values.any? || relation.having_values.any?
+      end
+
+      if relation.respond_to?(:klass, false)
+        raise('Class mismatch while attempting to merge into #{self.class.name}') unless relation.klass == @klass
+      end
+
+      where(relation.where_values_hash) do
+        @limit_value = relation.limit_value if relation.respond_to?(:limit_value, false)
+        @offset_value = relation.offset_value if relation.respond_to?(:offset_value, false)
+      end
+    end
+
+    def all
+      spawn
+    end
+
+    def to_a
+      eraminho_relation.map(&:animable)
+    end
+
+    def take
+      eraminho_relation.take.try(:animable)
+    end
+
+    def take!
+      take || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def find_by(where_values_hash)
+      where(where_values_hash).take
+    end
+
+    def find_by!(where_values_hash)
+      where(where_values_hash).take!
+    end
+
+    def find(id)
+      find_by!(@klass.primary_key => id)
+    end
+
+    def first(limit = nil)
+      if limit
+        eraminho_relation.first(limit).map(&:animable)
+      else
+        eraminho_relation.first.try(:animable)
+      end
+    end
+
+    def first!
+      first || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def last(limit = nil)
+      if limit
+        eraminho_relation.last(limit).map(&:animable)
+      else
+        eraminho_relation.last.try(:animable)
+      end
+    end
+
+    def last!
+      last || raise(ActiveRecord::RecordNotFound)
+    end
+
+    def exists?(where_values_hash = nil)
+      if where_values_hash
+        where(where_values_hash).exists?
+      else
+        eraminho_relation.exists?
+      end
+    end
+
+    def count
+      eraminho_relation.count
+    end
+
+    def pluck(*columns)
+      if columns.count > 1
+        eraminho_relation.map { |eraminho| columns.map { |column| eraminho.animable!.public_send(column) } }
+      else
+        eraminho_relation.map { |eraminho| eraminho.animable!.public_send(columns.first) }
+      end
+    end
+
+    def limit(limit_value)
+      spawn do
+        @limit_value = limit_value
+      end
+    end
+
+    def offset(offset_value)
+      spawn do
+        @offset_value = offset_value
+      end
+    end
+
+    def ids
+      eraminho_relation.pluck(:animable_id)
+    end
+
+    def find_each(options = {}, &block)
+      eraminho_relation.find_each(options) { |eraminho| block.call(eraminho.animable!) }
+    end
+
+    def reset
+      eraminho_relation.reset
+    end
+
+    def loaded?
+      eraminho_relation.loaded?
+    end
+
+    def inspect
+      entries = to_a.take(11).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
+    def ==(other)
+      case other
+      when FeyRelation
+        eraminho_relation.to_sql == other.eraminho_relation.to_sql
+      when Array
+        to_a == other
+      end
+    end
+
+    def reanimate_all!(options = {})
+      options = { force: false, transactional: true, validate: true }.merge(options)
+
+      validation_queue = []
+
+      Eraminho.transaction do
+        if options[:transactional]
+          Eraminho.with_transaction_uuid(eraminho_relation.pluck(:transaction_uuid))
+        else
+          eraminho_relation
+        end.find_each do |eraminho|
+          if options[:force]
+            eraminho.animable!.reanimate(options.merge(transactional: false, force: false), validation_queue)
+          else
+            eraminho.animable!.reanimate!(options.merge(transactional: false, force: false), validation_queue)
+          end
+        end
+
+        validation_queue.each do |animable| 
+          unless animable.valid?(:reanimate)
+            raise(ActiveRecord::RecordInvalid.new(animable))
+          end
+        end
+
+        reset
+      end
+
+      true
+    end
+
+    def reanimate_all(options = {})
+      reanimate_all! rescue false
+    end
+
+    def to_active_record_relation
+      @_active_record_relation ||= @klass.where(@where_values_hash)
+    end
+
+    def divine(options = {}, &block)
+      options = { validate: false }.merge(options)
+
+      result = nil
+
+      @klass.transaction do
+        reanimate_all!(options)
+        result = to_active_record_relation.instance_exec(&block)
+        raise ActiveRecord::Rollback
+      end
+
+      result
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @klass.respond_to?(method_name, false) || [].respond_to?(method_name, false) || super
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @klass.respond_to?(method_name, false)
+        result = to_active_record_relation.public_send(method_name, *args, &block)
+
+        if result.respond_to?(:where_values_hash)
+          result = merge(result)
+        else
+          result
+        end
+      elsif [].respond_to?(method_name, false)
+        to_a.public_send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    protected
+
+    def eraminho_relation
+      unless @eraminho_relation
+        @eraminho_relation = Eraminho.with_animable_class(@klass.name)
+
+        @eraminho_relation = @eraminho_relation.with_transaction_uuid(@transaction_uuid) if @transaction_uuid
+
+        animable_id = @where_values_hash[@klass.primary_key] || @where_values_hash[@klass.primary_key.to_sym]
+        animable_attributes = @where_values_hash.reject { |key| key == @klass.primary_key || key == @klass.primary_key.to_sym }
+
+        @eraminho_relation = @eraminho_relation.with_animable_id(animable_id) if animable_id
+        @eraminho_relation = @eraminho_relation.with_animable_attributes(animable_attributes)
+
+        @eraminho_relation = @eraminho_relation.limit(@limit_value) if @limit_value
+        @eraminho_relation = @eraminho_relation.offset(@offset_value) if @offset_value
+      end
+
+      @eraminho_relation
+    end
+  end
+end

data/lib/animator/reanimation_error.rb

@@ -0,0 +1,4 @@
+module Animator
+  class ReanimationError < StandardError
+  end
+end

data/lib/generators/animator/install_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module Animator
+  class InstallGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'create_eraminhos.rb', 'db/migrate/create_eraminhos.rb'
+      create_file_template 'animator.rb', 'config/initializers/animator.rb'
+    end
+
+    private
+
+    def create_file_template(source, destination)
+      source  = File.expand_path(find_in_source_paths(source.to_s))
+      context = instance_eval('binding')
+      create_file(destination, ERB.new(::File.binread(source), nil, '-', '@output_buffer').result(context))
+    end
+  end
+end

data/lib/generators/animator/templates/animator.rb

@@ -0,0 +1,3 @@
+class ActiveRecord::Base
+  include Animator::Animable
+end

data/lib/generators/animator/templates/create_eraminhos.rb

@@ -0,0 +1,15 @@
+class CreateEraminhos < ActiveRecord::Migration
+  def change
+    create_table :eraminhos do |t|
+      t.string   :transaction_uuid, null: false
+      t.string   :animable_class,   null: false
+      t.integer  :animable_id,      null: true   # Support for tables without a primary key
+      t.text     :anima,            null: false
+      t.datetime :created_at,       null: false
+    end
+
+    add_index :eraminhos, [:animable_class, :animable_id]
+    add_index :eraminhos, [:animable_class, :transaction_uuid]
+    add_index :eraminhos, [:transaction_uuid]
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: animator
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Alec Larsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Animator is a cleanly namespaced ActiveRecord plugin that hooks into
+  the existing model life-cycle allowing you to to restore (Animable#reanimate), query
+  (Animable.inanimate), and inspect (Animable#divine) destroyed objects including
+  associations without the tedium and ugliness of default scopes, monkey-patched methods,
+  and complex callbacks.
+email: aleclarsen42@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- animator.gemspec
+- lib/animator.rb
+- lib/animator/animable.rb
+- lib/animator/eraminho.rb
+- lib/animator/fey_relation.rb
+- lib/animator/reanimation_error.rb
+- lib/generators/animator/install_generator.rb
+- lib/generators/animator/templates/animator.rb
+- lib/generators/animator/templates/create_eraminhos.rb
+homepage: https://github.com/AlecLarsen/animator
+licenses:
+- MIT
+metadata: {}
+post_install_message: |2+
+
+  Animator will not work properly until the eraminhos table has been created. You can generate the proper migration by running `rails g animator:install`.
+
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Animator is a cleanly namespaced ActiveRecord plugin that hooks into the
+  existing model life-cycle allowing you to to restore (Animable#reanimate), query
+  (Animable.inanimate), and inspect (Animable#divine) destroyed objects including
+  associations without the tedium and ugliness of default scopes, monkey-patched methods,
+  and complex callbacks.
+test_files: []