rails_core_extensions 0.0.1

data/lib/rails_core_extensions/action_controller_sortable.rb

@@ -0,0 +1,22 @@
+module RailsCoreExtensions
+  module ActionControllerSortable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def sortable
+        include RailsCoreExtensions::ActionControllerSortable::InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      def sort
+        RailsCoreExtensions::Sortable.new(params, controller_name).sort
+
+        render :update do |page|
+        end
+      end
+    end
+  end
+end

data/lib/rails_core_extensions/action_view_currency_extensions.rb

@@ -0,0 +1,26 @@
+module ActionView
+  module Helpers
+    module FormTagHelper
+      # Create currency selector tag -- see select_tag for options
+      def currency_select_tag(name, current_value, options={})
+        selectable_options = []
+        selectable_options << ["--", nil] if options[:include_blank]
+        selectable_options += EnabledCurrency.all.map(&:iso_code) unless EnabledCurrency.all.empty?
+        select_tag(name, options_for_select(selectable_options, current_value), options)
+      end
+    end
+
+    module DateHelper
+      def currency_select(object_name, method, options = {})
+        value = options[:object] || EnabledCurrency.base_currency
+        currency_select_tag("#{object_name}[#{method}]", value, options.merge(:id => "#{object_name}_#{method}")) 
+      end
+    end
+
+    class FormBuilder
+      def currency_select(method, options = {})
+        @template.currency_select(@object_name, method, options.merge(:object => @object.send(method)))
+      end
+    end
+  end
+end

data/lib/rails_core_extensions/action_view_extensions.rb

@@ -0,0 +1,62 @@
+module RailsCoreExtensions
+  module ActionViewExtensions
+    def textilize(content)
+      super(h(content)).html_safe
+    end
+
+    # Will recursively parse a Hash and any sub hashes to be normal hashes
+    # This is useful when exporting hashes to non ruby systems, which don't understand HashWithIndifferentAccess
+    def hashify(element)
+      if element.is_a? Hash
+        element = element.to_hash if element.is_a?(HashWithIndifferentAccess)
+        element.each_pair do |key, value|
+          element[key] = hashify(value)
+        end
+      else
+        # Must hashify enumerables encase their sub items are hashes
+        # Can't enumerate through string as it returns strings, which are also enumerable (stack level too deep)
+        if element.respond_to?(:each) && !element.is_a?(String)
+          element.map{ |sub| hashify(sub) }
+        else
+          element
+        end
+      end
+    end
+
+    # Generates a tooltip with given text
+    # text is textilized before display
+    def tooltip(hover_element_id, text, title='')
+      content = "<div style='width: 25em'>#{textilize(text)}</div>"
+      "<script>" +
+        "new Tip('#{hover_element_id}', '#{escape_javascript(content)}',"+
+        "{title : '#{escape_javascript title}', className: 'silver_smaller_div',"+
+        "showOn: 'mouseover', hideOn: { event: 'mouseout' }, fixed: false});"+
+      "</script>"
+    end
+
+    def expandable_list_for(objects, show = 4)
+      first, others = objects[0..(show-1)], objects[show..(objects.size-1)]
+      first.each do |o|
+        yield o
+      end
+      if others
+        content_tag 'div', :id => 'others', :style => 'display: none' do
+          others.each do |o|
+            yield o
+          end
+        end
+        "#{others.size} Others - ".html_safe + link_to_function("Show/Hide", "$('others').toggle()")
+      end
+    end
+
+    def boolean_select_tag(name, *args)
+      options = args.extract_options!
+      options ||= {}
+      opts = [['Yes', '1'], ['No', '0']]
+      opts = [blank_option] + opts if options[:include_blank]
+      select_tag name, options_for_select(opts, options[:selected])
+    end
+  end
+end
+
+ActionView::Base.send(:include, RailsCoreExtensions::ActionViewExtensions) if defined?(ActionView::Base)

data/lib/rails_core_extensions/action_view_has_many_extensions.rb

@@ -0,0 +1,32 @@
+module RailsCoreExtensions
+  module HasManyExtensions
+    module Tags
+      def hm_check_box(object_name, method, options = {})
+        object = options.delete(:object)
+        parent = options.delete(:parent) || instance_variable_get(object_name)
+        objects = options.delete(:objects) || parent.send(method)
+        check_box_tag("#{object_name}[#{method}][]", object, objects.include?(object), options.merge(:id => "#{object_name}_#{method}"))
+      end
+
+      def hm_empty_array(object_name, method)
+        hidden_field_tag "#{object_name}[#{method}][]"
+      end
+    end
+
+    module FormBuilder
+      def hm_empty_array(method)
+        @habtm_fields ||= {}
+        @habtm_fields[method] = @object.send(method)
+        @template.hm_empty_array(@object_name, method)
+      end
+
+      def hm_check_box(method, object, options = {})
+        empty = (hm_empty_array(method) unless @habtm_fields && @habtm_fields[method])
+        (empty || '').html_safe + @template.hm_check_box(@object_name, method, options.merge(:object => object, :parent => @object, :objects => @habtm_fields[method]))
+      end
+    end
+  end
+end
+
+ActionView::Base.send(:include, RailsCoreExtensions::HasManyExtensions::Tags) if defined?(ActionView::Base)
+ActionView::Helpers::FormBuilder.send(:include, RailsCoreExtensions::HasManyExtensions::FormBuilder) if defined?(ActionView::Base)

data/lib/rails_core_extensions/activatable.rb

@@ -0,0 +1,38 @@
+module Activatable
+
+  def self.included(controller)
+    controller.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def activatable
+      include Activatable::InstanceMethods
+    end
+
+  end
+
+  module InstanceMethods
+
+    def activate(success_block = nil)
+      resource.active = params[:active].presence || false
+      action = resource.active ? 'activate' : 'inactivate'
+
+      resource.save!
+
+      success_block ||= -> {
+        flash[:success] = "#{resource} #{action}d"
+        redirect_to(collection_path)
+      }
+
+      success_block.call
+
+    rescue ActiveRecord::ActiveRecordError => e
+      resource.errors.add(:base, "Failed to #{action}: " + e.message)
+      flash[:error] = resource.errors.full_messages.to_sentence
+      redirect_to(collection_path)
+    end
+
+  end
+
+end

data/lib/rails_core_extensions/active_model_extensions.rb

@@ -0,0 +1,47 @@
+module ActiveModelExtensions
+  module Validations
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Validates the presence of the required fields identified in a rule-string.
+    #
+    # Similar to validates_presence_of macro, but is an INSTANCE method.
+    # This allows it to vary depending on custom settings.
+    #
+    # Example:
+    # validate_required_fields "field1,field2 or field4"
+    #
+
+    # The string is a CSV of required field rules, where each field rule is:
+    #  - the name of a required field
+    #  - OR a set of required field names spearated by 'or' (where only ONE is required)
+    #
+    class CustomPresenceValidator < ActiveModel::Validator
+      def validate(record)
+        required_fields = Array.wrap(@options[:attributes]).first.call || []
+        return if required_fields.empty?
+
+        required_fields.flatten.each do |required_field|
+          if required_field.include? ' or '
+            fields = required_field.split(' or ')
+            if fields.all? { |field| record.send(field).to_s.blank? }
+              record.errors.add(:base, "One of %s is required" % fields.map(&:humanize).to_sentence)
+            end
+          else
+            if record.send(required_field).to_s.blank?
+              record.errors.add(required_field, "is required")
+            end
+          end
+        end
+
+      end
+    end
+
+    module ClassMethods
+      def validate_presence_by_custom_rules(*with)
+        validates_with CustomPresenceValidator, _merge_attributes(with)
+      end
+    end
+  end
+end

data/lib/rails_core_extensions/active_record_cache_all_attributes.rb

@@ -0,0 +1,43 @@
+module ActiveRecordCacheAllAttributes
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module InstanceMethods
+    def clear_attribute_cache
+      self.class.cache.delete("#{self.class.name}.attribute_cache") if self.class.should_cache?
+    end
+  end
+
+  module ClassMethods
+    def cache
+      Rails.cache
+    end
+
+    def attribute_cache
+      cache_key = "#{self.name}.attribute_cache"
+      if self.should_cache?
+        cache.read(cache_key) || self.generate_cache(cache_key)
+      else
+        self.generate_attributes_hash
+      end
+    end
+
+    def generate_attributes_hash
+      scope = self
+      scope = scope.ordered if respond_to?(:ordered)
+      Hash[scope.all.map { |o| [o.send(self.cache_attributes_by), o.attributes] }]
+    end
+
+    def generate_cache(cache_key)
+      if (cache_value = generate_attributes_hash)
+        cache.write(cache_key, cache_value)
+      end
+      cache_value
+    end
+
+    def should_cache?
+      Rails.configuration.action_controller.perform_caching
+    end
+  end
+end

data/lib/rails_core_extensions/active_record_cloning.rb

@@ -0,0 +1,81 @@
+module ActiveRecordCloning
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def inherited(subclass)
+      super
+      subclass.cloned_attributes_hash = cloned_attributes_hash
+    end
+
+    def attributes_included_in_cloning
+      cloned_attributes_hash[:include].dup
+    end
+
+    def attributes_excluded_from_cloning
+      cloned_attributes_hash[:exclude].dup
+    end
+
+    def clones_attributes(*attributes)
+      cloned_attributes_hash[:include] = attributes.map(&:to_sym)
+    end
+
+    def clones_attributes_except(*attributes)
+      cloned_attributes_hash[:exclude] = attributes.map(&:to_sym)
+    end
+
+    protected
+
+    def cloned_attributes_hash
+      @cloned_attributes ||= {:include => [], :exclude => []}
+    end
+
+    def cloned_attributes_hash=(attributes_hash)
+      @cloned_attributes = attributes_hash
+    end
+
+  end
+
+  module InstanceMethods
+
+    def self.included(base)
+      base.class_eval %q{
+        alias_method :base_clone_attributes, :clone_attributes
+        def clone_attributes(reader_method = :read_attribute, attributes = {})
+          allowed = cloned_attributes
+          base_clone_attributes(reader_method, attributes).delete_if { |k,v| !allowed.include?(k.to_sym) }
+        end
+      }
+    end
+
+    def clone_excluding(excludes=[])
+      method = ActiveRecord::Base.instance_methods(false).include?(:clone) ? :clone : :dup
+      cloned = send(method)
+
+      excludes ||= []
+      excludes = [excludes] unless excludes.is_a?(Enumerable)
+
+      excludes.each do |excluded_attr|
+        attr_writer = (excluded_attr.to_s + '=').to_sym
+        cloned.send attr_writer, nil
+      end
+
+      cloned
+    end
+
+    private
+
+    def cloned_attributes
+      included_attributes = if self.class.attributes_included_in_cloning.empty?
+        attribute_names.map(&:to_sym)
+      else
+        attribute_names.map(&:to_sym) & self.class.attributes_included_in_cloning
+      end
+      included_attributes - self.class.attributes_excluded_from_cloning
+    end
+  end
+
+end

data/lib/rails_core_extensions/active_record_extensions.rb

@@ -0,0 +1,228 @@
+module ActiveRecordExtensions
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    # Like establish_connection but postfixes the key with the rails environment
+    # e.g. database('hello') in development will look for the database
+    #      which in config/database.yml is called hello_development
+    def database(key)
+      establish_connection("#{key}_#{Rails.env}")
+    end
+
+    def cache_all_attributes(options = {})
+      method = options[:by] || 'id'
+      class_eval <<-CACHE
+        after_save :clear_attribute_cache
+        after_destroy :clear_attribute_cache
+        cattr_accessor :cache_attributes_by
+        self.cache_attributes_by = '#{method}'
+      CACHE
+      extend ActiveRecordCacheAllAttributes::ClassMethods
+      include ActiveRecordCacheAllAttributes::InstanceMethods
+    end
+
+    # Create a new object from the attributes passed in
+    # OR update an existing
+    #
+    # If an :id attribute is present it will assume it's an existing record, and needs update
+    def new_or_update!(hash={}, options = {:hard_update => true})
+      hash.symbolize_keys!
+      if hash[:id].blank?
+        self.new(hash)
+      else
+        rec = self.find(hash[:id])
+        if options[:hard_update]
+          rec.update_attributes!(hash.except(:id))
+        else
+          rec.update_attributes(hash.except(:id))
+        end
+        rec
+      end
+    end
+    
+    def enum(field, values, options = {})
+      const_set("#{field.to_s.upcase}_OPTIONS", values)
+      
+      select_options = if values.is_a?(Array)
+        values.map.with_index{|v, i| [v.to_s.humanize, i]}
+      elsif values.is_a?(Hash)
+        values.values.map.with_index{|v, i| [v, i]}
+      end
+      const_set("#{field.to_s.upcase}_SELECT_OPTIONS", select_options)
+
+      values.each.with_index do |value, i|
+        const_set("#{field.to_s.upcase}_#{value.to_s.upcase}", i)
+        method_name = options[:short_name] ? "#{value}?" : "#{field}_#{value}?"
+        class_eval <<-ENUM
+          def #{method_name}
+            #{field} == #{i}
+          end
+        ENUM
+      end
+      class_eval <<-ENUM
+        def #{field}_name
+          #{field.to_s.upcase}_OPTIONS[#{field}]
+        end
+      ENUM
+    end
+
+    def optional_fields(*possible_fields)
+      @optional_fields_loader = possible_fields.pop if possible_fields.last.is_a?(Proc)
+
+      class << self
+        def enabled_fields
+          @enabled_fields || @optional_fields_loader.try(:call)
+        end
+
+        def enabled_fields=(fields)
+          @enabled_fields = fields
+        end
+      end
+
+      possible_fields.each do |field|
+        instance_eval <<-EVAL
+          def #{field}_enabled?
+            enabled_fields.include?(:#{field})
+          end
+        EVAL
+      end
+    end
+
+
+    def position_helpers_for(*collections)
+      collections.each do |collection|
+        class_eval <<-EVAL
+          after_save do |record|
+            record.rebalance_#{collection.to_s.singularize}_positions!
+          end
+
+          def assign_#{collection.to_s.singularize}_position(object)
+            object.position = (#{collection}.last.try(:position) || 0) + 1 unless object.position
+          end
+
+          def rebalance_#{collection.to_s.singularize}_positions!(object = nil)
+            reload
+            #{collection}.sort_by(&:position).each_with_index do |o, index|
+              if o.position != (index + 1)
+                o.update_attribute(:position, index + 1)
+              end
+            end
+          end
+        EVAL
+      end
+    end
+
+
+    # Validates presence of -- but works on parent within accepts_nested_attributes
+    #
+    def validates_presence_of_parent(foreign_key)
+      after_save do |record|
+        unless record.send(foreign_key)
+          record.errors.add_on_blank(foreign_key)
+          raise ActiveRecord::ActiveRecordError, record.errors.full_messages.to_sentence
+        end
+      end
+    end
+
+
+    # Run a block, being respectful of connection pools
+    #
+    # Useful for when you're not in the standard rails request process,
+    # since normally rails will take, then clear you're connection in the
+    # processing of the request.
+    #
+    # If you don't do this in, say, a command line task with threads, then
+    # you'll run out of connections after 5 x Threads are run simultaneously...
+    def with_connection_pooling
+      # Verify active connections and remove and disconnect connections
+      # associated with stale threads.
+      ActiveRecord::Base.verify_active_connections!
+
+      yield
+
+      # This code checks in the connection being used by the current thread back
+      # into the connection pool. It repeats this if you are using multiple
+      # connection pools. It will not disconnect the connection.
+      #
+      # Returns any connections in use by the current thread back to the pool,
+      # and also returns connections to the pool cached by threads that are no
+      # longer alive.
+      ActiveRecord::Base.clear_active_connections!
+
+    end
+
+
+    def translate(key, options = {})
+      klass = self
+      klass = klass.superclass while klass.superclass != ActiveRecord::Base
+      I18n.translate key, options.merge(:scope => klass.name.tableize.singularize)
+    end
+
+
+    def t(key, options = {})
+      self.translate(key, options)
+    end
+
+  end
+
+  
+  module InstanceMethods
+
+
+    def all_errors
+      errors_hash = {}
+      self.errors.each do |attr, msg|
+        (errors_hash[attr] ||= []) << if self.respond_to?(attr) && (record_attr = self.send(attr)).is_a?(ActiveRecord::Base)
+          record_attr.all_errors
+        else
+          msg
+        end
+      end
+      errors_hash
+    end
+
+
+    def to_drop
+      @drop_class ||= (self.class.name+'Drop').constantize
+      @drop_class.new(self)
+    end
+    alias_method :to_liquid, :to_drop
+
+
+    # A unique id - even if you are unsaved!
+    def unique_id
+      id || @generated_dom_id || (@generated_dom_id = Time.now.to_f.to_s.gsub('.', '_'))
+    end
+
+
+    #getting audits
+    def audit_log
+      return (self.methods.include?('audits') ? self.audits : [])
+    end
+
+
+
+    private
+
+    def t(key, options = {})
+      self.class.translate(key, options)
+    end
+
+
+    def transfer_records(klass, objects, options = {})
+      record_ids = objects.flat_map { |o|
+        o.send(klass.name.underscore + '_ids')
+      }
+      unless record_ids.empty?
+        options[:foreign_key] ||= self.class.name.underscore + '_id'
+        update_options = options.except(:foreign_key)
+        update_options[options[:foreign_key]] = id
+        klass.where(id: record_ids).update_all(update_options)
+      end
+    end
+
+  end
+
+end