activeadmin 0.4.4 → 0.5.0.pre

data/lib/active_admin/arbre/html/html5_elements.rb

@@ -1,47 +0,0 @@
-module Arbre
-  module HTML
-
-    AUTO_BUILD_ELEMENTS = [ :a, :abbr, :address, :area, :article, :aside, :audio, :b, :base,
-                       :bdo, :blockquote, :body, :br, :button, :canvas, :caption, :cite,
-                       :code, :col, :colgroup, :command, :datalist, :dd, :del, :details,
-                       :dfn, :div, :dl, :dt, :em, :embed, :fieldset, :figcaption, :figure,
-                       :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :hgroup, 
-                       :hr, :html, :i, :iframe, :img, :input, :ins, :keygen, :kbd, :label, 
-                       :legend, :li, :link, :map, :mark, :menu, :meta, :meter, :nav, :noscript, 
-                       :object, :ol, :optgroup, :option, :output, :pre, :progress, :q,
-                       :s, :samp, :script, :section, :select, :small, :source, :span,
-                       :strong, :style, :sub, :summary, :sup, :table, :tbody, :td,
-                       :textarea, :tfoot, :th, :thead, :time, :title, :tr, :ul, :var, :video ]
-
-    HTML5_ELEMENTS = [ :p ] + AUTO_BUILD_ELEMENTS
-
-    AUTO_BUILD_ELEMENTS.each do |name|
-      class_eval <<-EOF
-        class #{name.to_s.capitalize} < Tag
-          builder_method :#{name}
-        end
-      EOF
-    end
-
-    class P < Tag
-      builder_method :para
-    end
-
-    class Table < Tag
-      def initialize(*)
-        super
-        set_table_tag_defaults
-      end
-
-      protected
-
-      # Set some good defaults for tables
-      def set_table_tag_defaults
-        set_attribute :border,      0
-        set_attribute :cellspacing, 0
-        set_attribute :cellpadding, 0
-      end
-    end
-
-  end
-end

data/lib/active_admin/arbre/html/tag.rb

@@ -1,145 +0,0 @@
-require 'erb'
-
-module Arbre
-  module HTML
-
-    class Tag < Element
-      attr_reader :attributes
-
-      def initialize(*)
-        super
-        @attributes = Attributes.new
-      end
-
-      def build(*args)
-        super
-        attributes = args.extract_options!
-        self.content = args.first if args.first
-
-        set_for_attribute(attributes.delete(:for))
-
-        attributes.each do |key, value|
-          set_attribute(key, value)
-        end
-      end
-
-      def set_attribute(name, value)
-        @attributes[name.to_sym] = value
-      end
-
-      def get_attribute(name)
-        @attributes[name.to_sym]
-      end
-      alias :attr :get_attribute
-
-      def has_attribute?(name)
-        @attributes.has_key?(name.to_sym)
-      end
-
-      def remove_attribute(name)
-        @attributes.delete(name.to_sym)
-      end
-
-      def id
-        get_attribute(:id)
-      end
-
-      # Generates and id for the object if it doesn't exist already
-      def id!
-        return id if id
-        self.id = object_id.to_s
-        id
-      end
-
-      def id=(id)
-        set_attribute(:id, id)
-      end
-
-      def add_class(class_names)
-        class_list.add class_names
-      end
-
-      def remove_class(class_names)
-        class_list.delete(class_names)
-      end
-
-      # Returns a string of classes
-      def class_names
-        class_list.to_s
-      end
-
-      def class_list
-        get_attribute(:class) || set_attribute(:class, ClassList.new)
-      end
-
-      def to_s
-        indent(opening_tag, content, closing_tag).html_safe
-      end
-
-      private
-
-      def opening_tag
-        "<#{tag_name}#{attributes_html}>"
-      end
-
-      def closing_tag
-        "</#{tag_name}>"
-      end
-
-      INDENT_SIZE = 2
-      
-      def indent(open_tag, child_content, close_tag)
-        spaces = ' ' * indent_level * INDENT_SIZE
-
-        html = ""
-
-        if no_child? || child_is_text?
-          if self_closing_tag?
-            html << spaces << open_tag.sub( />$/, '/>' )
-          else
-            # one line
-            html << spaces << open_tag << child_content << close_tag
-          end
-        else
-          # multiple lines
-          html << spaces << open_tag << "\n"
-          html << child_content # the child takes care of its own spaces
-          html << spaces << close_tag
-        end
-
-        html << "\n"
-
-        html
-      end
-      
-      def self_closing_tag?
-        %w|meta link|.include?(tag_name)
-      end
-      
-      def no_child?
-        children.empty?
-      end
-
-      def child_is_text?
-        children.size == 1 && children.first.is_a?(TextNode)
-      end
-
-
-      def attributes_html
-        attributes.any? ? " " + attributes.to_s : nil
-      end
-
-      def set_for_attribute(record)
-        return unless record
-        set_attribute :id, ActionController::RecordIdentifier.dom_id(record, default_id_for_prefix)
-        add_class ActionController::RecordIdentifier.dom_class(record)
-      end
-
-      def default_id_for_prefix
-        nil
-      end
-
-    end
-
-  end
-end

data/lib/active_admin/arbre/html/text_node.rb

@@ -1,35 +0,0 @@
-require 'erb'
-
-module Arbre
-  module HTML
-
-    class TextNode < Element
-
-      builder_method :text_node
-
-      # Builds a text node from a string
-      def self.from_string(string)
-        node = new
-        node.build(string)
-        node
-      end
-
-      def add_child(*args)
-        raise "TextNodes do not have children"
-      end
-
-      def build(string)
-        @content = string
-      end
-
-      def tag_name
-        nil
-      end
-
-      def to_s
-        ERB::Util.html_escape(@content.to_s)
-      end
-    end
-
-  end
-end

data/lib/active_admin/filter_form_builder.rb

@@ -1,53 +0,0 @@
-module ActiveAdmin
-  # 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 FilterFormBuilder < FormBuilder
-
-    def filter(method, options = {})
-      return "" if method.nil? || method == ""
-      options[:as] ||= default_input_type(method)
-      return "" unless options[:as]
-      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
-        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)
-      "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
-end

data/lib/active_admin/renderer.rb

@@ -1,87 +0,0 @@
-module ActiveAdmin
-  class Renderer
-
-    include ::ActiveAdmin::ViewHelpers::RendererHelper
-    include Arbre::Builder
-
-    attr_accessor :view, :assigns
-
-    # For use in html
-    alias_method :helpers, :view
-
-    def initialize(view_or_renderer)
-      @view = view_or_renderer.is_a?(Renderer) ? view_or_renderer.view : view_or_renderer
-
-      if view.respond_to?(:assigns)
-        @assigns = view.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
-      else
-        @assigns = {}
-      end
-    end
-
-    def method_missing(name,*args, &block)
-      if view.respond_to?(name)
-        view.send(name, *args, &block)
-      else
-        super
-      end
-    end    
-
-    def to_html(*args)
-    end
-
-    def to_s(*args)
-      to_html(*args)
-    end
-
-    def haml(template)
-      begin
-        require 'haml' unless defined?(Haml)
-      rescue LoadError
-        raise LoadError, "Please install the HAML gem to use the HAML method with ActiveAdmin"
-      end
-
-      # Find the first non whitespace character in the template
-      indent = template.index(/\S/)
-
-      # Remove the indent if its greater than 0
-      if indent > 0
-        template = template.split("\n").collect do |line|
-          line[indent..-1]
-        end.join("\n")
-      end
-
-      # Render it baby
-      Haml::Engine.new(template).render(self)
-    end
-
-    protected
-
-    # Although we make a copy of all the instance variables on the way in, it
-    # doesn't mean that we can set new instance variables that are stored in
-    # the context of the view. This method allows you to do that. It can be useful
-    # when trying to share variables with a layout.
-    def set_ivar_on_view(name, value)
-      view.instance_variable_set(name, value)
-    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 takes care of this functionality.
-    #
-    #   call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
-    # OR
-    #   proc = Proc.new{|s| s.size }
-    #   call_method_or_proc_on(@my_obj, proc)
-    #
-    def call_method_or_proc_on(obj, symbol_or_proc)
-      case symbol_or_proc
-      when Symbol, String
-        obj.send(symbol_or_proc.to_sym)
-      when Proc
-        instance_exec(obj, &symbol_or_proc)
-      end
-    end
-    
-  end
-end

data/lib/active_admin/resource_controller/filters.rb

@@ -1,58 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    module Filters
-      extend ActiveSupport::Concern
-
-      included do
-        helper_method :filters_config
-      end
-
-      module ClassMethods
-        def filter(attribute, options = {})
-          return false if attribute.nil?
-          @filters ||= []
-          @filters << options.merge(:attribute => attribute)
-        end
-
-        def filters_config
-          @filters && @filters.any? ? @filters : default_filters_config
-        end
-
-        def reset_filters!
-          @filters = []
-        end
-
-        # Returns a sane set of filters by default for the object
-        def default_filters_config
-          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
-      end
-
-      protected
-
-      def filters_config
-        self.class.filters_config
-      end
-    end
-
-  end
-end

data/lib/active_admin/view_helpers/filter_form_helper.rb

@@ -1,36 +0,0 @@
-module ActiveAdmin
-
-  module ViewHelpers
-    module FilterFormHelper
-
-      # Helper method to render a filter form
-      def active_admin_filters_form_for(search, filters, options = {})
-        options[:builder] ||= ActiveAdmin::FilterFormBuilder
-        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.each do |filter_options|
-            filter_options = filter_options.dup
-            attribute = filter_options.delete(:attribute)
-            f.filter attribute, filter_options
-          end
-
-          buttons = content_tag :div, :class => "buttons" do
-            f.submit(I18n.t('active_admin.filter')) +
-              clear_link +
-              hidden_field_tag("order", params[:order]) +
-              hidden_field_tag("scope", params[:scope])
-          end
-
-          f.form_buffers.last + buttons
-        end
-      end
-
-    end
-  end
-
-end