lev 0.0.1

data/.ruby-gemset

@@ -0,0 +1 @@
+lev

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p392

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lev.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    lev (0.0.1)
+      active_attr
+      transaction_isolation
+      transaction_retry
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    active_attr (0.8.2)
+      activemodel (>= 3.0.2, < 4.1)
+      activesupport (>= 3.0.2, < 4.1)
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.0)
+    atomic (1.1.14)
+    builder (3.1.4)
+    i18n (0.6.5)
+    minitest (4.7.5)
+    multi_json (1.8.0)
+    rake (10.1.0)
+    thread_safe (0.1.3)
+      atomic
+    transaction_isolation (1.0.3)
+      activerecord (>= 3.0.11)
+    transaction_retry (1.0.2)
+      activerecord (>= 3.0.11)
+      transaction_isolation (>= 1.0.2)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  lev!
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 JP Slavinsky
+
+MIT License
+
+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,29 @@
+# Lev
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lev'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lev
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lev.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lev/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lev"
+  spec.version       = Lev::VERSION
+  spec.authors       = ["JP Slavinsky"]
+  spec.email         = ["jps@kindlinglabs.com"]
+  spec.description   = %q{Ride the rails but don't touch them.}
+  spec.summary       = %q{Ride the rails but don't touch them.}
+  spec.homepage      = "http://github.com/lml/lev"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "transaction_isolation"
+  spec.add_dependency "transaction_retry"
+  spec.add_dependency "active_attr"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/lev/algorithm.rb

@@ -0,0 +1,26 @@
+module Lev
+  #   http://ducktypo.blogspot.com/2010/08/why-inheritance-sucks.html
+  #   http://stackoverflow.com/a/1328093/1664216
+  module Algorithm
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        include Lev::RoutineNesting
+      end
+    end
+
+    def call(*args, &block)
+      in_transaction do
+        exec(*args, &block)
+      end
+    end
+
+    module ClassMethods
+      def call(*args, &block)
+        new.call(*args, &block)
+      end
+    end
+
+  end
+end

data/lib/lev/better_active_model_errors.rb

@@ -0,0 +1,408 @@
+# -*- coding: utf-8 -*-
+
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/ordered_hash'
+
+module Lev
+  # == Better Errors
+  #
+  # Same as ActiveModel::Errors but also retains error types
+  #
+  # Provides a modified +OrderedHash+ that you can include in your object
+  # for handling error messages and interacting with Action Pack helpers.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #
+  #     # Required dependency for ActiveModel::Errors
+  #     extend ActiveModel::Naming
+  #
+  #     def initialize
+  #       @errors = ActiveModel::Errors.new(self)
+  #     end
+  #
+  #     attr_accessor :name
+  #     attr_reader   :errors
+  #
+  #     def validate!
+  #       errors.add(:name, "can not be nil") if name == nil
+  #     end
+  #
+  #     # The following methods are needed to be minimally implemented
+  #
+  #     def read_attribute_for_validation(attr)
+  #       send(attr)
+  #     end
+  #
+  #     def Person.human_attribute_name(attr, options = {})
+  #       attr
+  #     end
+  #
+  #     def Person.lookup_ancestors
+  #       [self]
+  #     end
+  #
+  #   end
+  #
+  # The last three methods are required in your object for Errors to be
+  # able to generate error messages correctly and also handle multiple
+  # languages. Of course, if you extend your object with ActiveModel::Translation
+  # you will not need to implement the last two. Likewise, using
+  # ActiveModel::Validations will handle the validation related methods
+  # for you.
+  #
+  # The above allows you to do:
+  #
+  #   p = Person.new
+  #   p.validate!             # => ["can not be nil"]
+  #   p.errors.full_messages  # => ["name can not be nil"]
+  #   # etc..
+  class BetterActiveModelErrors
+    include Enumerable
+
+    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+
+    attr_reader :messages
+    attr_reader :types
+
+    # Pass in the instance of the object that is using the errors object.
+    #
+    #   class Person
+    #     def initialize
+    #       @errors = ActiveModel::Errors.new(self)
+    #     end
+    #   end
+    def initialize(base)
+      @base     = base
+      @types = ActiveSupport::OrderedHash.new
+      @messages = ActiveSupport::OrderedHash.new
+    end
+
+    def initialize_dup(other)
+      @types = other.types.dup
+      @messages = other.messages.dup
+    end
+
+    # Backport dup from 1.9 so that #initialize_dup gets called
+    unless Object.respond_to?(:initialize_dup, true)
+      def dup # :nodoc:
+        copy = super
+        copy.initialize_dup(self)
+        copy
+      end
+    end
+
+    # Clear the messages
+    def clear
+      types.clear
+      messages.clear
+    end
+
+    # Do the error messages include an error with key +error+?
+    def include?(error)
+      (v = messages[error]) && v.any?
+    end
+    alias :has_key? :include?
+
+    # Get messages for +key+
+    def get(key)
+      messages[key]
+    end
+
+    def get_type(key)
+      types[key]
+    end
+
+    # Set messages for +key+ to +value+
+    def set(key, value)
+      types[key] = (value == [] ? [] : (value.is_a?(Symbol) ? value : nil))
+      messages[key] = value
+    end
+
+    # Delete messages for +key+
+    def delete(key)
+      types.delete(key)
+      messages.delete(key)
+    end
+
+    # When passed a symbol or a name of a method, returns an array of errors
+    # for the method.
+    #
+    #   p.errors[:name]   # => ["can not be nil"]
+    #   p.errors['name']  # => ["can not be nil"]
+    def [](attribute)
+      get(attribute.to_sym) || set(attribute.to_sym, [])
+    end
+
+    # Adds to the supplied attribute the supplied error message.
+    #
+    #   p.errors[:name] = "must be set"
+    #   p.errors[:name] # => ['must be set']
+    def []=(attribute, error)
+      self[attribute] << error
+    end
+
+    # Iterates through each error key, value pair in the error messages hash.
+    # Yields the attribute and the error for that attribute. If the attribute
+    # has more than one error message, yields once for each error message.
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.each do |attribute, errors_array|
+    #     # Will yield :name and "can't be blank"
+    #   end
+    #
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.each do |attribute, errors_array|
+    #     # Will yield :name and "can't be blank"
+    #     # then yield :name and "must be specified"
+    #   end
+    def each
+      messages.each_key do |attribute|
+        self[attribute].each { |error| yield attribute, error }
+      end
+    end
+
+    def each_with_type_and_message
+      types.each_key do |attribute|
+        for ii in 0..self.types[attribute].size-1
+          yield attribute, self.types[attribute][ii], self.messages[attribute][ii]
+        end
+      end
+    end
+
+    # Returns the number of error messages.
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.size # => 1
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.size # => 2
+    def size
+      values.flatten.size
+    end
+
+    # Returns all message values
+    def values
+      messages.values
+    end
+
+    # Returns all message keys
+    def keys
+      messages.keys
+    end
+
+    # Returns an array of error messages, with the attribute name included
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.to_a # => ["name can't be blank", "name must be specified"]
+    def to_a
+      full_messages
+    end
+
+    # Returns the number of error messages.
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.count # => 1
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.count # => 2
+    def count
+      to_a.size
+    end
+
+    # Returns true if no errors are found, false otherwise.
+    # If the error message is a string it can be empty.
+    def empty?
+      all? { |k, v| v && v.empty? && !v.is_a?(String) }
+    end
+    alias_method :blank?, :empty?
+
+    # Returns an xml formatted representation of the Errors hash.
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.to_xml
+    #   # =>
+    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+    #   #  <errors>
+    #   #    <error>name can't be blank</error>
+    #   #    <error>name must be specified</error>
+    #   #  </errors>
+    def to_xml(options={})
+      to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
+    end
+
+    # Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.
+    def as_json(options=nil)
+      to_hash
+    end
+
+    def to_hash
+      messages.dup
+    end
+
+    # Adds +message+ to the error messages on +attribute+. More than one error can be added to the same
+    # +attribute+.
+    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
+    #
+    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_error+).
+    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
+    def add(attribute, message = nil, options = {})
+      normalized_message = normalize_message(attribute, message, options)
+      if options[:strict]
+        raise ActiveModel::StrictValidationFailed, full_message(attribute, normalized_message)
+      end
+
+      self[attribute] << normalized_message
+      self.types[attribute] << message if message.is_a?(Symbol)
+    end
+
+    # Will add an error message to each of the attributes in +attributes+ that is empty.
+    def add_on_empty(attributes, options = {})
+      [attributes].flatten.each do |attribute|
+        value = @base.send(:read_attribute_for_validation, attribute)
+        is_empty = value.respond_to?(:empty?) ? value.empty? : false
+        add(attribute, :empty, options) if value.nil? || is_empty
+      end
+    end
+
+    # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
+    def add_on_blank(attributes, options = {})
+      [attributes].flatten.each do |attribute|
+        value = @base.send(:read_attribute_for_validation, attribute)
+        add(attribute, :blank, options) if value.blank?
+      end
+    end
+
+    # Returns true if an error on the attribute with the given message is present, false otherwise.
+    # +message+ is treated the same as for +add+.
+    #   p.errors.add :name, :blank
+    #   p.errors.added? :name, :blank # => true
+    def added?(attribute, message = nil, options = {})
+      message = normalize_message(attribute, message, options)
+      self[attribute].include? message
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    #   class Company
+    #     validates_presence_of :name, :address, :email
+    #     validates_length_of :name, :in => 5..30
+    #   end
+    #
+    #   company = Company.create(:address => '123 First St.')
+    #   company.errors.full_messages # =>
+    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+    def full_messages
+      map { |attribute, message| full_message(attribute, message) }
+    end
+
+    # Returns a full message for a given attribute.
+    #
+    #   company.errors.full_message(:name, "is invalid")  # =>
+    #     "Name is invalid"
+    def full_message(attribute, message)
+      self.class.full_message(@base, attribute, message)
+    end
+
+    def self.full_message(model, attribute, message)
+      return message if attribute == :base
+      attr_name = attribute.to_s.gsub('.', '_').humanize
+      attr_name = model.class.human_attribute_name(attribute, :default => attr_name)
+      I18n.t(:"errors.format", {
+        :default   => "%{attribute} %{message}",
+        :attribute => attr_name,
+        :message   => message
+      })
+    end
+
+    # Translates an error message in its default scope
+    # (<tt>activemodel.errors.messages</tt>).
+    #
+    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
+    # if it's not there, it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not
+    # there also, it returns the translation of the default message
+    # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name,
+    # translated attribute name and the value are available for interpolation.
+    #
+    # When using inheritance in your models, it will check all the inherited
+    # models too, but only if the model itself hasn't been found. Say you have
+    # <tt>class Admin < User; end</tt> and you wanted the translation for
+    # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
+    # it looks for these translations:
+    #
+    # * <tt>activemodel.errors.models.admin.attributes.title.blank</tt>
+    # * <tt>activemodel.errors.models.admin.blank</tt>
+    # * <tt>activemodel.errors.models.user.attributes.title.blank</tt>
+    # * <tt>activemodel.errors.models.user.blank</tt>
+    # * any default you provided through the +options+ hash (in the <tt>activemodel.errors</tt> scope)
+    # * <tt>activemodel.errors.messages.blank</tt>
+    # * <tt>errors.attributes.title.blank</tt>
+    # * <tt>errors.messages.blank</tt>
+    #
+    def generate_message(attribute, type = :invalid, options = {})
+      self.class.generate_message(@base, attribute, type, options)
+    end
+
+    # TODO maybe don't need this method split out any more?
+    def self.generate_message(model, attribute, type = :invalid, options = {})
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+
+      if model.class.respond_to?(:i18n_scope)
+        defaults = model.class.lookup_ancestors.map do |klass|
+          [ :"#{model.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+            :"#{model.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
+        end
+      else
+        defaults = []
+      end
+
+      defaults << options.delete(:message)
+      defaults << :"#{model.class.i18n_scope}.errors.messages.#{type}" if model.class.respond_to?(:i18n_scope)
+      defaults << :"errors.attributes.#{attribute}.#{type}"
+      defaults << :"errors.messages.#{type}"
+
+      defaults.compact!
+      defaults.flatten!
+
+      key = defaults.shift
+      value = (attribute != :base ? model.send(:read_attribute_for_validation, attribute) : nil)
+
+      options = {
+        :default => defaults,
+        :model => model.class.model_name.human,
+        :attribute => model.class.human_attribute_name(attribute),
+        :value => value
+      }.merge(options)
+
+      I18n.translate(key, options)
+    end
+
+  private
+    def normalize_message(attribute, message, options)
+      message ||= :invalid
+
+      if message.is_a?(Symbol)
+        generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
+      elsif message.is_a?(Proc)
+        message.call
+      else
+        message
+      end
+    end
+  end
+
+  class StrictValidationFailed < StandardError
+  end
+end
+
+module ActiveModel
+  module Validations
+    def errors
+      @errors ||= Lev::BetterActiveModelErrors.new(self)
+    end
+  end
+end

data/lib/lev/delegate_to_algorithm.rb

@@ -0,0 +1,25 @@
+# ActiveRecord::Base.delegate_to_algorithm
+#
+# Let active records delegate certain (likely non-trivial) actions to algoritms
+# 
+# Arguments:
+#   method: a symbol for the instance method to delegate, e.g. :destroy
+#   options: a hash of options including...
+#      :algorithm_klass => The class of the algorithm to delegate to; if not 
+#        given, 
+ActiveRecord::Base.define_singleton_method(:delegate_to_algorithm) do |method, options={}|
+  algorithm_klass = options[:algorithm_klass]
+
+  if algorithm_klass.nil?
+    algorithm_klass_name = "#{method.to_s.capitalize}#{self.name}"
+    algorithm_klass = Kernel.const_get(algorithm_klass_name)
+  end
+
+  self.instance_eval do
+    alias_method "#{method}_original".to_sym, method
+    define_method method do
+      algorithm_klass.call(self)
+    end
+  end
+
+end

data/lib/lev/exceptions.rb

@@ -0,0 +1 @@
+class IsolationMismatch < StandardError; end

data/lib/lev/form_builder.rb

@@ -0,0 +1,63 @@
+module Lev
+  class FormBuilder < ActionView::Helpers::FormBuilder
+
+    (field_helpers - %w(label check_box radio_button fields_for file_field)).each do |selector|
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{selector}(method, options = {})                       # def text_field(method, options = {})
+          set_value_if_available(method, options)                   #   ... verbatim ...
+          mark_error_if_present(method, options)                    #   ... verbatim ...
+          super(method, options)                                    #   ... verbatim ...
+        end                                                         # end
+      RUBY_EVAL
+    end
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      options[:checked] = true if get_form_params_entry(method).to_i > 0
+      mark_error_if_present(method, options)
+      super(method, options, checked_value, unchecked_value)
+    end
+
+    def radio_button(method, tag_value, options = {})
+      options[:checked] = true if get_form_params_entry(method) == tag_value
+      mark_error_if_present(method, options)
+      super(method, tag_value, options)
+    end
+
+    def fields_for(record_name, record_object = nil, fields_options = {}, &block)
+      raise "Didn't put fields_for into LevitateFormBuilder yet"
+    end
+
+  protected
+
+    def get_form_params_entry(name)
+      @options[:params].present? ? 
+        (@options[:params][@object_name].present? ?
+          @options[:params][@object_name][name] :
+          nil) :
+        nil
+    end
+
+    def has_error?(name)
+      @options[:errors].present? ? @options[:errors].has_offending_param?([@object_name, name]) : false
+    end
+
+    def set_value_if_available(method, options)
+      value = get_form_params_entry(method)
+      options[:value] ||= value if !value.nil?
+    end
+
+    def mark_error_if_present(method, options)
+      if has_error?(method)
+        options[:class] = [options[:class], Lev.configuration.form_error_class].compact.join(' ')
+      end
+    end
+
+  end
+end
+
+def lev_form_for(record_or_name_or_array, *args, &proc)
+  options = args.extract_options!
+  options[:params] = params
+  options[:errors] = @errors || []
+  form_for(record_or_name_or_array, *(args << options.merge(:builder => Lev::FormBuilder)), &proc)
+end