moribus 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDcwN2E3NWU5NjI0MDk4OTU1NWE4OGVlYjEwZmViNmRkZTkzMDZjNQ==
+  data.tar.gz: !binary |-
+    OGM1MjU5YzVmMzA0YzViZWNlNDBkZWNjYjljNTQ1YWNlOGNkODkzOA==
+SHA512:
+  metadata.gz: !binary |-
+    YjRmMTY0MWJiNjcwNjU0ZDI3OGIyNDk4ZDQ3ZTVkNmY5YTJjNzU0NTE3NWI0
+    NzFmNWM3MWQ3YmNkNzliZmUzZWMzNjg2ZWQzOGNlN2FlMDA4NzJiNWYwMDAy
+    OTg1OWNhYmUwNTA2NDNmZjJiYzM0NGUwODk2OTZiMGIyM2FkMGQ=
+  data.tar.gz: !binary |-
+    YWQ4MmRjYzBkZGE4MWVlNmExNmJiNDk3ZjFjY2Y2OGZlMTZmOGRmMmRiOTll
+    Yjk1YzFkNjA1OGIxMTJjNTRmMTYyZWQ4ZWRlMTg2ZWQzODQ5ZWFhZDhlNWQ3
+    MDNmOGVkZTYwZjE4OGQ4ZjI4MGQxNDk1ZThkYjIzODhhMTliM2U=

data/.gitignore

@@ -0,0 +1,35 @@
+# simplecov generated
+coverage
+coverage.data
+!coverage/.resultset.json
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+*.gem
+Gemfile.lock
+
+# IDE generated
+.idea
+
+log/*.log
+spec/dummy/log/*.log
+
+# exclude everything in tmp
+tmp/*
+# except the metric_fu directory
+!tmp/metric_fu/
+# but exclude everything *in* the metric_fu directory
+tmp/metric_fu/*
+# except for the _data directory to track metrical outputs
+!tmp/metric_fu/_data/

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format nested
+--order rand
+--profile

data/.ruby-gemset

@@ -0,0 +1 @@
+moribus

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3

data/.simplecov

@@ -0,0 +1,42 @@
+require "simplecov-rcov-text"
+require "colorized_text"
+include ColorizedText
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::RcovTextFormatter,
+  SimpleCov::Formatter::HTMLFormatter
+]
+SimpleCov.start do
+  add_filter "/spec/"
+
+  # Fail the build when coverage is weak:
+  at_exit do
+    SimpleCov.result.format!
+    threshold, actual = 98.475, SimpleCov.result.covered_percent
+    if actual < threshold
+      msg = "\nLow coverage: "
+      msg << red("#{actual}%")
+      msg << " is #{red 'under'} the threshold: "
+      msg << green("#{threshold}%.")
+      msg << "\n"
+      $stderr.puts msg
+      exit 1
+    else
+      # Precision: three decimal places:
+      actual_trunc = (actual * 1000).floor / 1000.0
+      msg = "\nCoverage: "
+      msg << green("#{actual}%")
+      msg << " is #{green 'over'} the threshold: "
+      if actual_trunc > threshold
+        msg << bold(yellow("#{threshold}%. "))
+        msg << "Please update the threshold to: "
+        msg << bold(green("#{actual_trunc}% "))
+        msg << "in ./.simplecov."
+      else
+        msg << green("#{threshold}%.")
+      end
+      msg << "\n"
+      $stdout.puts msg
+    end
+  end
+end

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+notifications:
+  email:
+    - a.kuzko@gmail.com

data/Gemfile

@@ -0,0 +1,19 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in moribus.gemspec
+gemspec
+
+gem "power_enum", "~> 1.3"
+
+group :development do
+  gem "redcarpet"
+  gem "yard"
+  gem "pry"
+end
+
+group :test do
+  gem "simplecov",           :require => false
+  gem "simplecov-rcov-text", :require => false
+
+  gem "timecop"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 TMXCredit, authors Artem Kuzko, Sergey Potapov
+
+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,104 @@
+# Moribus
+
+[![Build Status](https://secure.travis-ci.org/TMXCredit/moribus.png)](http://travis-ci.org/TMXCredit/moribus)
+
+Moribus is a set of tools for managing complex graphs of ActiveRecord objects
+for which there are many inbound foreign keys, attributes and associations with
+high rates of change, and business demands for well-tracked change history.
+
+##AggregatedBehavior
+
+AggregatedBehavior implements a pattern in which an object's identity
+is modeled apart from its attributes and outbound associations. This enables
+higher level of normalization of your data, since one set of properties
+may be shared among multiple objects. This set of properties - attributes
+and outbound associations - are modeled on an object called an "info object".
+And we say that this info object is aggregated by host object(s) and it acts
+(behaves) as aggregated. When an aggregated object is about to be saved, it
+looks up for an existing record with the same attributes in the database under
+the hood, and if it founds, it 'replaces' itself by that record. This allows
+you to work with attributes of your entity as if they are properties of an
+actual model and normalize your data at the same time.
+
+Inbound foreign keys will always point at the same object in memory, and the
+object will never be stale, as it has no attributes of its own that are subject
+to change. This is useful for objects with many inbound foreign keys and
+high-traffic attributes/associations, such as statuses. Without this pattern
+it would be difficult to avoid many StaleObjectErrors.
+
+##TrackedBehavior
+
+TrackedBehavior implements history tracking on the stack of objects
+representing the identity object's attributes and outbound associations.
+When a model behaves as a tracked behavior, it will never get actually
+updated. Instead, it will update it's own 'is_current' column to false
+and will be saved as a new record with new attribute values and
+'is_current' column as 'true'. Thus, under the hood, new attributes
+will supersede old attributes, leaving old record as history one.
+
+##Macros, Associations and Combination
+
+Despite the fact that Behaviors may be used by models on they're own,
+they main purpose is to be used within associations and in conjunction.
+The best way to demonstrate this is by example.
+
+Lets assume we have a User entity with attributes that should be tracked
+and normalized. Those attributes may be, for example, `:first_name`,
+`:last_name` and `:status` as enumerated integer value. This makes entity
+may be represented with three models: `User` - as main model for interactions,
+tracked `UserInfo` (`user_id`, `person_name_id`, `status`) for tracking, and
+aggregated `UserName` (`first_name`, `last_name`) for name normalization.
+Class definitions for that models will look as follows:
+
+```ruby
+  class User < ActiveRecord::Base
+    has_one_current :user_info
+    delegate_associated :user_name, :to => :user_info
+  end
+
+  class UserInfo < ActiveRecord::Base
+    has_aggregated :person_name
+    acts_as_tracked
+  end
+
+  class UserName < ActiveRecord::Base
+    acts_as_aggregated
+  end
+```
+
+Despite the fact that internal representation is more complicated now,
+top-level operations will look exactly the same:
+
+```ruby
+  user = User.create(:first_name => 'John', :last_name => 'Smith', :status => 0)
+  # This creates User(id: 1) record, PersonName(id: 1, first_name: 'John', last_name: 'Smith')
+  # record and UserInfo(id: 1, user_id: 1, person_name_id: 1, status: 0, is_current: true)
+
+  user.update_attributes(:status => 1)
+  # This creates new UserInfo(id: 2, user_id: 1, person_name_id: 1, status: 1, is_current: true)
+  # record, and changes UserInfo(id: 1) record's 'is_current' attribute to false.
+
+  user.update_attributes(:first_name => 'Mike')
+  # This creates new PersonName(id: 2, first_name: 'Mike', last_name: 'Smith') record and new
+  # current UserInfo(id: 3, user_id: 1, person_name_id: 2, :status: 1, is_current: true)
+
+  # Now, if we want to create another 'John Smith' user:
+  user2 = User.create(:first_name => 'John', :last_name => 'Smith', :status => 5)
+  # This creates User(id: 2) record and UserInfo(id: 4, user_id: 2, person_name_id: 1, status: 5, is_current: true)
+  # record that reuses existing UserName information.
+```
+
+## Run tests
+
+```sh
+rake spec
+```
+
+## Credits
+
+* [Artem Kuzko](https://github.com/akuzko)
+* [Potapov Sergey](https://github.com/greyblake)
+
+## Copyright
+
+Copyright (c) 2013 TMX Credit.

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "moribus #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/colorized_text.rb

@@ -0,0 +1,33 @@
+# Colorizes text with ASCII colors.
+# == Usage:
+#   include ColorizedText
+#
+#   puts green "OK"          # => green output
+#   puts bold "Running...    # => bold output
+#   puts bold green "OK!!!"  # => bold green output
+module ColorizedText
+  # Colorize text using ASCII color code
+  def colorize(text, code)
+    "\033[#{code}m#{text}\033[0m"
+  end
+
+  # :nodoc:
+  def yellow(text)
+    colorize(text, 33)
+  end
+
+  # :nodoc:
+  def green(text)
+    colorize(text, 32)
+  end
+
+  # :nodoc:
+  def red(text)
+    colorize(text, 31)
+  end
+
+  # :nodoc:
+  def bold(text)
+    colorize(text, 1)
+  end
+end

data/lib/moribus.rb

@@ -0,0 +1,133 @@
+# Introduces Aggregated and Tracked behavior to ActiveRecord::Base models, as well
+# as Macros and Extensions modules for more efficient usage. Effectively replaces
+# both Aggregatable and Trackable modules.
+module Moribus
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :AliasAssociation
+  autoload :AggregatedBehavior
+  autoload :AggregatedCacheBehavior
+  autoload :TrackedBehavior
+  autoload :Macros
+  autoload :Extensions
+
+  included do
+    include AliasAssociation
+    include Extensions
+    extend Macros
+  end
+
+  # :nodoc:
+  module ClassMethods
+    # Adds aggregated behavior to a model.
+    def acts_as_aggregated(options = {})
+      options.symbolize_keys!
+
+      options.assert_valid_keys(:cache_by, :non_content_columns)
+      include AggregatedBehavior
+
+      if options[:cache_by].present?
+        @aggregated_caching_column = options[:cache_by]
+        include AggregatedCacheBehavior
+      end
+
+      if options[:non_content_columns]
+        self.aggregated_behaviour_non_content_columns += Array.wrap(options[:non_content_columns]).map(&:to_s)
+      end
+    end
+    private :acts_as_aggregated
+
+    # Adds tracked behavior to a model
+    def acts_as_tracked(options = {})
+      options.symbolize_keys!
+
+      options.assert_valid_keys(:preceding_key)
+      include TrackedBehavior
+
+      @preceding_key_column = options[:preceding_key]
+    end
+    private :acts_as_tracked
+
+    # Return +true+ if self was declared as +acts_as_aggregated+.
+    def acts_as_aggregated?
+      self < AggregatedBehavior
+    end
+
+    # Return +true+ if self was declared as +acts_as_tracked+.
+    def acts_as_tracked?
+      self < TrackedBehavior
+    end
+  end
+
+  # Marks +self+ as a new record. Sets +id+ attribute to nil, but memorizes
+  # the old value in case of exception.
+  def to_new_record!
+    store_before_to_new_record_values
+    reset_persistence_values
+    @new_record = true
+  end
+
+  # Marks +self+ as persistent record. If another record is passed, uses its
+  # persistence attributes (id, timestamps). If nil is passed as an argument,
+  # marks +self+ as persisted record and sets +id+ to memorized value.
+  def to_persistent!(existing = nil)
+    if existing
+      self.id         = existing.id
+      self.created_at = existing.created_at if respond_to?(:created_at)
+      self.updated_at = existing.updated_at if respond_to?(:updated_at)
+      @changed_attributes = {}
+    else
+      restore_before_to_new_record_values
+    end
+    @new_record = false
+    true
+  end
+
+  # Stores original record id for tracking purposes.
+  def set_parent
+    tbc = self.class.preceding_key_column
+    if tbc && self.respond_to?(tbc)
+      write_attribute(tbc, @_before_to_new_record_values[:id])
+    end
+  end
+
+  # Helper method used by has_aggregated (in fact, belongs_to)
+  # association during autosave.
+  def updated_as_aggregated?
+    !!@updated_as_aggregated
+  end
+
+  # Save persistence values of id, updated_at and created_at to instance
+  # variable to have an ability to set them back if object fails to
+  # be saved.
+  def store_before_to_new_record_values
+    values = {:id => id}
+    values[:updated_at] = updated_at if respond_to?(:updated_at)
+    values[:created_at] = created_at if respond_to?(:created_at)
+    @_before_to_new_record_values = values
+  end
+  private :store_before_to_new_record_values
+
+  # Set persistence values of id, updated_at and created_at back.
+  def restore_before_to_new_record_values
+    values = @_before_to_new_record_values
+    self.id = values[:id]
+    self.created_at = values[:created_at] if respond_to?(:updated_at=)
+    self.updated_at = values[:updated_at] if respond_to?(:updated_at=)
+  end
+  private :restore_before_to_new_record_values
+
+  # Set id, updated_at and created_at to nil in order to
+  # update them when new record is created.
+  def reset_persistence_values
+    self.id = nil
+    self.updated_at = nil if respond_to?(:updated_at=)
+    self.created_at = nil if respond_to?(:created_at=)
+  end
+  private :reset_persistence_values
+end
+
+ActiveRecord::Base.class_eval do
+  include Moribus
+end