hammock 0.2.11.2

data/lib/hammock/monkey_patches/active_record.rb

@@ -0,0 +1,231 @@
+module Hammock
+  module ActiveRecordPatches
+    MixInto = ActiveRecord::Base
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods # TODO maybe include in the metaclass instead of extending the class?
+
+      %w[before_undestroy after_undestroy].each {|callback_name|
+        MixInto.define_callbacks callback_name
+        # base.send :define_method, callback_name, lambda { }
+      }
+    end
+
+    module ClassMethods
+
+      def new_with attributes
+        default_attributes.merge(attributes).inject(new) {|record,(k,v)|
+          record.send "#{k}=", v
+          record
+        }
+      end
+
+      def sorter
+        # TODO updated_at DESC
+        proc {|record| record.id }
+      end
+
+      def resource
+        base_class
+      end
+
+      def resource_sym
+        resource_name.to_sym
+      end
+
+      def resource_name
+        # TODO almost certainly a better way to do this
+        base_class.to_s.pluralize.underscore
+      end
+
+      def param_key
+        "#{base_model}_id"
+      end
+
+      def base_model
+        base_class.to_s.underscore
+      end
+
+      def description
+        base_model
+      end
+
+      def record?; false end
+      def resource?; true end
+
+      def update_statement set_clause, where_clause
+        statement = "UPDATE #{table_name} SET #{set_clause} WHERE #{send :sanitize_sql_array, where_clause}"
+        connection.update statement
+      end
+
+      def reset_cached_column_info
+        reset_column_information
+        subclasses.each &:reset_cached_column_info
+      end
+      
+      def find_or_new_with(find_attributes, create_attributes = {})
+        finder = respond_to?(:find_with_deleted) ? :find_with_deleted : :find
+
+        if record = send(finder, :first, :conditions => find_attributes.discard(:deleted_at))
+          # Found the record, so we can return it, if:
+          # (a) the record can't have a stored deletion state,
+          # (b) it can, but it's not actually deleted,
+          # (c) it is deleted, but we want to find one that's deleted, or
+          # (d) we don't want a deleted record, and undestruction succeeds.
+          if (finder != :find_with_deleted) || !record.deleted? || create_attributes[:deleted_at] || record.undestroy
+            record
+          end
+        else
+          creating_class = if create_attributes[:type].is_a?(ActiveRecord::Base)
+            create_attributes.delete(:type)
+          else
+            self
+          end
+          creating_class.new_with create_attributes.merge(find_attributes)
+        end
+      end
+
+      def find_or_create_with(find_attributes, create_attributes = {}, adjust_attributes = false)
+        if record = find_or_new_with(find_attributes, create_attributes)
+          log "Create failed. #{record.errors.inspect}", :skip => 1 if record.new_record? && !record.save
+          log "Adjust failed. #{record.errors.inspect}", :skip => 1 if adjust_attributes && !record.adjust(create_attributes)
+          record
+        end
+      end
+      
+      # def find_or_create_with! find_attributes, create_attributes = {}, adjust_attributes = false)
+      #   record = find_or_new_with find_attributes, create_attributes, adjust_attributes
+      #   record.valid? ? record : raise("Save failed. #{record.errors.inspect}")
+      # end
+
+    end
+
+    module InstanceMethods
+
+      def concise_inspect
+        "#{self.class}<#{self.to_param || 'new'}>"
+      end
+
+      def resource
+        self.class.resource
+      end
+
+      def resource_sym
+        self.class.resource_sym
+      end
+
+      def resource_name
+        self.class.resource_name
+      end
+
+      def record?; true end
+      def resource?; false end
+
+      def id_str
+        if new_record?
+          "new_#{base_model}"
+        else
+          "#{base_model}_#{id}"
+        end
+      end
+
+      def description
+        new_record? ? "new_#{base_model}" : "#{base_model}_#{id}"
+      end
+
+      def base_model
+        self.class.base_model
+      end
+
+      def new_or_deleted_before_save?
+        @new_or_deleted_before_save
+      end
+      def set_new_or_deleted_before_save
+        @new_or_deleted_before_save = new_record? || send_if_respond_to(:deleted?)
+      end
+
+      def undestroy
+        unless new_record?
+          if frozen?
+            self.class.find_with_deleted(self.id).undestroy # Re-fetch ourselves and undestroy the thawed copy
+          else
+            # We can undestroy
+            return false if callback(:before_undestroy) == false
+            result = self.class.update_all ['deleted_at = ?', (self.deleted_at = nil)], ['id = ?', self.id]
+            callback(:after_undestroy)
+            self if result != false
+          end
+        end
+      end
+
+      # Updates each given attribute to the current time.
+      #
+      # Assumes that each column can accept a +Time+ instance, i.e. that they're all +datetime+ columns or similar.
+      #
+      # The updates are done with update_attribute, and as such they are done with callbacks but
+      # without validation.
+      def touch *attrs
+        now = Time.now
+        attrs.each {|attribute|
+          update_attribute attribute, now
+        }
+      end
+
+      # Updates each given attribute to the current time, skipping attributes that are already set.
+      #
+      # Assumes that each column can accept a +Time+ instance, i.e. that they're all +datetime+ columns or similar.
+      #
+      # The updates are done with update_attribute, and as such they are done with callbacks but
+      # without validation.
+      def touch_once *attrs
+        touch *attrs.select {|attribute| attributes[attribute.to_s].nil? }
+      end
+
+      def adjust attrs
+        attrs.each {|k,v| send "#{k}=", v }
+        save false
+      end
+
+      def unsaved_attributes
+        self.changed.inject({}) {|hsh,k|
+          hsh[k] = attributes[k]
+          hsh
+        }
+      end
+
+      # Offset +attribute+ by +offset+ atomically in SQL.
+      def offset! attribute, offset
+        if new_record?
+          log "Can't offset! a new record."
+        else
+          # Update the in-memory model
+          send "#{attribute}=", send(attribute) + offset
+          # Update the DB
+          run_updater_sql 'Offset', "#{connection.quote_column_name(attribute)} = #{connection.quote_column_name(attribute)} + #{quote_value(offset)}"
+        end
+      end
+
+
+      private
+
+      def run_updater_sql logger_prefix, set_clause
+        connection.update(
+          "UPDATE #{self.class.table_name} " +
+          "SET #{set_clause} " +
+          "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}",
+
+          "#{self.class.name} #{logger_prefix}"
+        ) != false
+      end
+
+      # TODO Use ambition for association queries.
+      # def self.collection_reader_method reflection, association_proxy_class
+      #   define_method(reflection.name) do |*params|
+      #     reflection.klass.ambition_context.select { |entity| entity.__send__(reflection.primary_key_name) == quoted_id }
+      #   end
+      # end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/array.rb

@@ -0,0 +1,73 @@
+module Hammock
+  module ArrayPatches
+    MixInto = Array
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # Returns true iff +other+ appears exactly at the start of +self+.
+      def starts_with? *other
+        self[0, other.length] == other
+      end
+
+      # Returns true iff +other+ appears exactly at the end of +self+.
+      def ends_with? *other
+        self[-other.length, other.length] == other
+      end
+
+      def squash
+        self.dup.squash!
+      end
+      def squash!
+        self.delete_if &:blank?
+      end
+
+      def discard *args
+        self.dup.discard! *args
+      end
+      def discard! *args
+        args.each {|arg| self.delete arg }
+        self
+      end
+
+      def as_index_for &value_function
+        inject({}) do |accum, elem|
+          accum[elem] = value_function.call(elem)
+          accum
+        end
+      end
+
+      def remove_framework_backtrace
+        reverse.drop_while {|step|
+          !step.starts_with?(RAILS_ROOT)
+        }.reverse
+      end
+
+      def hash_by *methods, &block
+        hsh = Hash.new {|h,k| h[k] = [] }
+        this_method = methods.shift
+
+        # First, hash this array into +hsh+.
+        self.each {|i| hsh[i.send(this_method)] << i }
+
+        if methods.empty?
+          # If there are no methods remaining, yield this group to the block if required.
+          hsh.each_pair {|k,v| hsh[k] = yield(hsh[k]) } if block_given?
+        else
+          # Recursively hash remaining methods.
+          hsh.each_pair {|k,v| hsh[k] = v.hash_by(*methods, &block) }
+        end
+
+        hsh
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/hash.rb

@@ -0,0 +1,57 @@
+module Hammock
+  module HashPatches
+    MixInto = Hash
+    
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      def discard! *keys
+        keys.each {|k| delete k }
+        self
+      end
+
+      def discard *keys
+        dup.discard! *keys
+      end
+
+      def selekt &block
+        hsh = {}
+        each_pair {|k,v|
+          hsh[k] = v if yield(k,v)
+        }
+        hsh
+      end
+
+      def dragnet *keys
+        dup.dragnet! *keys
+      end
+
+      def dragnet! *keys
+        keys.inject({}) {|acc,key|
+          acc[key] = self.delete(key) if self.has_key?(key)
+          acc
+        }
+      end
+
+      def to_param_hash prefix = ''
+        hsh = self.dup
+        # TODO these two blocks can probably be combined
+        hsh.keys.each {|k| hsh.merge!(hsh.delete(k).to_param_hash(k)) if hsh[k].is_a?(Hash) }
+        hsh.keys.each {|k| hsh["#{prefix}[#{k}]"] = hsh.delete(k) } unless prefix.blank?
+        hsh
+      end
+
+      def to_flattened_json
+        to_param_hash.to_json
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/logger.rb

@@ -0,0 +1,28 @@
+module Hammock
+  module BufferedLoggerPatches
+    MixInto = ActiveSupport::BufferedLogger
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      # base.class_eval {
+      #   alias_method_chain :fatal, :color
+      # }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      def fatal_with_color message = nil, progname = nil, &block
+        first_line, other_lines = message.strip.split("\n", 2)
+        fatal_without_color "\n" + first_line.colorize('on red'), progname, &block
+        fatal_without_color other_lines.colorize('red') + "\n\n", progname, &block
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/module.rb

@@ -0,0 +1,27 @@
+module Hammock
+  module ModulePatches
+    MixInto = Module
+    LoadFirst = true
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      def alias_method_chain_once target, feature
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        unless [public_instance_methods, protected_instance_methods, private_instance_methods].flatten.include? without_method
+          alias_method_chain target, feature
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/numeric.rb

@@ -0,0 +1,25 @@
+module Hammock
+  module NumericPatches
+    MixInto = Numeric
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods # TODO maybe include in the metaclass instead of extending the class?
+
+      base.class_eval {
+        alias kb kilobytes
+        alias mb megabytes
+        alias gb gigabytes
+        alias tb terabytes
+      }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/object.rb

@@ -0,0 +1,61 @@
+module Hammock
+  module ObjectPatches
+    MixInto = Object
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        alias is_an? is_a?
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # Return +self+ after yielding to the given block.
+      #
+      # Useful for inline logging and diagnostics. Consider the following:
+      #     @items.map {|i| process(i) }.join(", ")
+      # With +tap+, adding intermediate logging is simple:
+      #     @items.map {|i| process(i) }.tap {|obj| log obj.inspect }.join(", ")
+      #--
+      # TODO Remove for Ruby 1.9
+      def tap
+        yield self
+        self
+      end
+      
+      # The reverse of <tt>Enumerable#include?</tt> - returns +true+ if +self+ is
+      # equal to one of the elements of +args+.
+      def in? *args
+        args.include? self
+      end
+
+      # A symbolized, underscored (i.e. reverse-camelized) representation of +self+.
+      #
+      # Examples:
+      #
+      #     Hash.symbolize                     #=> :hash
+      #     ActiveRecord::Base.symbolize       #=> :"active_record/base"
+      #     "GetThisCamelOffMyCase".symbolize  #=> :get_this_camel_off_my_case
+      def symbolize
+        self.to_s.underscore.to_sym
+      end
+
+      # If +condition+ evaluates to true, return the result of sending +method_name+ to +self+; <tt>*args</tt> to +self+, otherwise, return +self+ as-is.
+      def send_if condition, method_name, *args
+        condition ? send(method_name, *args) : self
+      end
+
+      # If +condition+ evaluates to true, return the result of sending +method_name+ to +self+; <tt>*args</tt> to +self+, otherwise, return +self+ as-is.
+      def send_if_respond_to method_name, *args
+        send_if respond_to?(method_name), method_name, *args
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/route_set.rb

@@ -0,0 +1,28 @@
+module Hammock
+  module RouteSetPatches
+    MixInto = ActionController::Routing::RouteSet
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        attr_accessor :route_map
+      }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def initialize_hammock_route_map
+        self.route_map = Hammock::RouteNode.new
+      end
+
+    end
+  end
+end