yousty-activeadmin 1.0.0.pre

data/lib/active_admin/resource_dsl.rb

@@ -0,0 +1,134 @@
+module ActiveAdmin
+  # This is the class where all the register blocks are instance eval'd
+  class ResourceDSL < DSL
+    private
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    # Scope collection to a relation
+    def scope_to(*args, &block)
+      config.scope_to(*args, &block)
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      options[:as] ||= :table
+      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    def form(options = {}, &block)
+      config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    #   csv :col_sep => ";", :force_quotes => true do
+    #     column :name
+    #   end
+    #
+    def csv(options={}, &block)
+      config.csv_builder = CSVBuilder.new(options, &block)
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id]
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # You can treat everything within the block as a standard Rails controller
+    # action.
+    #
+    def action(set, name, options = {}, &block)
+      set << ControllerAction.new(name, options)
+      title = options.delete(:title)
+
+      controller do
+        before_filter(:only => [name]) { @page_title = title } if title
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    def member_action(name, options = {}, &block)
+      action config.member_actions, name, options, &block
+    end
+
+    def collection_action(name, options = {}, &block)
+      action config.collection_actions, name, options, &block
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   :to => :controller
+    delegate :before_create,  :after_create,  :to => :controller
+    delegate :before_update,  :after_update,  :to => :controller
+    delegate :before_save,    :after_save,    :to => :controller
+    delegate :before_destroy, :after_destroy, :to => :controller
+
+    # Standard rails filters
+    delegate :before_filter, :skip_before_filter, :after_filter, :around_filter, :skip_filter, :to => :controller
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, :to => :controller
+
+  end
+end

data/lib/active_admin/router.rb

@@ -0,0 +1,106 @@
+module ActiveAdmin
+  class Router
+    def initialize(application)
+      @application = application
+    end
+
+    # Creates all the necessary routes for the ActiveAdmin configurations
+    #
+    # Use this within the routes.rb file:
+    #
+    #   Application.routes.draw do |map|
+    #     ActiveAdmin.routes(self)
+    #   end
+    #
+    def apply(router)
+      define_root_routes router
+      define_resource_routes router
+    end
+
+    def define_root_routes(router)
+      router.instance_exec @application.namespaces.values do |namespaces|
+        namespaces.each do |namespace|
+          if namespace.root?
+            root :to => namespace.root_to
+          else
+            namespace namespace.name do
+              root :to => namespace.root_to
+            end
+          end
+        end
+      end
+    end
+
+    # Defines the routes for each resource
+    def define_resource_routes(router)
+      router.instance_exec @application.namespaces, self do |namespaces, aa_router|
+        resources = namespaces.values.map{ |n| n.resources.values }.flatten
+        resources.each do |config|
+          routes = aa_router.resource_routes(config)
+
+          # Add in the parent if it exists
+          if config.belongs_to?
+            belongs_to = routes
+            routes     = Proc.new do
+              # If it's optional, make the normal resource routes
+              instance_exec &belongs_to if config.belongs_to_config.optional?
+
+              # Make the nested belongs_to routes
+              # :only is set to nothing so that we don't clobber any existing routes on the resource
+              resources config.belongs_to_config.target.resource_name.plural, :only => [] do
+                instance_exec &belongs_to
+              end
+            end
+          end
+
+          # Add on the namespace if required
+          unless config.namespace.root?
+            nested = routes
+            routes = Proc.new do
+              namespace config.namespace.name do
+                instance_exec &nested
+              end
+            end
+          end
+
+          instance_exec &routes
+        end
+      end
+    end
+
+    def resource_routes(config)
+      Proc.new do
+        # Builds one route for each HTTP verb passed in
+        build_route  = proc{ |verbs, *args|
+          [*verbs].each{ |verb| send verb, *args }
+        }
+        # Deals with +ControllerAction+ instances
+        build_action = proc{ |action|
+          build_route.call(action.http_verb, action.name)
+        }
+        case config
+        when ::ActiveAdmin::Resource
+          resources config.resource_name.route_key, :only => config.defined_actions do
+            member do
+              config.member_actions.each &build_action
+            end
+
+            collection do
+              config.collection_actions.each &build_action
+              post :batch_action
+            end
+          end
+        when ::ActiveAdmin::Page
+          page = config.underscored_resource_name
+          get "/#{page}" => "#{page}#index"
+          config.page_actions.each do |action|
+            build_route.call action.http_verb, "/#{page}/#{action.name}" => "#{page}##{action.name}"
+          end
+        else
+          raise "Unsupported config class: #{config.class}"
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/scope.rb

@@ -0,0 +1,57 @@
+module ActiveAdmin
+  class Scope
+
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block
+
+    # Create a Scope
+    #
+    # Examples:
+    #
+    #   Scope.new(:published)
+    #   # => Scope with name 'Published' and scope method :published
+    #
+    #   Scope.new('Published', :public)
+    #   # => Scope with name 'Published' and scope method :public
+    #
+    #   Scope.new 'Published', :public, :if => proc { current_admin_user.can? :manage, resource_class } do |articles|
+    #     articles.where :published => true
+    #   end
+    #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block
+    #
+    #   Scope.new('Published') { |articles| articles.where(:published => true) }
+    #   # => Scope with name 'Published' using a block to scope
+    #
+    #   Scope.new ->{Date.today.strftime '%A'}, :published_today
+    #   # => Scope with dynamic title using the :published_today scope method
+    #
+    def initialize(name, method = nil, options = {}, &block)
+      @name, @scope_method = name, method.try(:to_sym)
+
+      if name.is_a? Proc
+        raise "A string/symbol is required as the second argument if your label is a proc." unless method
+        @id = method.to_s.gsub(' ', '').underscore
+      else
+        @scope_method ||= name.to_sym
+        @id = name.to_s.gsub(' ', '').underscore
+      end
+
+      @scope_method               = nil        if @scope_method == :all
+      @scope_method, @scope_block = nil, block if block_given?
+
+      @show_count       = options[:show_count].nil? ? true : options[:show_count]
+      @display_if_block = options[:if]      || proc{ true }
+      @default_block    = options[:default] || proc{ false }
+
+    end
+
+    def name
+      case @name
+        when Proc   then @name.call.to_s
+        when String then @name
+        when Symbol then @name.to_s.titleize
+        else             @name.to_s
+      end
+    end
+
+  end
+end

data/lib/active_admin/sidebar_section.rb

@@ -0,0 +1,37 @@
+module ActiveAdmin
+
+  class SidebarSection
+    include ActiveAdmin::OptionalDisplay
+
+    attr_accessor :name, :options, :block
+
+    def initialize(name, options = {}, &block)
+      @name, @options, @block = name, options, block
+      normalize_display_options!
+    end
+
+    # The id gets used for the div in the view
+    def id
+      "#{name.to_s.downcase.underscore}_sidebar_section".parameterize
+    end
+
+    def icon?
+      !!options[:icon]
+    end
+
+    def icon
+      options[:icon] if icon?
+    end
+
+    # The title gets displayed within the section in the view
+    def title
+      I18n.t("active_admin.sidebars.#{name.to_s}", :default => name.to_s.titlecase)
+    end
+
+    # If a block is not passed in, the name of the partial to render
+    def partial_name
+      options[:partial] || "#{name.to_s.downcase.gsub(' ', '_')}_sidebar"
+    end
+  end
+
+end

data/lib/active_admin/version.rb

@@ -0,0 +1,3 @@
+module ActiveAdmin
+  VERSION = '1.0.0.pre'
+end

data/lib/active_admin/view_factory.rb

@@ -0,0 +1,27 @@
+require 'active_admin/abstract_view_factory'
+
+module ActiveAdmin
+  class ViewFactory < AbstractViewFactory
+
+    # Register Helper Renderers
+    register  :global_navigation    => ActiveAdmin::Views::TabbedNavigation,
+              :utility_navigation   => ActiveAdmin::Views::TabbedNavigation,
+              :site_title           => ActiveAdmin::Views::SiteTitle,
+              :action_items         => ActiveAdmin::Views::ActionItems,
+              :title_bar            => ActiveAdmin::Views::TitleBar,
+              :header               => ActiveAdmin::Views::Header,
+              :footer               => ActiveAdmin::Views::Footer,
+              :index_scopes         => ActiveAdmin::Views::Scopes,
+              :blank_slate          => ActiveAdmin::Views::BlankSlate,
+              :action_list_popover  => ActiveAdmin::Views::ActionListPopover
+
+    # Register All The Pages
+    register  :index_page         	=> ActiveAdmin::Views::Pages::Index,
+              :show_page          	=> ActiveAdmin::Views::Pages::Show,
+              :new_page           	=> ActiveAdmin::Views::Pages::Form,
+              :edit_page          	=> ActiveAdmin::Views::Pages::Form,
+              :layout             	=> ActiveAdmin::Views::Pages::Layout,
+              :page               	=> ActiveAdmin::Views::Pages::Page
+
+  end
+end

data/lib/active_admin/view_helpers/active_admin_application_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ActiveAdminApplicationHelper
+
+      # Returns the current Active Admin application instance
+      def active_admin_application
+        ActiveAdmin.application
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/assigns_with_indifferent_access_helper.rb

@@ -0,0 +1,7 @@
+module AssignsWithIndifferentAccessHelper
+
+  def assigns
+    @assigns_with_indifferent_access_helper ||= HashWithIndifferentAccess.new(super)
+  end
+
+end

data/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module ViewHelpers
+    module AutoLinkHelper
+
+      # Automatically links objects to their resource controllers. If
+      # the resource has not been registered, a string representation of
+      # the object is returned.
+      #
+      # The default content in the link is returned from ActiveAdmin::ViewHelpers::DisplayHelper#display_name
+      #
+      # You can pass in the content to display
+      #   eg: auto_link(@post, "My Link Content")
+      #
+      def auto_link(resource, link_content = nil)
+        content = link_content || display_name(resource)
+        if (registration = active_admin_resource_for(resource.class))
+          begin
+            content = link_to(content, registration.route_instance_path(resource))
+          rescue
+            # ignored
+          end
+        end
+        content
+      end
+
+      # Returns the ActiveAdmin::Resource instance for a class
+      def active_admin_resource_for(klass)
+        return nil unless respond_to?(:active_admin_namespace)
+        active_admin_namespace.resource_for(klass)
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -0,0 +1,26 @@
+module ActiveAdmin
+  module ViewHelpers
+    module BreadcrumbHelper
+
+      # Returns an array of links to use in a breadcrumb
+      def breadcrumb_links(path = request.path)
+        parts = path[1..-1].split('/') # remove leading "/" and split up the URL
+        parts.pop                      # remove last since it's used as the page title
+
+        parts.each_with_index.map do |part, index|
+          # 1. try using `display_name` if we can locate a DB object
+          # 2. try using the model name translation
+          # 3. default to calling `titlecase` on the URL fragment
+          if part =~ /\A(\d+|[a-f0-9]{24})\z/ && parts[index-1]
+            config = active_admin_config.belongs_to_config.try(:target) || active_admin_config
+            name   = display_name config.find_resource(part)
+          end
+          name ||= I18n.t "activerecord.models.#{part.singularize}", :count => 1.1, :default => part.titlecase
+
+          link_to name, '/' + parts[0..index].join('/')
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/display_helper.rb

@@ -0,0 +1,49 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DisplayHelper
+
+      # Attempts to call any known display name methods on the resource.
+      # See the setting in `application.rb` for the list of methods and their priority.
+      def display_name(resource)
+        resource.send display_name_method_for resource if resource
+      end
+
+      # Looks up and caches the first available display name method.
+      def display_name_method_for(resource)
+        @@display_name_methods_cache ||= {}
+        @@display_name_methods_cache[resource.class] ||= begin
+          methods = active_admin_application.display_name_methods - association_methods_for(resource)
+          methods.detect{ |method| resource.respond_to? method }
+        end
+      end
+
+      # To prevent conflicts, we exclude any methods that happen to be associations.
+      def association_methods_for(resource)
+        return [] unless resource.class.respond_to? :reflect_on_all_associations
+        resource.class.reflect_on_all_associations.map(&:name)
+      end
+
+      # Return a pretty string for any object
+      # Date Time are formatted via #localize with :format => :long
+      # ActiveRecord and Mongoid objects are formatted via #auto_link
+      # We attempt to #display_name of any other objects
+      def pretty_format(object)
+        case object
+        when String
+          object
+        when Arbre::Element
+          object
+        when Date, Time
+          localize(object, :format => :long)
+        when ->(obj){defined?(::ActiveRecord) && obj.is_a?(ActiveRecord::Base)}
+          auto_link(object)
+        when ->(obj){defined?(::Mongoid) && obj.class.included_modules.include?(Mongoid::Document)}
+          auto_link(object)
+        else
+          display_name(object)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/download_format_links_helper.rb

@@ -0,0 +1,49 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DownloadFormatLinksHelper
+
+      module ClassMethods
+
+        # A ready only of formats to make available in index/paginated
+        # collection view.
+        # @return [Array]
+        # @see add_format for information on adding custom download link
+        # formats
+        def formats
+          @formats ||= [:csv, :xml, :json]
+          @formats.clone
+        end
+
+        # Adds a mime type extension to the list of available formats.
+        # You must register the extension prior to adding it to the list
+        # of avilable formats. This should be used by plugins that want
+        # to add additional formats to the download format links.
+        # @param [Symbol] extension the mime extension to add
+        # @return [Array] A copy of the updated formats array.
+        def add_format extension
+          unless formats.include?(extension)
+            if Mime::Type.lookup_by_extension(extension).nil?
+              raise ArgumentError, "The mime extension you defined: #{extension} is not registered. Please register it via Mime::Type.register before adding it to the available formats."
+            end
+          @formats << extension
+          end
+          formats
+        end
+      end
+
+      # TODO: Refactor to new HTML DSL
+      def build_download_format_links(formats = self.class.formats)
+        params = request.query_parameters.except :format, :commit
+        links = formats.map { |format| link_to format.to_s.upcase, params: params, format: format }
+        div :class => "download_links" do
+          text_node [I18n.t('active_admin.download'), links].flatten.join("&nbsp;").html_safe
+        end
+      end
+
+      def self.included base
+        base.extend ClassMethods
+      end
+    end
+  end
+end
+

data/lib/active_admin/view_helpers/fields_for.rb

@@ -0,0 +1,50 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      # Flatten a params Hash to an array of fields.
+      #
+      # @param params [Hash]
+      # @param options [Hash] :namespace and :except
+      #
+      # @return [Array] of [Hash] with one element.
+      #
+      # @example
+      #   fields_for_params(scope: "all", users: ["greg"])
+      #     => [ {"scope" => "all"} , {"users[]" => "greg"} ]
+      #
+      def fields_for_params(params, options = {})
+        namespace = options[:namespace]
+        except = options[:except].is_a?(Array) ? options[:except] : [options[:except]]
+
+        params.map do |k, v|
+          next if namespace.nil? && %w(controller action commit utf8).include?(k.to_s)
+          next if except.map(&:to_s).include?(k.to_s)
+
+          if namespace
+            k = "#{namespace}[#{k}]"
+          end
+
+          case v
+          when String
+            { k => v }
+          when Symbol
+            { k => v.to_s }
+          when Hash
+            fields_for_params(v, :namespace => k)
+          when Array
+            v.map do |v|
+              { "#{k}[]" => v }
+            end
+          when nil
+          	{ k => '' }
+          when TrueClass,FalseClass
+            { k => v }
+          else
+            raise "I don't know what to do with #{v.class} params: #{v.inspect}"
+          end
+        end.flatten.compact
+      end
+    end
+  end
+end

data/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/lib/active_admin/view_helpers/form_helper.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      def active_admin_form_for(resource, options = {}, &block)
+        options = Marshal.load( Marshal.dump(options) )
+        options[:builder] ||= ActiveAdmin::FormBuilder
+
+        if ! options.fetch(:decorate, true)
+          resource = resource.model
+        end
+
+        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/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