benhoskings-hammock 0.2.4

data/lib/hammock/model_attributes.rb

@@ -0,0 +1,38 @@
+module Hammock
+  module ModelAttributes
+    MixInto = ActiveRecord::Base
+    
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      def has_defaults attrs
+        write_inheritable_attribute "default_attributes", (default_attributes || {}).merge(attrs)
+      end
+      def attr_accessible_on_create *attributes
+        write_inheritable_attribute "attr_accessible_on_create", Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_create || [])
+      end
+      def attr_accessible_on_update *attributes
+        write_inheritable_attribute "attr_accessible_on_update", Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_update || [])
+      end
+
+      def default_attributes
+        read_inheritable_attribute("default_attributes") || {}
+      end
+      def accessible_attributes_on_create
+        read_inheritable_attribute "attr_accessible_on_create"
+      end
+      def accessible_attributes_on_update
+        read_inheritable_attribute "attr_accessible_on_update"
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end

data/lib/hammock/model_logging.rb

@@ -0,0 +1,30 @@
+module Hammock
+  module ModelLogging
+    MixInto = ActiveRecord::Base
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      include Hammock::Utils::Methods
+      include Hammock::Logging::Methods
+    end
+
+    module InstanceMethods
+      include Hammock::Utils::Methods
+      include Hammock::Logging::Methods
+
+      def log_with_model *args
+        opts = args.extract_options!
+
+        message = "#{self.class}<#{self.id}>#{(' | ' + args.shift) if args.first.is_a?(String)}"
+
+        log_without_model *args.unshift(message).push(opts.merge(:skip => (opts[:skip] || 0) + 1))
+      end
+      alias_method_chain :log, :model
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/action_pack.rb

@@ -0,0 +1,32 @@
+module Hammock
+  module ActionControllerPatches
+    MixInto = ActionController::Rescue
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+      
+      # base.class_eval {
+      #   alias_method_chain :clean_backtrace, :truncation
+      # }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def clean_backtrace_with_truncation exception
+        if backtrace = clean_backtrace_without_truncation(exception)
+          backtrace.take_while {|line|
+            line['perform_action_without_filters'].nil?
+          }.push("... and so on")
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/active_record.rb

@@ -0,0 +1,227 @@
+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 base_model
+        base_class.to_s.underscore
+      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.id || '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 id_or_description
+        new_record? ? new_record_description : id
+      end
+      
+      def new_record_description
+        attributes.map {|k,v| "#{k}-#{(v.to_s || '')[0..10]}" }.join("_")
+      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,49 @@
+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 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