rails_core_extensions 0.0.1

data/lib/rails_core_extensions/active_record_liquid_extensions.rb

@@ -0,0 +1,32 @@
+module RailsCoreExtensions
+  module ActiveRecordLiquidExtensions
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    def validates_liquid(field)
+      field = field.to_sym
+      before_validation do |record|
+        begin
+          Liquid::Template.parse(record.send(field))
+        rescue Liquid::SyntaxError => e
+          record.errors.add(field, "Liquid Syntax Error: #{e}")
+        end
+      end
+    end
+
+    def liquid_field(field)
+      class_eval <<-CODE
+        def parsed_#{field}
+          Liquid::Template.parse(#{field})
+        end
+
+        def render_#{field}(*args)
+          parsed_#{field}.render!(*args)
+        end
+      CODE
+    end
+  end
+end

data/lib/rails_core_extensions/active_support_concern.rb

@@ -0,0 +1,134 @@
+module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.send(:include, InstanceMethods)
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
+  # module which depends on the former, we would typically write the following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
+  # these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo 
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
+  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  #
+  module Concern
+    def self.extended(base)
+      base.instance_variable_set("@_dependencies", [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?("@_dependencies")
+        base.instance_variable_get("@_dependencies") << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+        base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
+        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        @_included_block = block
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rails_core_extensions/breadcrumb.rb

@@ -0,0 +1,170 @@
+module RailsCoreExtensions
+
+  module Breadcrumb
+
+    def breadcrumbs(object_or_nested_array = nil)
+      breadcrumbs_builder_for(object_or_nested_array).breadcrumbs
+    end
+
+
+    private
+
+    def breadcrumbs_builder_for(object_or_nested_array)
+      BreadcrumbsBuilder.new(self, object_or_nested_array)
+    end
+
+
+    class BreadcrumbsBuilder
+
+      attr_reader :view, :object_or_nested_array, :path
+
+      def initialize(view, object_or_nested_array = nil)
+        @view                     =   view
+        @object_or_nested_array   =   object_or_nested_array ||   path_builder.nested_array
+        @path                     =   path_builder.collection_url
+      end
+
+
+      def breadcrumbs
+        view.content_tag :ul, :class =>'breadcrumb' do
+          (breadcrumb_for_parent + breadcrumb_for_collection + breadcrumb_for_action).html_safe
+        end
+      end
+
+
+      def breadcrumb_for_object_link
+        breadcrumb_for link_to_object
+      end
+
+
+      private
+
+      def breadcrumb_for_parent
+        parent = path_builder.parent
+        return ''.html_safe unless parent
+        BreadcrumbsBuilder.new(view, parent).breadcrumb_for_object_link
+      end
+
+
+      def breadcrumb_for_collection
+        breadcrumb_for view.link_to(object.class.table_name.titleize, path)
+      end
+
+
+      def breadcrumb_for_action
+        case action
+          when 'new'    then breadcrumb_for('New', :class => 'active')
+          when 'edit'   then breadcrumb_for_object + breadcrumb_for('Edit', :class => 'active')
+          else breadcrumb_for_object_name
+        end
+      end
+
+
+      def breadcrumb_for_object
+        if can_show?
+          breadcrumb_for_object_link
+        else
+          breadcrumb_for_object_name
+        end
+      end
+
+
+      def breadcrumb_for(content, options = {})
+        view.content_tag :li, content, options
+      end
+
+
+      def breadcrumb_for_object_name
+        breadcrumb_for object_name.html_safe
+      end
+
+
+      def link_to_object
+        view.link_to object_name.html_safe, object_or_nested_array
+      end
+
+
+      def can_show?
+        view.controller.respond_to?(:show)
+      end
+
+
+      def action
+        return 'new' if object.new_record?
+        view.params[:action]
+      end
+
+
+      def object_name
+        if object.respond_to?(:name) && object.name.present?
+          object.name
+        else
+          object.to_s
+        end
+      end
+
+
+      def object
+        @object ||= Array(object_or_nested_array).last
+      end
+
+
+      def path_builder
+        @path_builder ||= if inherited_resources?
+                            InheritedResourcesPathBuilder.new(view)
+                          else
+                            PathBuilder.new(view)
+                          end
+      end
+
+
+      def inherited_resources?
+        defined?(InheritedResources) && view.controller.responder == InheritedResources::Responder
+      end
+
+    end
+
+
+    PathBuilder = Struct.new(:view) do
+      def nested_array
+        (namespaces + [parent] + [view.current_object]).compact
+      end
+
+      def collection_url
+        view.objects_path
+      end
+
+      def parent
+        view.parent_object
+      end
+
+      def namespaces
+        return [] unless view.respond_to?(:namespaces)
+        Array(view.namespaces)
+      end
+    end
+
+
+    InheritedResourcesPathBuilder = Struct.new(:view) do
+      def nested_array
+        if view.respond_to? :calculate_nested_array
+          view.calculate_nested_array
+        else
+          [parent, view.resource].compact
+        end
+      end
+
+      def collection_url
+        view.collection_url
+      end
+
+      def parent
+        return view.parent.becomes(view.parent.class.base_class) if view.respond_to?(:parent)
+        view.parent_object
+      end
+    end
+
+  end
+end
+
+ActionView::Base.send(:include, RailsCoreExtensions::Breadcrumb) if defined?(ActionView::Base)

data/lib/rails_core_extensions/caches_action_without_host.rb

@@ -0,0 +1,17 @@
+module CachesActionWithoutHost
+
+  def self.included(controller)
+    controller.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def caches_action_without_host(*args)
+      options = args.extract_options!
+      options ||= {}
+      options[:cache_path] ||= proc{|c| c.url_for(c.params).split(/\//, 4).last}
+      args << options
+      caches_action(*args)
+    end
+  end
+
+end

data/lib/rails_core_extensions/concurrency.rb

@@ -0,0 +1,152 @@
+module Concurrency
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def concurrency_safe(*methods)
+      options = methods.extract_options!
+      methods.each do |method|
+        add_concurrency_check(method, options)
+      end
+    end
+    
+    
+    def concurrency_safe_method_locked?(method)
+      concurrency_cache.read(concurrency_safe_method_cache_name(method)) == 'locked'
+    end
+    
+    
+    def concurrency_cache
+      @concurrency_cache ||= ::Rails.cache
+    end
+    
+    
+    def concurrency_cache=(cache)
+      [:read,:write,:delete].each do |method|
+        raise ConcurrencyCacheException, "#{cache} does not implement #{method}" unless cache.respond_to?(method)
+      end
+      @concurrency_cache = cache
+    end
+    
+    
+    private
+    
+    def add_concurrency_check(method, options = {})
+      method_definition = <<-DEFINITION
+        def #{method}_with_concurrency_lock(*args)
+          if concurrency_safe_method_locked?(:#{method})
+            raise ConcurrentCallException.new(self,:#{method}), "#{self.name}.#{method} is already running"
+          end
+          lock_concurrency_safe_method(:#{method})
+          return_value = nil
+          begin
+            return_value = #{method}_without_concurrency_lock(*args)
+          ensure
+            unlock_concurrency_safe_method(:#{method})
+          end
+          return_value
+        end
+
+        alias_method_chain :#{method}, :concurrency_lock
+      DEFINITION
+      
+      if method_type(method, options[:type]) == 'class'
+        method_definition = <<-DEFINITION
+          class << self
+            #{method_definition}
+          end
+        DEFINITION
+      end
+      
+      module_eval method_definition
+    end
+    
+    
+    def lock_concurrency_safe_method(method)
+      concurrency_cache.write(concurrency_safe_method_cache_name(method), 'locked')
+    end
+    
+    
+    def unlock_concurrency_safe_method(method)
+      concurrency_cache.delete(concurrency_safe_method_cache_name(method))
+    end
+    
+    
+    def concurrency_safe_method_cache_name(method)
+      "#{self.name.underscore}_concurrency_safe_class_method_#{method}"
+    end
+    
+    
+    def method_type(method, type = nil)
+      types = method_types(method, type)
+      raise AmbiguousMethodException.new(self, method), "#{method} for #{self.name} is ambiguous. Please specify the type (instance/class) option" if types.count == 2
+      raise NoMethodException.new(self, method), "#{method} is not not a valid method for #{self.name}." if types.blank?
+      types.first
+    end
+    
+    
+    def method_types(method, type = nil)
+      ['class', 'instance'].select do |mt|
+        (type.blank? || type.to_s == mt) && self.send("#{mt}_method?", method)
+      end
+    end
+    
+    
+    def class_method?(method)
+      self.respond_to?(method, true)
+    end
+    
+    
+    def instance_method?(method)
+      (self.instance_methods + self.private_instance_methods).map(&:to_s).include?(method.to_s)
+    end
+    
+  end
+  
+  
+  module InstanceMethods
+    
+    def concurrency_cache
+      self.class.concurrency_cache
+    end
+    
+    
+    def concurrency_safe_method_locked?(method)
+      concurrency_cache.read(concurrency_safe_method_cache_name(method)) == 'locked'
+    end
+    
+    
+    private
+    
+    def lock_concurrency_safe_method(method)
+      concurrency_cache.write(concurrency_safe_method_cache_name(method), 'locked')
+    end
+    
+    
+    def unlock_concurrency_safe_method(method)
+      concurrency_cache.delete(concurrency_safe_method_cache_name(method))
+    end
+    
+    
+    def concurrency_safe_method_cache_name(method)
+      "#{self.class.name.underscore}_concurrency_safe_instance_method_#{method}"
+    end
+    
+  end
+  
+  
+  class ConcurrencyException < ::Exception; end
+  class ConcurrencyCacheException < ConcurrencyException; end
+  class MethodException < ConcurrencyException
+    attr_reader :object, :method
+    
+    def initialize(object, method)
+      @object = object
+      @method = method
+    end
+  end
+  class ConcurrentCallException < MethodException; end
+  class NoMethodException < MethodException; end
+  class AmbiguousMethodException < MethodException; end
+    
+end