arca 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e3c9c827e804d9e159cd1287dd96d2f51a73b7c
+  data.tar.gz: 2258bba04de95cb191e8db9819ff6b170cd96ab0
+SHA512:
+  metadata.gz: a769d84288997f5dcb1557d3e8061b2c215a1bf492f63da1c9d84d4b37a6552a59b90a53f6531104e0b2ecfe0cdf20b88b34c6611d243b85385cfff04a24ae85
+  data.tar.gz: cbebb0af251cfbd5d8900d85aaaa9c973e8ca29a03cb9d73a94d0591f640b6cf6e7f5e03455859bea967346a01e2481bbae49949b6fb06ca8573c8dc3228a74b

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    arca (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    method_source (0.8.2)
+    minitest (5.7.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    slop (3.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  arca!
+  minitest (~> 5.7)
+  pry (~> 0.10.1)
+  rake (~> 10.4)

data/README.md

@@ -0,0 +1,188 @@
+# ActiveRecord Callback Analyzer
+
+Arca is a callback analyzer for ActiveRecord like models ideally suited for digging yourself out of callback hell. Arca helps you answer questions like:
+
+* how spread out callbacks are for each model
+* how many callbacks use conditionals (`:if` and `:unless`)
+* how many possible permutations exist per callback type (`:commit`, `:create`, `:destroy`, `:find`, `:initialize`, `:rollback`, `:save`, `:touch`, `:update`, `:validation`) taking conditionals into consideration
+
+The Arca library has two main components, the collector and the reporter. Include the collector module in each ActiveRecord model you want to analyze and then use the reporter to analyze and present the data.
+
+## Usage
+
+Add the gem to your Gemfile and run `bundle`.
+
+```
+gem 'arca'
+```
+
+Add an initializer to require the library and configure it (`config/initializers/arca.rb` for example). There's no magic here and Arca doesn't assume your root project path or the path to your `ActiveRecord` models so you have to specify those paths yourself in the initializer.
+
+```
+require "arca"
+
+Arca.root_path = Rails.root
+Arca.model_path = Rails.root.join("app", "models")
+```
+
+Include `Arca::Collector` in the models you want to analyze. It must be included before any callbacks so I recommend including it right after the class definition.
+
+```ruby
+class Ticket < ActiveRecord::Base
+  include Arca::Collector
+  include Announcements
+
+  before_save :set_title, :set_body
+  before_save :upcase_title, :if => :title_is_a_shout?
+
+  def set_title
+    self.title ||= "Ticket id #{SecureRandom.hex(2)}"
+  end
+
+  def set_body
+    self.body ||= "Everything is broken."
+  end
+
+  def upcase_title
+    self.title = title.upcase
+  end
+
+  def title_is_a_shout?
+    self.title.split(" ").size == 1
+  end
+end
+```
+
+In this example the `Annoucements` module is included in `Ticket` and defines it's own callback.
+
+```ruby
+module Announcements
+  def self.included(base)
+    base.class_eval do
+      after_save :announce_save
+    end
+  end
+
+  def announce_save
+    puts "saved #{self.class.name.downcase}!"
+  end
+end
+```
+
+Next use `Arca[Ticket].report` to analyze the callbacks for the `Ticket` class.
+
+```ruby
+> Arca.root_path = `pwd`.chomp
+=> "/Users/jonmagic/Projects/arca"
+> Arca[Ticket].report
+{
+                   :model_name => "Ticket",
+              :model_file_path => "test/fixtures/ticket.rb",
+              :callbacks_count => 4,
+           :conditionals_count => 1,
+          :lines_between_count => 6,
+     :external_callbacks_count => 1,
+       :external_targets_count => 0,
+  :external_conditionals_count => 0,
+      :calculated_permutations => 2
+}
+> Arca[Ticket].analyzed_callbacks
+{
+  :before_save => [
+    {
+      :callback                       => :before_save,
+      :callback_file_path             => "test/fixtures/ticket.rb",
+      :callback_line_number           => 5,
+      :external_callback              => false,
+      :target                         => :set_title,
+      :target_file_path               => "test/fixtures/ticket.rb",
+      :target_line_number             => 8,
+      :external_target                => false,
+      :lines_to_target                => 3,
+      :conditional                    => nil,
+      :conditional_target             => nil,
+      :conditional_target_file_path   => nil,
+      :conditional_target_line_number => nil,
+      :external_conditional_target    => nil,
+      :lines_to_conditional_target    => nil
+    },
+    {
+      :callback                       => :before_save,
+      :callback_file_path             => "test/fixtures/ticket.rb",
+      :callback_line_number           => 5,
+      :external_callback              => false,
+      :target                         => :set_body,
+      :target_file_path               => "test/fixtures/ticket.rb",
+      :target_line_number             => 12,
+      :external_target                => false,
+      :lines_to_target                => 7,
+      :conditional                    => nil,
+      :conditional_target             => nil,
+      :conditional_target_file_path   => nil,
+      :conditional_target_line_number => nil,
+      :external_conditional_target    => nil,
+      :lines_to_conditional_target    => nil
+    },
+    {
+      :callback                       => :before_save,
+      :callback_file_path             => "test/fixtures/ticket.rb",
+      :callback_line_number           => 6,
+      :external_callback              => false,
+      :target                         => :upcase_title,
+      :target_file_path               => "test/fixtures/ticket.rb",
+      :target_line_number             => 16,
+      :external_target                => false,
+      :lines_to_target                => 10,
+      :conditional                    => :if,
+      :conditional_target             => :title_is_a_shout?,
+      :conditional_target_file_path   => "test/fixtures/ticket.rb",
+      :conditional_target_line_number => 20,
+      :external_conditional_target    => false,
+      :lines_to_conditional_target    => nil
+    }
+  ],
+  :after_save  => [
+    {
+      :callback                       => :after_save,
+      :callback_file_path             => "test/fixtures/announcements.rb",
+      :callback_line_number           => 4,
+      :external_callback              => true,
+      :target                         => :announce_save,
+      :target_file_path               => "test/fixtures/announcements.rb",
+      :target_line_number             => 8,
+      :external_target                => false,
+      :lines_to_target                => 4,
+      :conditional                    => nil,
+      :conditional_target             => nil,
+      :conditional_target_file_path   => nil,
+      :conditional_target_line_number => nil,
+      :external_conditional_target    => nil,
+      :lines_to_conditional_target    => nil
+    }
+  ]
+}
+```
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Jonathan Hoyt
+
+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/Rakefile

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/arca.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name          = "arca"
+  spec.version       = "1.0.0"
+  spec.date          = "2015-07-11"
+  spec.summary       = "ActiveRecord callback analyzer"
+  spec.description   = "Arca is a callback analyzer for ActiveRecord ideally suited for digging yourself out of callback hell"
+  spec.authors       = ["Jonathan Hoyt"]
+  spec.email         = "jonmagic@gmail.com"
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.homepage      = "https://github.com/jonmagic/arca"
+  spec.license       = "MIT"
+
+  spec.add_development_dependency "rake",     "~> 10.4"
+  spec.add_development_dependency "minitest", "~> 5.7"
+  spec.add_development_dependency "pry", "~> 0.10"
+end

data/lib/arca.rb

@@ -0,0 +1,64 @@
+require_relative "arca/collector"
+require_relative "arca/model"
+require_relative "arca/report"
+require_relative "arca/callback_analysis"
+
+module Arca
+
+  # Error raised if Arca[] is passed something other than a class constant.
+  class ClassRequired < StandardError; end
+
+  # Error raised if model does not respond to arca_callback_data
+  class CallbackDataMissing < StandardError; end
+
+  # Public: Reader method for accessing the Arca::Model for analysis and
+  # reporting.
+  def self.[](klass)
+    raise ClassRequired unless klass.kind_of?(Class)
+    raise CallbackDataMissing unless klass.respond_to?(:arca_callback_data)
+
+    Arca::Model.new(klass)
+  end
+
+  # Public: (optional) Writer method for configuring the root path of the
+  # project where  Arca is being used. Setting Arca.root_path will makes
+  # inspecting analyzed callbacks easier by shortening absolute paths to
+  # relative paths.
+  #
+  # path - Pathname or String representing the root path of the project.
+  def self.root_path=(path)
+    @root_path = path.to_s
+  end
+
+  # Public: String representing the root path for the project.
+  def self.root_path
+    @root_path
+  end
+
+  # Public: (required) Writer method for configuring the root path to the models
+  # for the project where Arca is being used. This path is required by the
+  # Arca::Collector for finding the correct line in the caller Array.
+  def self.model_root_path=(path)
+    @model_root_path = path.to_s
+  end
+
+  # Public: String representing the path to the models for the project.
+  def self.model_root_path
+    @model_root_path
+  end
+
+  # Public: Helper method for turning absolute paths into relative paths.
+  #
+  # path - String absolute path.
+  #
+  # Returns a relative path String.
+  def self.relative_path(path)
+    return if path.nil?
+
+    if @root_path
+      path.sub(/^#{Regexp.escape(@root_path) || ""}\//, "")
+    else
+      path
+    end
+  end
+end

data/lib/arca/callback_analysis.rb

@@ -0,0 +1,134 @@
+module Arca
+  class CallbackAnalysis
+
+    # Arca::CallbackAnalysis takes an Arca::Model and data for a specific
+    # callback and then calculates and exposes a complete analysis for the
+    # callback including target methods, file paths, line numbers, booleans
+    # representing whether targets are in the same file they are called from,
+    # and finally the number of lines between callers and the target methods
+    # they call.
+    #
+    # model         - Arca::Model instance.
+    # callback_data - Hash with callback data collected by Arca::Collector.
+    def initialize(model:, callback_data:)
+      @model                     = model
+      @callback_symbol           = callback_data.fetch(:callback_symbol)
+      @callback_file_path        = callback_data.fetch(:callback_file_path)
+      @callback_line_number      = callback_data.fetch(:callback_line_number)
+      @target_symbol             = callback_data.fetch(:target_symbol)
+      @conditional_symbol        = callback_data[:conditional_symbol]
+      @conditional_target_symbol = callback_data[:conditional_target_symbol]
+    end
+
+    # Public: Hash representation of the object for interactive consoles.
+    def inspect
+      to_hash.to_s
+    end
+
+    # Public: Hash of collected and analyzed callback data.
+    def to_hash
+      {
+        :callback                       => callback_symbol,
+        :callback_file_path             => Arca.relative_path(callback_file_path),
+        :callback_line_number           => callback_line_number,
+        :external_callback              => external_callback?,
+        :target                         => target_symbol,
+        :target_file_path               => Arca.relative_path(target_file_path),
+        :target_line_number             => target_line_number,
+        :external_target                => external_target?,
+        :lines_to_target                => lines_to_target,
+        :conditional                    => conditional_symbol,
+        :conditional_target             => conditional_target_symbol,
+        :conditional_target_file_path   => Arca.relative_path(conditional_target_file_path),
+        :conditional_target_line_number => conditional_target_line_number,
+        :external_conditional_target    => external_conditional_target?,
+        :lines_to_conditional_target    => nil
+      }
+    end
+
+    # Public: Arca::Model this callback belongs to.
+    attr_reader :model
+
+    # Public: Symbol representing the callback method name.
+    attr_reader :callback_symbol
+
+    # Public: String path to the file where the callback is used.
+    attr_reader :callback_file_path
+
+    # Public: Integer line number where the callback is called.
+    attr_reader :callback_line_number
+
+    # Public: Boolean representing whether the callback is used in the same
+    # file where the ActiveRecord model is defined.
+    def external_callback?
+      callback_file_path != model.file_path
+    end
+
+    # Public: Symbol representing the callback target method name.
+    attr_reader :target_symbol
+
+    # Public: String path to the file where the callback target is located.
+    def target_file_path
+      model.source_location(target_symbol)[:file_path]
+    end
+
+    # Public: Integer line number where the callback target is located.
+    def target_line_number
+      model.source_location(target_symbol)[:line_number]
+    end
+
+    # Public: Boolean representing whether the callback target is located in the
+    # same file where the callback is defined.
+    def external_target?
+      target_file_path != callback_file_path
+    end
+
+    # Public: Integer representing the number of lines between where the
+    # callback is used and the callback target is located.
+    def lines_to_target
+      return if external_target?
+
+      (target_line_number - callback_line_number).abs
+    end
+
+    # Public: Symbol representing the conditional target method name.
+    attr_reader :conditional_symbol
+    attr_reader :conditional_target_symbol
+
+    # Public: String path to the file where the conditional target is located.
+    def conditional_target_file_path
+      return if conditional_target_symbol.nil?
+
+      model.source_location(conditional_target_symbol)[:file_path]
+    end
+
+    # Public: Integer line number where the conditional target is located.
+    def conditional_target_line_number
+      return if conditional_target_symbol.nil?
+
+      model.source_location(conditional_target_symbol)[:line_number]
+    end
+
+    # Public: Boolean representing whether the conditional target is located in
+    # the same file where the callback is defined.
+    def external_conditional_target?
+      return if conditional_target_symbol.nil?
+
+      callback_file_path != conditional_target_file_path
+    end
+
+    # Public: Integer representing the number of lines between where the
+    # callback is used and the conditional target is located.
+    def lines_to_conditional_target
+      return if conditional_target_symbol.nil? || external_conditional_target?
+
+      (conditional_target_line_number - callback_line_number).abs
+    end
+
+    # Public: Boolean representing whether the callback target is located in the
+    # ActiveRecord gem.
+    def target_file_path_active_record?
+      target_file_path =~ /gems\/activerecord/
+    end
+  end
+end

data/lib/arca/collector.rb

@@ -0,0 +1,95 @@
+module Arca
+
+  # Include Arca::Collector in an ActiveRecord class in order to collect data
+  # about how callbacks are being used.
+  module Collector
+
+    # Error raised if Arca.model_root_path is nil.
+    class ModelRootPathRequired < StandardError; end
+
+    # Internal: Regular expression used for extracting the file path and line
+    # number from a caller line.
+    ARCA_LINE_PARSER_REGEXP = /\A(.+)\:(\d+)\:in\s(.+)\z/
+    private_constant :ARCA_LINE_PARSER_REGEXP
+
+    # Internal: Array of conditional symbols.
+    ARCA_CONDITIONALS = [:if, :unless]
+    private_constant :ARCA_CONDITIONALS
+
+    # http://ruby-doc.org/core-2.2.1/Module.html#method-i-included
+    def self.included(base)
+      # Raise error if Arca.model_root_path is nil.
+      raise ModelRootPathRequired if Arca.model_root_path.nil?
+
+      # Get the file path to the model class that included the collector.
+      model_file_path, = caller[0].partition(":")
+
+      base.class_eval do
+        # Define :arca_callback_data for storing the data we collect.
+        define_singleton_method :arca_callback_data do
+          @callbacks ||= {}
+        end
+
+        # Collect the model_file_path.
+        arca_callback_data[:model_file_path] = model_file_path
+
+        # Find the callback methods defined on this class.
+        callback_method_symbols = singleton_methods.grep /^(after|around|before)\_/
+
+        callback_method_symbols.each do |callback_symbol|
+          # Find the UnboundMethod for the callback.
+          callback_method = singleton_class.instance_method(callback_symbol)
+
+          # Redefine the callback method so that data can be collected each time
+          # the callback is used for this class.
+          define_singleton_method(callback_method.name) do |*args|
+            # Duplicate args before modifying.
+            args_copy = args.dup
+
+            # Get the options hash from the end of the args Array if it exists.
+            options = args_copy.pop if args[-1].is_a?(Hash)
+
+            # Iterate through the rest of the args. Each remaining arguement is
+            # a Symbol representing the callback target method.
+            args_copy.each do |target_symbol|
+
+              # Find the caller line where the callback is used.
+              line = caller.find {|line| line =~ /#{Regexp.escape(Arca.model_root_path)}/ }
+
+              # Parse the line in order to extract the file path and line number.
+              callback_line_matches     = line.match(ARCA_LINE_PARSER_REGEXP)
+
+              # Find the conditional symbol if it exists in the options hash.
+              conditional_symbol = ARCA_CONDITIONALS.
+                find {|conditional| options && options.has_key?(conditional) }
+
+              # Find the conditional target symbol if there is a conditional.
+              conditional_target_symbol = if conditional_symbol
+                options[conditional_symbol]
+              end
+
+              # Set the collector hash for this callback_symbol to an empty
+              # Array if it has not already been set.
+              arca_callback_data[callback_symbol] ||= []
+
+              # Add the collected callback data to the collector Array for
+              # this callback_symbol.
+              arca_callback_data[callback_symbol] << {
+                :callback_symbol                => callback_symbol,
+                :callback_file_path             => callback_line_matches[1],
+                :callback_line_number           => callback_line_matches[2].to_i,
+                :target_symbol                  => target_symbol,
+                :conditional_symbol             => conditional_symbol,
+                :conditional_target_symbol      => conditional_target_symbol
+              }
+
+            end
+
+            # Bind the callback method to self and call it with args.
+            callback_method.bind(self).call(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arca/model.rb

@@ -0,0 +1,121 @@
+module Arca
+  class Model
+
+    # Arca::Model wraps an ActiveRecord model class and provides an interface
+    # to the collected and analyzed callback data for that class and the file
+    # path to the model class.
+    def initialize(klass)
+      @klass = klass
+      @name = klass.name
+      @callbacks = klass.arca_callback_data.dup
+      @file_path = callbacks.delete(:model_file_path)
+    end
+
+    # Array of ActiveRecord callback method symbols in a rough order of when
+    # they are used in the life cycle of an ActiveRecord model.
+    CALLBACKS = [
+      :after_initialize, :after_find, :after_touch, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
+    ]
+
+    # Public: ActiveRecord model class.
+    attr_reader :klass
+
+    # Public: String model name.
+    attr_reader :name
+
+    # Public: String file path.
+    attr_reader :file_path
+
+    # Public: Hash of collected callback data.
+    attr_reader :callbacks
+
+    # Public: Arca::Report for this model.
+    def report
+      @report ||= Report.new(self)
+    end
+
+    # Public: Helper method for finding the file path and line number where
+    # a method is located for the ActiveRecord model.
+    #
+    # method_symbol - Symbol representation of the method name.
+    def source_location(method_symbol)
+      source_location = klass.instance_method(method_symbol).source_location
+      {
+        :file_path => source_location[0],
+        :line_number => source_location[1]
+      }
+    rescue NameError
+      {
+        :file_path => nil,
+        :line_number => nil
+      }
+    rescue TypeError
+      {
+        :file_path => nil,
+        :line_number => nil
+      }
+    end
+
+    # Public: Hash of CallbackAnalysis objects for each callback type.
+    def analyzed_callbacks
+      @analyzed_callbacks ||= CALLBACKS.inject({}) do |result, callback_symbol|
+        Array(callbacks[callback_symbol]).each do |callback_data|
+          result[callback_symbol] ||= []
+          callback_analysis = CallbackAnalysis.new({
+            :model         => self,
+            :callback_data => callback_data
+          })
+
+          unless callback_analysis.target_file_path_active_record?
+            result[callback_symbol] << callback_analysis
+          end
+        end
+        result
+      end
+    end
+
+    # Public: Array of all CallbackAnalysis objects for this model.
+    def analyzed_callbacks_array
+      @analyzed_callbacks_array ||= analyzed_callbacks.values.flatten
+    end
+
+    # Public: Integer representing the number of callbacks analyzed.
+    def analyzed_callbacks_count
+      analyzed_callbacks_array.size
+    end
+
+    # Public: Integer representing the total number of lines between callbacks
+    # called for this class from files other than the one where the class is
+    # defined.
+    def lines_between_count
+      lines_between = 0
+      line_numbers = analyzed_callbacks_array.map &:callback_line_number
+      sorted_line_numbers = line_numbers.sort {|a,b| b <=> a }
+      sorted_line_numbers.each_with_index do |line_number, index|
+        lines_between += line_number - (sorted_line_numbers[index + 1] || 0)
+      end
+      lines_between
+    end
+
+    # Public: Integer representing the number of callbacks called for this class
+    # from files other than this model.
+    def external_callbacks_count
+      analyzed_callbacks_array.select {|analysis| analysis.external_callback? }.size
+    end
+
+    # Public: Integer representing the number of callback targets that are
+    # defined in files other than this model.
+    def external_targets_count
+      analyzed_callbacks_array.select {|analysis| analysis.external_target? }.size
+    end
+
+    # Public: Integer representing the number of conditional callback targets
+    # that are defined in files other than this model.
+    def external_conditionals_count
+      analyzed_callbacks_array.select {|analysis| analysis.external_conditional_target? }.size
+    end
+  end
+end

data/lib/arca/report.rb

@@ -0,0 +1,80 @@
+module Arca
+  class Report
+
+    # Arca::Report takes an Arca::Model and compiles the analyzed callback data
+    # into a short overview report for the model.
+    def initialize(model)
+      @model = model
+    end
+
+    # Public: Arca::Model representing the ActiveRecord class being reported.
+    attr_reader :model
+
+    # Public: Hash representation of the object for interactive consoles.
+    def inspect
+      to_hash.to_s
+    end
+
+    # Public: Hash of compiled report data.
+    def to_hash
+      {
+        :model_name                  => model_name,
+        :model_file_path             => Arca.relative_path(model_file_path),
+        :callbacks_count             => callbacks_count,
+        :conditionals_count          => conditionals_count,
+        :lines_between_count         => lines_between_count,
+        :external_callbacks_count    => external_callbacks_count,
+        :external_targets_count      => external_targets_count,
+        :external_conditionals_count => external_conditionals_count,
+        :calculated_permutations     => calculated_permutations
+      }
+    end
+
+    # Public: String class name of model.
+    def model_name
+      model.name
+    end
+
+    # Public: String file path of model.
+    def model_file_path
+      model.file_path
+    end
+
+    # Public: Integer representing the number of callbacks used in this model.
+    def callbacks_count
+      model.analyzed_callbacks_count
+    end
+
+    # Public: Integer representing the number of conditionals used in callback
+    # for the model being reported.
+    def conditionals_count
+      number_of_unique_conditionals(model.analyzed_callbacks_array)
+    end
+
+    delegate :lines_between_count, :external_callbacks_count,
+      :external_targets_count, :external_conditionals_count, :to => :model
+
+    # Public: Integer representing the possible number of permutations stemming
+    # from conditionals for an instance of the model being reported during the
+    # lifecycle of the object.
+    def calculated_permutations
+      permutations = model.analyzed_callbacks.inject([]) do |results, (key, analyzed_callbacks)|
+        results << 2 ** number_of_unique_conditionals(analyzed_callbacks)
+      end.sum - number_of_unique_conditionals(model.analyzed_callbacks_array)
+    end
+
+    # Internal: Integer representing the number of unique conditions for an
+    # Array of CallbackAnalysis objects.
+    #
+    # analyzed_callbacks - Array of CallbackAnalysis objects.
+    #
+    # Returns an Integer.
+    def number_of_unique_conditionals(analyzed_callbacks)
+      analyzed_callbacks.
+        select {|analysis| analysis.conditional_symbol }.
+        uniq {|analysis| analysis.conditional_target_symbol }.
+        size
+    end
+    private :number_of_unique_conditionals
+  end
+end

data/test/fixtures/announcements.rb

@@ -0,0 +1,11 @@
+module Announcements
+  def self.included(base)
+    base.class_eval do
+      after_save :announce_save
+    end
+  end
+
+  def announce_save
+    puts "saved #{self.class.name.downcase}!"
+  end
+end

data/test/fixtures/bar.rb

@@ -0,0 +1,3 @@
+class Bar < ActiveRecord::Base
+  include Arca::Collector
+end

data/test/fixtures/foo.rb

@@ -0,0 +1,33 @@
+class Foo
+  extend ActiveModel::Callbacks
+  define_model_callbacks :save
+
+  include Arca::Collector
+  before_save :bar, :baz, :if => :boop?
+
+  def initialize
+    @mission_complete = false
+  end
+
+  def save
+    run_callbacks :save do
+      @mission_complete = true
+    end
+  end
+  attr_reader :mission_complete
+
+  def bar
+    @bargo = "hello"
+  end
+  attr_reader :bargo
+
+  def baz
+    @bazinga = "world"
+  end
+  attr_reader :bazinga
+
+  def boop?
+    !!@boop
+  end
+  attr_writer :boop
+end

data/test/fixtures/ticket.rb

@@ -0,0 +1,23 @@
+class Ticket < ActiveRecord::Base
+  include Arca::Collector
+  include Announcements
+
+  before_save :set_title, :set_body
+  before_save :upcase_title, :if => :title_is_a_shout?
+
+  def set_title
+    self.title ||= "Ticket id #{SecureRandom.hex(2)}"
+  end
+
+  def set_body
+    self.body ||= "Everything is broken."
+  end
+
+  def upcase_title
+    self.title = title.upcase
+  end
+
+  def title_is_a_shout?
+    self.title.split(" ").size == 1
+  end
+end

data/test/lib/arca/callback_analysis_test.rb

@@ -0,0 +1,133 @@
+require_relative "../../test_helper"
+
+class Arca::CallbackAnalysisTest < Minitest::Test
+  def model
+    @model ||= Arca::Model.new(Ticket)
+  end
+
+  def announce_save
+    @announce_save ||= Arca::CallbackAnalysis.new({
+      :model => model,
+      :callback_data => {
+        :callback_symbol => :after_save,
+        :callback_file_path => "/Users/jonmagic/Projects/arca/test/fixtures/announcements.rb",
+        :callback_line_number => 4,
+        :target_symbol => :announce_save,
+        :conditional_symbol => nil,
+        :conditional_target_symbol => nil
+      }
+    })
+  end
+
+  def set_title
+    @set_title ||= Arca::CallbackAnalysis.new({
+      :model => model,
+      :callback_data => {
+        :callback_symbol=>:before_save,
+        :callback_file_path => "/Users/jonmagic/Projects/arca/test/fixtures/ticket.rb",
+        :callback_line_number => 5,
+        :target_symbol => :set_title,
+        :conditional_symbol => nil,
+        :conditional_target_symbol => nil
+      }
+    })
+  end
+
+  def upcase_title
+    @upcase_title ||= Arca::CallbackAnalysis.new({
+      :model => model,
+      :callback_data => {
+        :callback_symbol => :before_save,
+        :callback_file_path => "/Users/jonmagic/Projects/arca/test/fixtures/ticket.rb",
+        :callback_line_number => 6,
+        :target_symbol => :upcase_title,
+        :conditional_symbol => :if,
+        :conditional_target_symbol => :title_is_a_shout?
+      }
+    })
+  end
+
+  def test_callback_symbol
+    assert_equal :after_save, announce_save.callback_symbol
+    assert_equal :before_save, set_title.callback_symbol
+    assert_equal :before_save, upcase_title.callback_symbol
+  end
+
+  def test_callback_file_path
+    assert_match "test/fixtures/announcements.rb", announce_save.callback_file_path
+    assert_match "test/fixtures/ticket.rb", set_title.callback_file_path
+    assert_match "test/fixtures/ticket.rb", upcase_title.callback_file_path
+  end
+
+  def test_callback_line_number
+    assert_equal 4, announce_save.callback_line_number
+    assert_equal 5, set_title.callback_line_number
+    assert_equal 6, upcase_title.callback_line_number
+  end
+
+  def test_external_callback?
+    assert_predicate announce_save, :external_callback?
+    refute_predicate set_title, :external_callback?
+    refute_predicate upcase_title, :external_callback?
+  end
+
+  def test_target_symbol
+    assert_equal :announce_save, announce_save.target_symbol
+    assert_equal :set_title, set_title.target_symbol
+    assert_equal :upcase_title, upcase_title.target_symbol
+  end
+
+  def test_target_file_path
+    assert_match "test/fixtures/announcements.rb", announce_save.target_file_path
+    assert_match "test/fixtures/ticket.rb", set_title.target_file_path
+    assert_match "test/fixtures/ticket.rb", upcase_title.target_file_path
+  end
+
+  def test_target_line_number
+    assert_equal 8, announce_save.target_line_number
+    assert_equal 8, set_title.target_line_number
+    assert_equal 16, upcase_title.target_line_number
+  end
+
+  def test_external_target?
+    refute_predicate announce_save, :external_target?
+    refute_predicate set_title, :external_target?
+    refute_predicate upcase_title, :external_target?
+  end
+
+  def test_lines_to_target
+    assert_equal 4, announce_save.lines_to_target
+    assert_equal 3, set_title.lines_to_target
+    assert_equal 10, upcase_title.lines_to_target
+  end
+
+  def test_conditional_symbol
+    assert_nil announce_save.conditional_symbol
+    assert_nil set_title.conditional_symbol
+    assert_equal :if, upcase_title.conditional_symbol
+  end
+
+  def test_conditional_target_symbol
+    assert_nil announce_save.conditional_target_symbol
+    assert_nil set_title.conditional_target_symbol
+    assert_equal :title_is_a_shout?, upcase_title.conditional_target_symbol
+  end
+
+  def test_conditional_target_file_path
+    assert_nil announce_save.conditional_target_file_path
+    assert_nil set_title.conditional_target_file_path
+    assert_match "test/fixtures/ticket.rb", upcase_title.conditional_target_file_path
+  end
+
+  def test_conditional_target_line_number
+    assert_nil announce_save.conditional_target_line_number
+    assert_nil set_title.conditional_target_line_number
+    assert_equal 20, upcase_title.conditional_target_line_number
+  end
+
+  def test_lines_to_conditional_target
+    assert_nil announce_save.lines_to_conditional_target
+    assert_nil set_title.lines_to_conditional_target
+    assert_equal 14, upcase_title.lines_to_conditional_target
+  end
+end

data/test/lib/arca/collector_test.rb

@@ -0,0 +1,66 @@
+require_relative "../../test_helper"
+
+class Arca::CollectorTest < Minitest::Test
+  def test_collects_callback_data
+    callbacks = Ticket.arca_callback_data
+
+    callback = callbacks[:after_save][0]
+    assert_equal :after_save, callback[:callback_symbol]
+    assert_match "test/fixtures/announcements.rb", callback[:callback_file_path]
+    assert_equal 4, callback[:callback_line_number]
+    assert_equal :announce_save, callback[:target_symbol]
+    assert_nil callback[:conditional_symbol]
+    assert_nil callback[:conditional_target_symbol]
+
+    callback = callbacks[:before_save][0]
+    assert_equal :before_save, callback[:callback_symbol]
+    assert_match "test/fixtures/ticket.rb", callback[:callback_file_path]
+    assert_equal 5, callback[:callback_line_number]
+    assert_equal :set_title, callback[:target_symbol]
+    assert_nil callback[:conditional_symbol]
+    assert_nil callback[:conditional_target_symbol]
+
+    callback = callbacks[:before_save][1]
+    assert_equal :before_save, callback[:callback_symbol]
+    assert_match "test/fixtures/ticket.rb", callback[:callback_file_path]
+    assert_equal 5, callback[:callback_line_number]
+    assert_equal :set_body, callback[:target_symbol]
+    assert_nil callback[:conditional_symbol]
+    assert_nil callback[:conditional_target_symbol]
+
+    callback = callbacks[:before_save][2]
+    assert_equal :before_save, callback[:callback_symbol]
+    assert_match "test/fixtures/ticket.rb", callback[:callback_file_path]
+    assert_equal 6, callback[:callback_line_number]
+    assert_equal :upcase_title, callback[:target_symbol]
+    assert_equal :if, callback[:conditional_symbol]
+    assert_equal :title_is_a_shout?, callback[:conditional_target_symbol]
+  end
+
+  def test_arca_model_root_path_is_required
+    model_root_path = Arca.model_root_path
+    Arca.instance_variable_set(:@model_root_path, nil)
+
+    assert_raises(Arca::Collector::ModelRootPathRequired) do
+      require_relative "../../fixtures/bar"
+    end
+
+    Arca.model_root_path = model_root_path
+  end
+
+  def test_callback_is_reapplied_with_original_args
+    foo = Foo.new
+    refute       foo.boop?
+    foo.save
+    assert       foo.mission_complete
+    assert_nil   foo.bargo
+    assert_nil   foo.bazinga
+
+    foo.boop =   true
+    assert       foo.boop?
+    foo.save
+    assert       foo.mission_complete
+    assert_equal "hello", foo.bargo
+    assert_equal "world", foo.bazinga
+  end
+end

data/test/lib/arca/model_test.rb

@@ -0,0 +1,59 @@
+require_relative "../../test_helper"
+
+class Arca::ModelTest < Minitest::Test
+  def model
+    @model ||= Arca::Model.new(Ticket)
+  end
+
+  def test_report
+    assert model.report.instance_of?(Arca::Report)
+  end
+
+  def test_source_location
+    source_location = model.source_location(:set_title)
+    assert_match "test/fixtures/ticket.rb", source_location[:file_path]
+    assert_equal 8, source_location[:line_number]
+  end
+
+  def test_source_location_with_method_symbol_with_no_associated_method
+    source_location = model.source_location(:foo_bar)
+    assert_nil source_location[:file_path]
+    assert_nil source_location[:line_number]
+  end
+
+  def test_source_location_with_an_invalid_object
+    source_location = model.source_location(lambda {})
+    assert_nil source_location[:file_path]
+    assert_nil source_location[:line_number]
+  end
+
+  def test_analyzed_callbacks
+    assert_equal 3, model.analyzed_callbacks[:before_save].size
+    assert_equal 1, model.analyzed_callbacks[:after_save].size
+  end
+
+  def test_analyzed_callbacks_array
+    assert_equal 4, model.analyzed_callbacks_array.size
+    assert model.analyzed_callbacks_array[0].is_a?(Arca::CallbackAnalysis)
+  end
+
+  def test_analyzed_callbacks_count
+    assert_equal 4, model.analyzed_callbacks_count
+  end
+
+  def test_lines_between_count
+    assert_equal 6, model.lines_between_count
+  end
+
+  def test_external_callbacks_count
+    assert_equal 1, model.external_callbacks_count
+  end
+
+  def test_external_targets_count
+    assert_equal 0, model.external_targets_count
+  end
+
+  def test_external_conditionals_count
+    assert_equal 0, model.external_conditionals_count
+  end
+end

data/test/lib/arca/report_test.rb

@@ -0,0 +1,27 @@
+require_relative "../../test_helper"
+
+class Arca::ReportTest < Minitest::Test
+  def report
+    @report ||= Arca::Report.new(Arca::Model.new(Ticket))
+  end
+
+  def test_model_class
+    assert_equal "Ticket", report.model_name
+  end
+
+  def test_model_file_path
+    assert_match "test/fixtures/ticket.rb", report.model_file_path
+  end
+
+  def callbacks_count
+    assert_equal 4, report.callbacks_count
+  end
+
+  def test_conditionals_count
+    assert_equal 1, report.conditionals_count
+  end
+
+  def test_calculated_permutations
+    assert_equal 2, report.calculated_permutations
+  end
+end

data/test/lib/arca_test.rb

@@ -0,0 +1,19 @@
+require_relative "../test_helper"
+
+class ArcaTest < Minitest::Test
+  def test_returns_model
+    assert Arca[Ticket].instance_of?(Arca::Model)
+  end
+
+  def test_requires_class
+    assert_raises(Arca::ClassRequired) do
+      Arca[:ticket]
+    end
+  end
+
+  def test_requires_callback_data
+    assert_raises(Arca::CallbackDataMissing) do
+      Arca[ArcaTest]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "active_record"
+require "minitest/autorun"
+
+require "arca"
+Arca.root_path = `pwd`.chomp
+Arca.model_root_path = Arca.root_path + "/test/fixtures"
+
+require_relative "fixtures/announcements"
+require_relative "fixtures/ticket"
+require_relative "fixtures/foo"
+
+if ENV["CONSOLE"]
+  require "pry"
+  binding.pry
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: arca
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jonathan Hoyt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Arca is a callback analyzer for ActiveRecord ideally suited for digging
+  yourself out of callback hell
+email: jonmagic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- arca.gemspec
+- lib/arca.rb
+- lib/arca/callback_analysis.rb
+- lib/arca/collector.rb
+- lib/arca/model.rb
+- lib/arca/report.rb
+- test/fixtures/announcements.rb
+- test/fixtures/bar.rb
+- test/fixtures/foo.rb
+- test/fixtures/ticket.rb
+- test/lib/arca/callback_analysis_test.rb
+- test/lib/arca/collector_test.rb
+- test/lib/arca/model_test.rb
+- test/lib/arca/report_test.rb
+- test/lib/arca_test.rb
+- test/test_helper.rb
+homepage: https://github.com/jonmagic/arca
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ActiveRecord callback analyzer
+test_files:
+- test/fixtures/announcements.rb
+- test/fixtures/bar.rb
+- test/fixtures/foo.rb
+- test/fixtures/ticket.rb
+- test/lib/arca/callback_analysis_test.rb
+- test/lib/arca/collector_test.rb
+- test/lib/arca/model_test.rb
+- test/lib/arca/report_test.rb
+- test/lib/arca_test.rb
+- test/test_helper.rb