adva-core 0.0.3 → 0.0.4

data/lib/core_ext/rails/action_view/has_many_through_collection_helpers.rb

@@ -0,0 +1,27 @@
+require 'action_view/helpers/form_helper'
+
+ActionView::Helpers::FormBuilder.send :include do
+  def has_many_through_collection_check_boxes(attribute, collection, label_attribute)
+    through_class = object.class.reflect_on_association(attribute).class_name.constantize
+    foreign_key = through_class.reflect_on_all_associations(:belongs_to).detect { |r| r.class_name != object.class.name }.primary_key_name
+
+    html = ''
+    collection.each_with_index do |item, ix|
+      param   = "#{object_name}[#{attribute}_attributes][#{ix}]"
+      through = object.send(attribute).detect { |t| t.send(foreign_key) == item.id }
+
+      if through
+        html << @template.hidden_field_tag("#{param}[id]", through.id, :id => '')
+        html << @template.hidden_field_tag("#{param}[_destroy]", '1', :id => '')
+        html << @template.label_tag("#{param}[_destroy]", :class => 'checkbox') do
+          @template.check_box_tag("#{param}[_destroy]", '0', true) + item.send(label_attribute)
+        end
+      else
+        html << @template.label_tag("#{param}[#{foreign_key}]", :class => 'checkbox') do
+          @template.check_box_tag("#{param}[#{foreign_key}]", item.id) + item.send(label_attribute)
+        end
+      end
+    end
+    html.html_safe
+  end
+end

data/lib/core_ext/rails/active_record/skip_callbacks.rb

@@ -0,0 +1,51 @@
+require 'active_support/basic_object'
+
+ActiveRecord::Base.class_eval do
+  class WithoutCallbacks < ActiveSupport::BasicObject
+    def initialize(target, types)
+      @target = target
+      @types  = types
+    end
+
+    def respond_to?(method, include_private = false)
+      @target.respond_to?(method, include_private)
+    end
+
+    def method_missing(method, *args, &block)
+      @target.skip_callbacks(*@types) do
+        @target.send(method, *args, &block)
+      end
+    end
+  end
+
+  class << self
+    def without_callbacks(*types)
+      WithoutCallbacks.new(self, types)
+    end
+
+    def skip_callbacks(*types)
+      deactivate_callbacks(*types)
+      yield.tap do
+        activate_callbacks(*types)
+      end
+    end
+
+    def deactivate_callbacks(*types)
+      types = [:save, :create, :update, :destroy, :touch] if types.empty?
+      types.each do |type|
+        name = :"_run_#{type}_callbacks"
+        alias_method(:"_deactivated_#{name}", name)
+        define_method(name) { |&block| block.call }
+      end
+    end
+
+    def activate_callbacks(*types)
+      types = [:save, :create, :update, :destroy, :touch] if types.empty?
+      types.each do |type|
+        name = :"_run_#{type}_callbacks"
+        alias_method(name, :"_deactivated_#{name}")
+        undef_method(:"_deactivated_#{name}")
+      end
+    end
+  end
+end

data/lib/core_ext/ruby/array/flatten_once.rb

@@ -0,0 +1,9 @@
+class Array
+  def flatten_once
+    inject([]) { |result, elem| elem.is_a?(Array) ? result + elem : result << elem }
+  end
+
+  def flatten_once!
+    replace(flatten_once)
+  end
+end

data/lib/core_ext/ruby/kernel/silence_stream.rb

@@ -0,0 +1,17 @@
+# from lib/core/facets/kernel/silence.rb
+def silence_stream(*streams)
+  on_hold = streams.collect{ |stream| stream.dup }
+  streams.each do |stream|
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+  end
+  yield
+ensure
+  streams.each_with_index do |stream, i|
+    stream.reopen(on_hold[i])
+  end
+end
+
+def silence_stdout
+  silence_stream(STDOUT) { yield }
+end

data/lib/core_ext/ruby/module/include_anonymous.rb

@@ -0,0 +1,36 @@
+# Include an anonymous module
+#
+# Useful for defining a class or module with a base module. So, instead of:
+#
+#   class Foo
+#     module Base
+#       def bar
+#         # ...
+#       end
+#     end
+#     include Base
+#   end
+#
+# You can do:
+#
+#   class Foo
+#     include do
+#       def bar
+#         # ...
+#       end
+#     end
+#   end
+
+Class.class_eval do
+  def include(*args, &block)
+    block_given? ? super(Module.new(&block)) : super(*args)
+  end
+end
+
+Module.class_eval do
+  def include_with_anonymous(*args, &block)
+    block_given? ? include_without_anonymous(Module.new(&block)) : include_without_anonymous(*args)
+  end
+  alias :include_without_anonymous :include
+  alias :include :include_with_anonymous
+end

data/lib/core_ext/ruby/module/option_reader.rb

@@ -0,0 +1,9 @@
+Module.class_eval do
+  def option_reader(*names)
+    options = names.last.is_a?(Hash) ? names.last : {}
+    names.each do |name|
+      define_method(name) { @options[name.to_sym] }
+      define_method(:"#{name}?") { !!@options[name.to_sym] }
+    end
+  end
+end

data/lib/patches/inherited_resources.rb

@@ -0,0 +1,35 @@
+require 'gem_patching'
+require 'inherited_resources'
+
+Gem.patching('inherited_resources', '1.1.2') do
+  InheritedResources::Actions.module_eval do
+    module Actions
+      def index(options={}, &block)
+        respond_with(*(with_chain(resource_class) << options), &block)
+      end
+      alias :index! :index
+    end
+  end
+
+  InheritedResources::BaseHelpers.module_eval do
+    def collection
+      get_collection_ivar || begin
+        collection = end_of_association_chain
+        collection = collection.find(:all) unless collection.respond_to?(:each)
+        set_collection_ivar(collection)
+      end
+    end
+
+    def build_resource
+      get_resource_ivar || begin
+        resource = end_of_association_chain.send(method_for_build, params[resource_instance_name] || {})
+        # check if resource is included to prevent deleting from a relation
+        if method_for_build == :build && end_of_association_chain.include?(resource)
+          end_of_association_chain.delete(resource)
+        end
+        set_resource_ivar(resource)
+      end
+    end
+  end
+end
+

data/lib/patches/rails/asset_expansion_multiple_registrations.rb

@@ -0,0 +1,21 @@
+# Allow to register javascript/stylesheet_expansions to existing symbols
+#
+# see https://rails.lighthouseapp.com/projects/8994/tickets/1975-allow-to-register-javascriptstylesheet_expansions-to-existing-symbols
+
+require 'action_view/helpers/asset_tag_helper'
+
+module ActionView::Helpers::AssetTagHelper
+  def self.register_javascript_expansion(expansions)
+    expansions.each do |key, values|
+      @@javascript_expansions[key] ||= []
+      @@javascript_expansions[key] += Array(values)
+    end
+  end
+
+  def self.register_stylesheet_expansion(expansions)
+    expansions.each do |key, values|
+      @@stylesheet_expansions[key] ||= []
+      @@stylesheet_expansions[key] += Array(values)
+    end
+  end
+end

data/lib/patches/rails/integretion_runner_respond_to.rb

@@ -0,0 +1,13 @@
+require 'gem_patching'
+
+# ActionDispatch::Integration::Runner defines method_missing but no accompaning
+# respond_to? method. It thus doesn't respond_to? to named route url helpers even
+# though it actually responds to them. Happens with the PolymorphicRoutes patch
+# above, so this patch is here as well.
+Gem.patching('rails', '3.0.3') do
+  ActionDispatch::Integration::Runner.module_eval do
+    def respond_to?(method, include_private = false)
+      @integration_session.respond_to?(method, include_private) || super
+    end
+  end
+end

data/lib/patches/rails/polymorphic_url_for.rb

@@ -0,0 +1,115 @@
+# Walks up the inheritance chain for given records if the generated named route
+# helper does not exist. Caches resulting method names.
+# see https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2986-polymorphic_url-should-handle-sti-better
+Gem.patching('rails', '3.0.3') do
+  require 'action_dispatch/routing/polymorphic_routes'
+
+  ActionDispatch::Routing::PolymorphicRoutes.module_eval do
+    def build_named_route_call(objects, inflection, options = {})
+      objects = objects[:id] if objects.is_a?(Hash)
+      NamedRouteCall.method_name(self, Array(objects), inflection, options)
+    end
+
+    class NamedRouteCall < Array
+      mattr_accessor :cache
+      self.cache = {}
+
+      class << self
+        def method_name(view, objects, inflection, options = {})
+          key = cache_key(objects, inflection, options)
+          method = cache[key] ||= begin
+            NamedRouteCall.new(objects, inflection, options).detect do |method|
+              view.respond_to?(method)
+            end
+          end
+        end
+
+        def cache_key(objects, inflection, options)
+          objects = objects + [inflection, options[:action_prefix], options[:routing_type]]
+          objects.compact.map do |object|
+            case object
+            when String, Symbol
+              object
+            when Class
+              object.name
+            else
+              "<#{object.class.name}>"
+            end
+          end
+        end
+      end
+
+      attr_reader :objects, :inflection, :action_prefix, :routing_type
+
+      def initialize(objects, inflection, options = {})
+        @objects       = Array(objects)
+        @inflection    = inflection
+        @action_prefix = options[:action_prefix]
+        @routing_type  = options[:routing_type] || :url
+      end
+
+      def detect
+        while method = build
+          return method if yield(method)
+        end
+        return first
+      end
+
+      def build
+        if combination = combinations.shift
+          self << method_name(combination)
+          self.last
+        end
+      end
+
+      def method_name(combination)
+        combination[-1] = pluralize(combination.last)
+        combination << 'index' if uncountable?(combination.last) && inflection == :plural
+        combination.unshift(action_prefix).push(routing_type).compact.join('_')
+      end
+
+      def pluralize(string)
+        # polymorphic_url passes an incorrect inflection in some cases
+        if [String, Symbol].include?(objects.last.class)
+          string
+        elsif inflection == :singular
+          string.singularize
+        else
+          string.pluralize
+        end
+      end
+
+      def combinations
+        @combinations ||= if classes.size == 1
+          classes.first.map { |klass| [klass] }
+        else
+          classes.inject(classes.shift) { |a, b| a.product(b) }.map(&:flatten)
+        end
+      end
+
+      def classes
+        @classes ||= objects.map do |object|
+          case object
+          when Symbol, String
+            [object.to_s]
+          when Class
+            ancestry(object)
+          else
+            ancestry(object.class)
+          end
+        end
+      end
+
+      def ancestry(model)
+        ancestry = [model]
+        ancestry << ancestry.last.superclass until ancestry.last.superclass == ActiveRecord::Base
+        ancestry.map { |model| ActiveModel::Naming.plural(model).singularize }
+      end
+
+      def uncountable?(string)
+        string.singularize == string.pluralize
+      end
+    end
+  end
+end
+

data/lib/patches/rails/recognize_path_env.rb

@@ -0,0 +1,42 @@
+require 'action_dispatch/routing/mapper'
+require 'action_dispatch/routing/route_set'
+
+# make recognize_path pass the given environment through
+
+module ActionDispatch
+  module Routing
+    class RouteSet
+      def recognize_path(path, environment = {})
+        method = (environment[:method] || "GET").to_s.upcase
+        path = Rack::Mount::Utils.normalize_path(path)
+
+        begin
+          # env = Rack::MockRequest.env_for(path, {:method => method})
+          env = Rack::MockRequest.env_for(path, {:method => method}).merge(environment)
+        rescue URI::InvalidURIError => e
+          raise ActionController::RoutingError, e.message
+        end
+
+        req = Rack::Request.new(env)
+        @set.recognize(req) do |route, matches, params|
+          params.each do |key, value|
+            if value.is_a?(String)
+              value = value.dup.force_encoding(Encoding::BINARY) if value.encoding_aware?
+              params[key] = URI.unescape(value)
+            end
+          end
+
+          dispatcher = route.app
+          dispatcher = dispatcher.app while dispatcher.is_a?(Mapper::Constraints)
+
+          if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
+            dispatcher.prepare_params!(params)
+            return params
+          end
+        end
+
+        raise ActionController::RoutingError, "No route matches #{path.inspect}"
+      end
+    end
+  end
+end

data/lib/patches/rails/route_set_to_param.rb

@@ -0,0 +1,25 @@
+# make route_set generator pass the current segment/param name to to_param
+# if arity allows it. so we can use param names in routes and distinguish them
+# in the model.
+
+require 'action_dispatch/routing/route_set'
+
+ActionDispatch::Routing::RouteSet::Generator.class_eval do
+  def opts
+    parameterize = lambda do |name, value|
+      if name == :controller
+        value
+      elsif value.is_a?(Array)
+        value.map { |v| Rack::Mount::Utils.escape_uri(to_param(name, v)) }.join('/')
+      else
+        return nil unless param = to_param(name, value)
+        param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
+      end
+    end
+    {:parameterize => parameterize}
+  end
+  
+  def to_param(name, value)
+    value.method(:to_param).arity == 1 ? value.to_param(name) : value.to_param
+  end
+end

data/lib/patches/rails/route_set_trailing_segment.rb

@@ -0,0 +1,13 @@
+require 'gem_patching'
+
+# remove trailing segments '.1' and  query params '?=1' from url
+Gem.patching('rails', '3.0.3') do
+  ActionDispatch::Routing::RouteSet.class_eval do
+    def url_for_with_singleton_resource_patch(options)
+      url_for_without_singleton_resource_patch(options).
+        sub(/\.\d+(\Z|\?)/) { $1 || '' }.
+        sub(/\?=\d+$/, '')
+    end
+    alias_method_chain :url_for, :singleton_resource_patch
+  end
+end

data/lib/patches/rails/sti_associations.rb

@@ -0,0 +1,17 @@
+require 'gem_patching'
+
+# Make build associations have their given type
+# i.e.: site.sections.build(:type => 'Page').class == Page
+# http://pragmatig.com/2010/06/04/fixing-rails-nested-attributes-on-collections-with-sti
+
+Gem.patching('rails', '3.0.3') do
+  class ActiveRecord::Reflection::AssociationReflection
+    def build_association(*options)
+      if options.first.is_a?(Hash) && options.first[:type].present?
+        options.first[:type].to_s.constantize.new(*options)
+      else
+        klass.new(*options)
+      end
+    end
+  end
+end