lalala 4.0.0.dev.46

data/vendor/deps/active_admin/lib/active_admin/view_helpers/flash_helper.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FlashHelper
+
+      # Returns all the flash keys to display in any Active Admin view.
+      # This method removes the :timedout key that Devise uses by default
+      def active_admin_flash_messages
+        @active_admin_flash_messages ||= flash.to_hash.except(:timedout)
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/form_helper.rb

@@ -0,0 +1,19 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+      
+      def active_admin_form_for(resource, options = {}, &block)
+        options = Marshal.load( Marshal.dump(options) )
+        options[:builder] ||= ActiveAdmin::FormBuilder
+        semantic_form_for resource, options, &block
+      end
+
+      def hidden_field_tags_for(params, options={})
+        fields_for_params(params, options).map do |kv|
+          k, v = kv.first
+          hidden_field_tag k, v, :id => sanitize_to_id("hidden_active_admin_#{k}")
+        end.join("\n").html_safe
+      end
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/icon_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module IconHelper
+      
+      # Render an icon from the Iconic icon set
+      def icon(*args)
+        ActiveAdmin::Iconic.icon(*args)
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/method_or_proc_helper.rb

@@ -0,0 +1,78 @@
+module MethodOrProcHelper
+
+  # This method will either call the symbol on self or instance_exec the Proc
+  # within self. Any args will be passed along to the method dispatch.
+  #
+  # Calling with a Symbol:
+  #
+  #     call_method_or_exec_proc(:to_s) #=> will call #to_s
+  #
+  # Calling with a Proc
+  #
+  #     my_proc = Proc.new{ to_s }
+  #     call_method_or_exec_proc(my_proc) #=> will instance_exec in self
+  #
+  def call_method_or_exec_proc(symbol_or_proc, *args)
+    case symbol_or_proc
+    when Symbol, String
+      send(symbol_or_proc, *args)
+    when Proc
+      instance_exec(*args, &symbol_or_proc)
+    end
+  end
+
+  # Many times throughout the views we want to either call a method on an object
+  # or instance_exec a proc passing in the object as the first parameter. This
+  # method wraps that pattern.
+  #
+  # Calling with a Symbol:
+  #
+  #     call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
+  #
+  # Calling with a Proc:
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     call_method_or_proc_on(@my_obj, proc)
+  #
+  # By default, the Proc will be instance_exec'd within self. If you would rather
+  # not instance exec, but just call the Proc, then pass along `:exec => false` in
+  # the options hash.
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     call_method_or_proc_on(@my_obj, proc, :exec => false)
+  #
+  # You can pass along any necessary arguments to the method / Proc as arguments. For 
+  # example:
+  #
+  #     call_method_or_proc_on(@my_obj, :find, 1) #=> @my_obj.find(1)
+  #
+  def call_method_or_proc_on(receiver, *args)
+    options = { :exec => true }.merge(args.extract_options!)
+
+    symbol_or_proc = args.shift
+
+    case symbol_or_proc
+    when Symbol, String
+      receiver.send(symbol_or_proc.to_sym, *args)
+    when Proc
+      if options[:exec]
+        instance_exec(receiver, *args, &symbol_or_proc)
+      else
+        symbol_or_proc.call(receiver, *args)
+      end
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This helper takes care of
+  # returning the content when String or call call_method_or_proc_on when Symbol or Proc.
+  #
+  def render_or_call_method_or_proc_on(obj, string_symbol_or_proc, options = {})
+    case string_symbol_or_proc
+    when Symbol, Proc
+      call_method_or_proc_on(obj, string_symbol_or_proc, options)
+    when String
+      string_symbol_or_proc
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/sidebar_helper.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module ViewHelpers
+    module SidebarHelper
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/title_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module TitleHelper
+
+      def title(_title)
+        @page_title = _title 
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/view_helpers/view_factory_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ViewFactoryHelper
+
+      def view_factory
+        active_admin_namespace.view_factory
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module ViewHelpers
+
+    # Require all ruby files in the view helpers dir
+    Dir[File.expand_path('../view_helpers', __FILE__) + "/*.rb"].each{|f| require f }
+
+    include AssignsWithIndifferentAccessHelper
+    include ActiveAdminApplicationHelper
+    include AutoLinkHelper
+    include BreadcrumbHelper
+    include DisplayHelper
+    include IconHelper
+    include MethodOrProcHelper
+    include SidebarHelper
+    include FormHelper
+    include TitleHelper
+    include ViewFactoryHelper
+    include FlashHelper
+
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/action_items.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+
+    class ActionItems < ActiveAdmin::Component
+
+      def build(action_items)
+        action_items.each do |action_item|
+          span :class => "action_item" do
+            instance_eval(&action_item.block)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/action_list_popover.rb

@@ -0,0 +1,29 @@
+require 'active_admin/views/components/popover'
+
+module ActiveAdmin
+  module Views
+    # Build an ActionListPopover
+    class ActionListPopover < ActiveAdmin::Views::Popover
+      builder_method :action_list_popover
+      
+      
+      def build(*args, &block)
+        @contents = ul :class => "popover_contents"
+        
+        options = args.extract_options!
+        
+        super(options)
+      end
+      
+      def action(title, url, *args)
+        options = args.extract_options!
+        within @contents do
+          li do
+            text_node link_to( title, url, options )
+          end
+        end
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/attributes_table.rb

@@ -0,0 +1,73 @@
+module ActiveAdmin
+  module Views
+
+    class AttributesTable < ActiveAdmin::Component
+      builder_method :attributes_table_for
+
+      attr_reader :resource
+
+      def build(record, *attrs)
+        @record = record
+        super(:for => @record)
+        @table = table
+        rows(*attrs)
+      end
+
+      def rows(*attrs)
+        attrs.each {|attr| row(attr) }
+      end
+
+      def row(*args, &block)
+        title   = args[0]
+        options = args.extract_options!
+        options[:class] ||= :row
+        @table << tr(options) do
+          th do
+            header_content_for(title)
+          end
+          td do
+            content_for(block || title)
+          end
+        end
+      end
+
+      protected
+
+      def default_id_for_prefix
+        'attributes_table'
+      end
+
+      def header_content_for(attr)
+        if @record.class.respond_to?(:human_attribute_name)
+          @record.class.human_attribute_name(attr, :default => attr.to_s.titleize)
+        else
+          attr.to_s.titleize
+        end
+      end
+
+      def empty_value
+        span I18n.t('active_admin.empty'), :class => "empty"
+      end
+
+      def content_for(attr_or_proc)
+        value = case attr_or_proc
+                when Proc
+                  attr_or_proc.call(@record)
+                else
+                  content_for_attribute(attr_or_proc)
+                end
+        value = pretty_format(value)
+        value == "" || value.nil? ? empty_value : value
+      end
+
+      def content_for_attribute(attr)
+        if attr.to_s =~ /^([\w]+)_id$/ && @record.respond_to?($1.to_sym)
+          content_for_attribute($1)
+        else
+          @record.send(attr.to_sym)
+        end
+      end
+    end
+
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/blank_slate.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+    # Build a Blank Slate
+    class BlankSlate < ActiveAdmin::Component
+      builder_method :blank_slate
+      
+      def default_class_name
+        'blank_slate_container'
+      end
+      
+      def build(content)
+        super(span(content.html_safe, :class => "blank_slate"))
+      end
+      
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/columns.rb

@@ -0,0 +1,150 @@
+module ActiveAdmin
+  module Views
+
+    # = Columns Component
+    #
+    # The Columns component allows you draw content into scalable columns. All
+    # you need to do is define the number of columns and the component will
+    # take care of the rest.
+    #
+    # == Simple Columns
+    #
+    # To display columns, use the #columns method. Within the block, call the 
+    # #column method to create a new column.
+    #
+    # To createa a two column layout:
+    #
+    #     colums do
+    #       column do
+    #         span "Column # 1
+    #       end
+    #       column do
+    #         span "Column # 2
+    #       end
+    #     end
+    #
+    #
+    # == Multiple Span Columns
+    #
+    # To make a column span multiple, pass the :span option to the column method:
+    #
+    #     colums do
+    #       column :span => 2 do
+    #         span "Column # 1
+    #       end
+    #       column do
+    #         span "Column # 2
+    #       end
+    #     end
+    #
+    # By default, each column spans 1 column. So the above layout would have 2 columns,
+    # the first being 2 time bigger than the second.
+    #
+    #
+    # == Max and Mix Column Sizes
+    #
+    # Active Admin is a fluid width layout, which means that columns are all defined
+    # using percentages. Sometimes this can cause issues if you don't want a column
+    # to shrink or expand past a certain point.
+    #
+    # To overcome this, columns include a :max_width and :min_width option.
+    #
+    #     colums do
+    #       column :max_width => "200px", :min_width => "100px" do
+    #         span "Column # 1
+    #       end
+    #       column do
+    #         span "Column # 2
+    #       end
+    #     end
+    #
+    # Now the first column will not grow bigger than 200px and will not shrink smaller
+    # than 100px.
+    class Columns < ActiveAdmin::Component
+      builder_method :columns
+
+
+      # For documentation, please take a look at Column#build
+      def column(*args, &block)
+        insert_tag Column, *args, &block
+      end
+
+      # Override add child to set widths
+      def add_child(*)
+        super
+        calculate_columns!
+      end
+
+      protected
+
+      # Override the closing tag to include a clear
+      def closing_tag
+        "<div style=\"clear:both;\"></div>" + super
+      end
+
+      def margin_size
+        2
+      end
+
+      # Calculate our columns sizes and margins
+      def calculate_columns!
+        span_count = columns_span_count
+        columns_count = children.size
+
+        all_margins_width = margin_size * (span_count - 1)
+        column_width = (100.00 - all_margins_width) / span_count
+
+        children.each_with_index do |col, i|
+          is_last_column = i == (columns_count - 1)
+          col.set_column_styles(column_width, margin_size, is_last_column)
+        end
+      end
+
+      def columns_span_count
+        count = 0
+        children.each {|column| count += column.span_size }
+
+        count
+      end
+
+    end
+
+    class Column < ActiveAdmin::Component
+
+      attr_accessor :span_size, :max_width, :min_width
+
+      # @param [Hash] options An options hash for the column
+      #
+      # @options options [Integer] :span The columns this column should span
+      def build(options = {})
+        options = options.dup
+        @span_size = options.delete(:span) || 1
+        @max_width = options.delete(:max_width)
+        @min_width = options.delete(:min_width)
+
+        super(options)
+      end
+
+      def set_column_styles(column_width, margin_width, is_last_column = false)
+        column_with_span_width = (span_size * column_width) + ((span_size - 1) * margin_width)
+
+        styles = []
+
+        styles << "width: #{column_with_span_width}%;"
+
+        if max_width
+          styles << "max-width: #{max_width};"
+        end
+
+        if min_width
+          styles << "min-width: #{min_width};"
+        end
+
+        styles << "margin-right: #{margin_width}%;" unless is_last_column
+
+        set_attribute :style, styles.join(" ")
+      end
+
+    end
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/dropdown_menu.rb

@@ -0,0 +1,73 @@
+require 'active_admin/views/components/popover'
+
+module ActiveAdmin
+  module Views
+
+    # Action List - A button with a drop down menu of links
+    #
+    # Creating a new action list:
+    #
+    #     dropdown_menu "Administration" do
+    #       item "Edit Details", edit_details_path
+    #       item "Edit My Account", edit_my_acccount_path
+    #     end
+    #
+    # This will create a button with the label "Administration" and
+    # a drop down once clicked with 2 options.
+    #
+    class DropdownMenu < ActiveAdmin::Component
+      builder_method :dropdown_menu
+
+      # Build a new action list
+      #
+      # @param [String] name  The name to display in the button
+      #
+      # @param [Hash] options A set of options that get passed along to
+      #                       to the parent dom element.
+      def build(name, options = {})
+        options = options.dup
+
+        # Easily set options for the button or menu
+        button_options  = options.delete(:button) || {}
+        menu_options = options.delete(:menu) || {}
+
+        @button  = build_button(name, button_options)
+        @menu = build_menu(menu_options)
+
+        super(options)
+      end
+
+      def item(*args)
+        within @menu do
+          li link_to(*args)
+        end
+      end
+
+      private
+
+      def build_button(name, button_options)
+        button_options[:class] ||= ""
+        button_options[:class] << " dropdown_menu_button"
+
+        button_options[:href] = "#"
+
+        a name, button_options
+      end
+
+      def build_menu(options)
+        options[:class] ||= ""
+        options[:class] << " dropdown_menu_list"
+
+        menu_list = nil
+
+        div :class => "dropdown_menu_list_wrapper", :style => "display:none;" do
+          menu_list = ul(options)
+        end
+
+        menu_list
+      end
+
+    end
+
+  end
+end

data/vendor/deps/active_admin/lib/active_admin/views/components/paginated_collection.rb

@@ -0,0 +1,115 @@
+require 'active_admin/helpers/collection'
+
+module ActiveAdmin
+  module Views
+
+    # Wraps the content with pagination and available formats.
+    #
+    # *Example:*
+    #
+    #   paginated_collection collection, :entry_name => "Post" do
+    #     div do
+    #       h2 "Inside the
+    #     end
+    #   end
+    #
+    # This will create a div with a sentence describing the number of
+    # posts in one of the following formats:
+    #
+    # * "No Posts found"
+    # * "Displaying all 10 Posts"
+    # * "Displaying Posts 1 - 30 of 31 in total"
+    #
+    # It will also generate pagination links.
+    #
+    class PaginatedCollection < ActiveAdmin::Component
+      builder_method :paginated_collection
+
+      attr_reader :collection
+
+      # Builds a new paginated collection component
+      #
+      # collection => A paginated collection from kaminari
+      # options    => These options will be passed to `page_entries_info`
+      #   entry_name     => The name to display for this resource collection
+      #   param_name     => Parameter name for page number in the links (:page by default)
+      #   download_links => Download links override (false or [:csv, :pdf])
+      #
+      def build(collection, options = {})
+        @collection = collection
+        @param_name     = options.delete(:param_name)
+        @download_links = options.delete(:download_links)
+
+        unless collection.respond_to?(:num_pages)
+          raise(StandardError, "Collection is not a paginated scope. Set collection.page(params[:page]).per(10) before calling :paginated_collection.")
+        end
+        
+        @contents = div(:class => "paginated_collection_contents")
+        build_pagination_with_formats(options)
+        @built = true
+      end
+
+      # Override add_child to insert all children into the @contents div
+      def add_child(*args, &block)
+        if @built
+          @contents.add_child(*args, &block)
+        else
+          super
+        end
+      end
+
+      protected
+
+      def build_pagination_with_formats(options)
+        div :id => "index_footer" do
+          build_pagination
+          div(page_entries_info(options).html_safe, :class => "pagination_information")
+
+          if @download_links.is_a?(Array) && !@download_links.empty?
+            build_download_format_links @download_links
+          else
+            build_download_format_links unless @download_links == false
+          end
+
+        end
+      end
+
+      def build_pagination
+        options =  request.query_parameters.except(:commit, :format)
+        options[:param_name] = @param_name if @param_name
+
+        text_node paginate(collection, options.symbolize_keys)
+      end
+
+      include ::ActiveAdmin::Helpers::Collection
+      include ::ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
+        
+      # modified from will_paginate
+      def page_entries_info(options = {})
+        if options[:entry_name]
+          entry_name = options[:entry_name]
+          entries_name = options[:entries_name] || entry_name.pluralize
+        elsif collection_is_empty?
+          entry_name = I18n.translate("active_admin.pagination.entry", :count => 1, :default => 'entry')
+          entries_name = I18n.translate("active_admin.pagination.entry", :count => 2, :default => 'entries')
+        else
+          entry_name = I18n.translate("activerecord.models.#{collection.first.class.model_name.i18n_key}", :count => 1, :default => collection.first.class.name.underscore.sub('_', ' '))
+          entries_name = I18n.translate("activerecord.models.#{collection.first.class.model_name.i18n_key}", :count => collection.size, :default => entry_name.pluralize)
+        end
+
+        if collection.num_pages < 2
+          case collection_size
+          when 0; I18n.t('active_admin.pagination.empty', :model => entries_name)
+          when 1; I18n.t('active_admin.pagination.one', :model => entry_name)
+          else;   I18n.t('active_admin.pagination.one_page', :model => entries_name, :n => collection.total_count)
+          end
+        else
+          offset = (collection.current_page - 1) * collection.limit_value
+          total = collection.total_count
+          I18n.t('active_admin.pagination.multiple', :model => entries_name, :from => offset + 1, :to => offset + collection_size, :total => total)
+        end
+      end
+
+    end
+  end
+end