lalala 4.0.0.dev.141 → 4.0.0.dev.144

data/vendor/deps/active_admin/lib/active_admin/dsl.rb

@@ -1,166 +0,0 @@
-module ActiveAdmin
-
-  #
-  # The Active Admin DSL. This class is where all the registration blocks
-  # are instance eval'd. This is the central place for the API given to 
-  # users of Active Admin
-  #
-  class DSL
-
-    def initialize(config)
-      @config = config
-    end
-
-    # Runs the registration block inside this object
-    def run_registration_block(&block)
-      instance_eval &block if block_given?
-    end
-
-    # The instance of ActiveAdmin::Config that's being registered
-    # currently. You can use this within your registration blocks to
-    # modify options:
-    #
-    # eg:
-    # 
-    #   ActiveAdmin.register Post do
-    #     config.sort_order = "id_desc"
-    #   end
-    #
-    def config
-      @config
-    end
-
-    # Include a module with this resource. The modules's `included` method
-    # is called with the instance of the `ActiveAdmin::DSL` passed into it.
-    #
-    # eg:
-    #
-    #   module HelpSidebar
-    #
-    #     def self.included(dsl)
-    #       dsl.sidebar "Help" do
-    #         "Call us for Help"
-    #       end
-    #     end
-    #
-    #   end
-    #
-    #   ActiveAdmin.register Post do
-    #     include HelpSidebar
-    #   end
-    #
-    # @param [Module] mod A module to include
-    #
-    # @returns [Nil]
-    def include(mod)
-      mod.included(self)
-    end
-
-    # Returns the controller for this resource. If you pass a
-    # block, it will be eval'd in the controller
-    #
-    # Example:
-    #
-    #   ActiveAdmin.register Post do
-    #
-    #     controller do
-    #       def some_method_on_controller
-    #         # Method gets added to Admin::PostsController
-    #       end
-    #     end
-    #
-    #   end
-    #
-    def controller(&block)
-      @config.controller.class_eval(&block) if block_given?
-      @config.controller
-    end
-
-    # Add a new action item to the resource
-    #
-    # @param [Hash] options valid keys include:
-    #                 :only:  A single or array of controller actions to display
-    #                         this action item on.
-    #                 :except: A single or array of controller actions not to
-    #                          display this action item on.
-    def action_item(options = {}, &block)
-      config.add_action_item(options, &block)
-    end
-
-    # Add a new batch action item to the resource
-    # Provide a symbol/string to register the action, options, & block to execute on request
-    # 
-    # To unregister an existing action, just provide the symbol & pass false as the second param
-    #
-    # @param [Symbol or String] title
-    # @param [Hash] options valid keys include:
-    # => :if is a proc that will be called to determine if the BatchAction should be displayed
-    # => :sort_order is used to sort the batch actions ascending
-    # => :confirm is a string which the user will have to accept in order to process the action
-    #
-    def batch_action(title, options = {}, &block)
-      # Create symbol & title information
-      if title.is_a?( String )
-        sym = title.titleize.gsub(' ', '').underscore.to_sym
-      else
-        sym = title
-        title = sym.to_s.titleize
-      end
-      
-      # Either add/remove the batch action
-      unless options == false
-        config.add_batch_action( sym, title, options, &block )
-      else
-        config.remove_batch_action sym
-      end
-    end
-
-    # Set the options that are available for the item that will be placed in the global
-    # navigation of the menu.
-    def menu(options = {})
-      config.menu_item_options = options
-    end
-
-    # Set the name of the navigation menu to display. This is mainly used in conjuction with the
-    # `#belongs_to` functionality.
-    #
-    # @param [Symbol] menu_name The name of the menu to display as the global navigation
-    #                 when viewing this resource. Defaults to a menu named `:default`.
-    #
-    # Pass a block returning the name of a menu you want rendered for the request, being
-    # executed in the context of the controller
-    #
-    def navigation_menu(menu_name=nil, &block)
-      config.navigation_menu_name = menu_name || block
-    end
-
-    # Rewrite breadcrumb links.
-    # Block will be executed inside controller.
-    # Block must return an array if you want to rewrite breadcrumb links.
-    #
-    # Example:
-    #   ActiveAdmin.register Post do
-    #
-    #     breadcrumb do
-    #       [
-    #         link_to('my piece', '/my/link/to/piece')
-    #       ]
-    #     end
-    #   end
-    #
-    def breadcrumb(&block)
-      config.breadcrumb = block
-    end
-
-    def sidebar(name, options = {}, &block)
-      config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
-    end
-
-    def decorate_with(decorator_class)
-      # Force storage as a string. This will help us with reloading issues.
-      # Assuming decorator_class.to_s will return the name of the class allows
-      # us to handle a string or a class.
-      config.decorator_class_name = "::#{ decorator_class }"
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/engine.rb

@@ -1,9 +0,0 @@
-module ActiveAdmin
-  class Engine < Rails::Engine
-    if Rails.version > "3.1"
-      initializer "ActiveAdmin precompile hook", :group => :all do |app|
-        app.config.assets.precompile += %w(active_admin.js active_admin.css active_admin/print.css)
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/event.rb

@@ -1,33 +0,0 @@
-module ActiveAdmin
-
-  class EventDispatcher
-    def initialize
-      @events = {}
-    end
-
-    def clear_all_subscribers!
-      @events = {}
-    end
-
-    def subscribe(*event_names, &block)
-      event_names.each do |event|
-        @events[event] ||= []
-        @events[event] << block
-      end
-    end
-
-    def subscribers(event)
-      @events[event] || []
-    end
-
-    def dispatch(event, *args)
-      subscribers(event).each do |subscriber|
-        subscriber.call(*args)
-      end
-    end
-  end
-
-  # ActiveAdmin::Event is set to a dispatcher
-  Event = EventDispatcher.new
-
-end

data/vendor/deps/active_admin/lib/active_admin/filters/dsl.rb

@@ -1,21 +0,0 @@
-module ActiveAdmin
-  module Filters
-    module DSL
-
-      # For docs, please see ActiveAdmin::Filters::ResourceExtension#add_filter
-      def filter(attribute, options = {})
-        config.add_filter(attribute, options)
-      end
-
-      # For docs, please see ActiveAdmin::Filters::ResourceExtension#delete_filter
-      def remove_filter(attribute)
-        config.remove_filter(attribute)
-      end
-
-      # For docs, please see ActiveAdmin::Filters::ResourceExtension#preserve_default_filters!
-      def preserve_default_filters!
-        config.preserve_default_filters!
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/filters/forms.rb

@@ -1,97 +0,0 @@
-module ActiveAdmin
-  module Filters
-
-    # This form builder defines methods to build filter forms such
-    # as the one found in the sidebar of the index page of a standard resource.
-    class FormBuilder < ::ActiveAdmin::FormBuilder
-
-      def filter(method, options = {})
-        return "" if method.blank? ||
-                     (options[:as] ||= default_input_type(method)).nil?
-        content = input(method, options)
-        form_buffers.last << content.html_safe if content
-      end
-
-      protected
-
-      # Returns the default filter type for a given attribute
-      def default_input_type(method, options = {})
-        if (column = column_for(method))
-          case column.type
-          when :date, :datetime
-            return :date_range
-          when :string, :text
-            return :string
-          when :integer
-            return :select if reflection_for(method.to_s.gsub('_id','').to_sym)
-            return :numeric
-          when :float, :decimal
-            return :numeric
-          when :boolean
-            return :boolean
-          end
-        end
-
-        if (reflection = reflection_for(method))
-          return :select if reflection.macro == :belongs_to && !reflection.options[:polymorphic]
-        end
-      end
-
-      def custom_input_class_name(as)
-        "Filter#{as.to_s.camelize}Input"
-      end
-
-      def active_admin_input_class_name(as)
-        "ActiveAdmin::Inputs::Filter#{as.to_s.camelize}Input"
-      end
-
-      # Returns the column for an attribute on the object being searched
-      # if it exists. Otherwise returns nil
-      def column_for(method)
-        @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
-      end
-
-      # Returns the association reflection for the method if it exists
-      def reflection_for(method)
-        @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
-      end
-
-    end
-
-
-    # This module is included into the view
-    module ViewHelper
-
-      # Helper method to render a filter form
-      def active_admin_filters_form_for(search, filters, options = {})
-        options[:builder] ||= ActiveAdmin::Filters::FormBuilder
-        options[:url] ||= collection_path
-        options[:html] ||= {}
-        options[:html][:method] = :get
-        options[:html][:class] ||= "filter_form"
-        options[:as] = :q
-        clear_link = link_to(I18n.t('active_admin.clear_filters'), "#", :class => "clear_filters_btn")
-        form_for search, options do |f|
-          filters.group_by{ |o| o[:attribute] }.each do |attribute, array|
-            options      = array.last # grab last-defined `filter` call from DSL
-            if_block     = options[:if]     || proc{ true }
-            unless_block = options[:unless] || proc{ false }
-            if call_method_or_proc_on(self, if_block) && !call_method_or_proc_on(self, unless_block)
-              f.filter options[:attribute], options.except(:attribute, :if, :unless)
-            end
-          end
-
-          buttons = content_tag :div, :class => "buttons" do
-            f.submit(I18n.t('active_admin.filter')) +
-              clear_link +
-              hidden_field_tags_for(params, :except => [:q, :page])
-          end
-
-          f.form_buffers.last + buttons
-        end
-      end
-
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/filters/resource_extension.rb

@@ -1,122 +0,0 @@
-module ActiveAdmin
-  module Filters
-
-    module ResourceExtension
-
-      def initialize(*)
-        super
-        add_filters_sidebar_section
-      end
-
-      # Returns the filters for this resource. If filters are not enabled,
-      # it will always return an empty array.
-      #
-      # @return [Array] Filters that apply for this resource
-      def filters
-        return [] unless filters_enabled?
-
-        if @filters.present?
-          if preserve_default_filters?
-            @filters + default_filters
-          else
-            @filters
-          end
-        else
-          default_filters
-        end
-      end
-
-      # Setter to enable / disable filters on this resource.
-      #
-      # Set to `nil` to inherit the setting from the namespace
-      def filters=(bool)
-        @filters_enabled = bool
-      end
-
-      # @return [Boolean] If filters are enabled for this resource
-      def filters_enabled?
-        @filters_enabled.nil? ? namespace.filters : @filters_enabled
-      end
-
-      def preserve_default_filters!
-        @preserve_default_filters = true
-      end
-
-      def preserve_default_filters?
-        @preserve_default_filters == true
-      end
-
-      # Remove a filter for this resource. If filters are not enabled, this method
-      # will raise a RuntimeError
-      #
-      # @param [Symbol] attribute The attribute to not filter on
-      def remove_filter(attribute)
-        unless filters_enabled?
-          raise RuntimeError, "Can't remove a filter when filters are disabled. Enable filters with 'config.filters = true'"
-        end
-
-        @filters ||= default_filters
-
-        @filters.delete_if { |f| f.fetch(:attribute) == attribute }
-      end
-
-      # Add a filter for this resource. If filters are not enabled, this method
-      # will raise a RuntimeError
-      #
-      # @param [Symbol] attribute The attribute to filter on
-      # @param [Hash] options The set of options that are passed through to
-      #                       metasearch for the field definition.
-      def add_filter(attribute, options = {})
-        unless filters_enabled?
-          raise RuntimeError, "Can't add a filter when filters are disabled. Enable filters with 'config.filters = true'"
-        end
-
-        @filters ||= []
-
-        @filters << options.merge({ :attribute => attribute })
-      end
-
-      # Reset the filters to use defaults
-      def reset_filters!
-        @filters = nil
-      end
-
-      private
-
-      # @return [Array] The array of default for filters for this resource
-      def default_filters
-        default_association_filters + default_content_filters
-      end
-
-      # Returns a default set of filters for the associations
-      def default_association_filters
-        if resource_class.respond_to?(:reflections)
-          resource_class.reflections.collect{|name, r| { :attribute => name }}
-        else
-          []
-        end
-      end
-
-      # Returns a default set of filters for the content columns
-      def default_content_filters
-        if resource_class.respond_to?(:content_columns)
-          resource_class.content_columns.collect{|c| { :attribute => c.name.to_sym } }
-        else
-          []
-        end
-      end
-
-      def add_filters_sidebar_section
-        self.sidebar_sections << filters_sidebar_section
-      end
-
-      def filters_sidebar_section
-        ActiveAdmin::SidebarSection.new(:filters, :only => :index, :if => proc{ active_admin_config.filters.any? } ) do
-          active_admin_filters_form_for assigns[:search], active_admin_config.filters
-        end
-      end
-
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/filters.rb

@@ -1,8 +0,0 @@
-require 'active_admin/filters/dsl'
-require "active_admin/filters/resource_extension"
-require 'active_admin/filters/forms'
-
-# Add our Extensions
-ActiveAdmin::ResourceDSL.send :include, ActiveAdmin::Filters::DSL
-ActiveAdmin::Resource.send    :include, ActiveAdmin::Filters::ResourceExtension
-ActiveAdmin::ViewHelpers.send :include, ActiveAdmin::Filters::ViewHelper

data/vendor/deps/active_admin/lib/active_admin/form_builder.rb

@@ -1,196 +0,0 @@
-module ActiveAdmin
-  class FormBuilder < ::Formtastic::FormBuilder
-
-    attr_reader :form_buffers
-
-    def initialize(*args)
-      @form_buffers = ["".html_safe]
-      super
-    end
-
-    def inputs(*args, &block)
-      @inputs_with_block = block_given?
-      form_buffers.last << with_new_form_buffer{ super }
-    end
-
-    # If this `input` call is inside a `inputs` block, add the content
-    # to the form buffer. Else, return it directly.
-    def input(method, *args)
-      content = with_new_form_buffer{ super }
-      @inputs_with_block ? form_buffers.last << content : content
-    end
-
-    def cancel_link(url = {:action => "index"}, html_options = {}, li_attrs = {})
-      li_attrs[:class] ||= "cancel"
-      li_content = template.link_to I18n.t('active_admin.cancel'), url, html_options
-      form_buffers.last << template.content_tag(:li, li_content, li_attrs)
-    end
-
-    def actions(*args, &block)
-      form_buffers.last << with_new_form_buffer do
-        block_given? ? super : super{ commit_action_with_cancel_link }
-      end
-    end
-
-    def action(*args)
-      form_buffers.last << with_new_form_buffer{ super }
-    end
-
-    def commit_action_with_cancel_link
-      action(:submit)
-      cancel_link
-    end
-
-    def has_many(association, options = {}, &block)
-      options = { :for => association }.merge(options)
-      options[:class] ||= ""
-      options[:class] << "inputs has_many_fields"
-
-      # Add Delete Links
-      form_block = proc do |has_many_form|
-        # @see https://github.com/justinfrench/formtastic/blob/2.2.1/lib/formtastic/helpers/inputs_helper.rb#L373
-        contents = if block.arity == 1  # for backwards compatibility with REE & Ruby 1.8.x
-          block.call(has_many_form)
-        else
-          index = parent_child_index(options[:parent]) if options[:parent]
-          block.call(has_many_form, index)
-        end
-
-        if has_many_form.object.new_record?
-          contents += template.content_tag(:li) do
-            template.link_to I18n.t('active_admin.has_many_delete'), "#", :onclick => "$(this).closest('.has_many_fields').remove(); return false;", :class => "button"
-          end
-        end
-
-        contents
-      end
-
-      content = with_new_form_buffer do
-        template.content_tag :div, :class => "has_many #{association}" do
-          form_buffers.last << template.content_tag(:h3, object.class.reflect_on_association(association).klass.model_name.human(:count => 1.1))
-          inputs options, &form_block
-
-          form_buffers.last << js_for_has_many(association, form_block, template)
-        end
-      end
-      form_buffers.last << content
-    end
-
-    # BTW: the fact that this *could* return nil might currently be causing problems
-    def semantic_errors(*args)
-      content = with_new_form_buffer{ super }
-      form_buffers.last << content if content
-    end
-
-    # These methods are deprecated and removed from Formtastic, however are
-    # supported here to help with transition.
-    module DeprecatedMethods
-
-      # Formtastic has depreciated #commit_button in favor of #action(:submit)
-      def commit_button(*args)
-        ::ActiveSupport::Deprecation.warn("f.commit_button is deprecated in favour of f.action(:submit)")
-
-        options = args.extract_options!
-        if String === args.first
-          options[:label] = args.first unless options.has_key?(:label)
-        end
-
-        action(:submit, options)
-      end
-
-      def commit_button_with_cancel_link
-        # Formtastic has depreciated #buttons in favor of #actions
-        ::ActiveSupport::Deprecation.warn("f.commit_button_with_cancel_link is deprecated in favour of f.commit_action_with_cancel_link")
-
-        commit_action_with_cancel_link
-      end
-
-      # The buttons method always needs to be wrapped in a new buffer
-      def buttons(*args, &block)
-        # Formtastic has depreciated #buttons in favor of #actions
-        ::ActiveSupport::Deprecation.warn("f.buttons is deprecated in favour of f.actions")
-
-        actions args, &block
-      end
-
-    end
-    include DeprecatedMethods
-
-    protected
-
-    def active_admin_input_class_name(as)
-      "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
-    end
-
-    # prevent exceptions in production environment for better performance
-    def input_class_with_const_defined(as)
-      input_class_name = custom_input_class_name(as)
-
-      if ::Object.const_defined?(input_class_name)
-        input_class_name.constantize
-      elsif ActiveAdmin::Inputs.const_defined?(input_class_name)
-        active_admin_input_class_name(as).constantize
-      elsif Formtastic::Inputs.const_defined?(input_class_name)
-        standard_input_class_name(as).constantize
-      else
-        raise Formtastic::UnknownInputError
-      end
-    end
-
-    # use auto-loading in development environment
-    def input_class_by_trying(as)
-      begin
-        begin
-          custom_input_class_name(as).constantize
-        rescue NameError
-          begin
-            active_admin_input_class_name(as).constantize
-          rescue NameError
-            standard_input_class_name(as).constantize
-          end
-        end
-      end
-    rescue NameError
-      raise Formtastic::UnknownInputError
-    end
-
-    # This method calls the block it's passed (in our case, the `f.inputs` block)
-    # and wraps the resulting HTML in a fieldset. If your block happens to return
-    # nil (but it otherwise built the form correctly), the below override passes
-    # the most recent part of the Active Admin form buffer.
-    def field_set_and_list_wrapping(*args, &block)
-      block_given? ? super{ yield || form_buffers.last } : super
-    end
-
-    private
-
-    def with_new_form_buffer
-      form_buffers << "".html_safe
-      return_value = yield.html_safe
-      form_buffers.pop
-      return_value
-    end
-
-    # Capture the ADD JS
-    def js_for_has_many(association, form_block, template)
-      association_reflection = object.class.reflect_on_association(association)
-      association_human_name = association_reflection.klass.model_name.human
-      placeholder = "NEW_#{association_human_name.upcase.split(' ').join('_')}_RECORD"
-
-      js = with_new_form_buffer do
-        inputs_for_nested_attributes :for => [association, association_reflection.klass.new],
-                                     :class => "inputs has_many_fields",
-                                     :for_options => { :child_index => placeholder },
-                                     &form_block
-      end
-
-      js = template.escape_javascript(js)
-
-      text = I18n.t 'active_admin.has_many_new', :model => association_human_name
-      onclick = "$(this).before('#{js}'.replace(/#{placeholder}/g, new Date().getTime())); return false;"
-
-      template.link_to(text, "#", :onclick => onclick, :class => "button").html_safe
-    end
-
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/helpers/collection.rb

@@ -1,23 +0,0 @@
-module ActiveAdmin
-  module Helpers
-    module Collection
-      # Works around this issue: https://github.com/rails/rails/issues/7121
-      #
-      # GROUP BY + COUNT drops SELECT statement. This leads to SQL error when
-      # the ORDER statement mentions a column defined in the SELECT statement.
-      #
-      # We remove the ORDER statement to work around this issue.
-      def collection_size(collection=collection)
-        size = collection.reorder("").count
-        # when GROUP BY is used, AR returns Hash instead of Fixnum for .size
-        size = size.size if size.kind_of?(Hash)
-
-        size
-      end
-
-      def collection_is_empty?(collection=collection)
-        collection_size(collection) == 0
-      end
-    end
-  end
-end