elucid-rails_admin 0.0.1

data/app/helpers/rails_admin/application_helper.rb

@@ -0,0 +1,65 @@
+require 'rails_admin/i18n_support'
+
+module RailsAdmin
+  module ApplicationHelper
+
+    include RailsAdmin::I18nSupport
+
+    def authorized?(*args)
+      @authorization_adapter.nil? || @authorization_adapter.authorized?(*args)
+    end
+
+    # Creative whitespace:
+    ViewType   =           Struct.new(:parent,    :type,   :authorization, :path_method)
+    VIEW_TYPES = {
+      :delete         => ViewType.new(:show,      :object, :delete),
+      :for_object     => ViewType.new(:show,      :object, nil,            :history_object),
+      :edit           => ViewType.new(:show,      :object, :edit),
+      :show           => ViewType.new(:index,     :object, nil),
+      :export         => ViewType.new(:index,     :model,  :export),
+      :new            => ViewType.new(:index,     :model,  :new),
+      :for_model      => ViewType.new(:index,     :model,  nil,            :history_model),
+      :index          => ViewType.new(:dashboard, :model,  :index),
+      :dashboard      => ViewType.new
+    }
+
+    def breadcrumbs_for view, abstract_model, object
+      return unless VIEW_TYPES[view]
+      views = []
+      parent = view
+      begin
+        views << parent
+      end while parent = VIEW_TYPES[parent].parent
+      breadcrumbs = views.reverse.map do |v|
+        breadcrumb_for v, abstract_model, object, (v==view)
+      end
+      content_tag(:ul, :class => "breadcrumb") do
+        breadcrumbs.join('<span class="divider">/</span>').html_safe
+      end
+    end
+
+    private
+
+    def breadcrumb_for view, abstract_model, object, active
+      vt = VIEW_TYPES[view]
+      if authorized?(view, abstract_model, object)
+        css_classes = []
+        css_classes << "active" if active
+        config = RailsAdmin.config(abstract_model)
+        content_tag(:li, :class => css_classes.join(' ')) do
+          path_method = vt.path_method || view
+          wording = case view
+            when :show
+              object.send(config.object_label_method)
+            when :index
+              config.label_plural
+            else
+              I18n.t("admin.breadcrumbs.#{view}").capitalize
+          end
+          link_to wording, self.send("#{path_method}_path")
+        end
+      end
+    end
+  end
+end
+

data/app/helpers/rails_admin/form_builder.rb

@@ -0,0 +1,52 @@
+ActionView::Base.field_error_proc = Proc.new { |html_tag, instance| "<span class=\"field_with_errors\">#{html_tag}</span>".html_safe }
+
+module RailsAdmin
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    def render action
+      @template.instance_variable_get(:@model_config).send(action).with(:form => self, :object => @object, :view => @template).visible_groups.map do |fieldset|
+        fieldset_for fieldset
+      end.join.html_safe +
+      @template.render(:partial => 'submit_buttons')
+    end
+
+    def fieldset_for fieldset
+      if (fields = fieldset.fields.map{ |f| f.with(:form => self, :object => @object, :view => @template) }.select(&:visible?)).length > 0
+        @template.content_tag :fieldset do
+          @template.content_tag(:legend, fieldset.label.html_safe + (fieldset.help.present? ? @template.content_tag(:small, fieldset.help) : '')) +
+          fields.map{ |field| field_wrapper_for(field) }.join.html_safe
+        end
+      end
+    end
+
+    def field_wrapper_for field
+      @template.content_tag(:div, :class => "clearfix field #{'error' if field.errors.present?}", :id => field.dom_id + '_field') do
+        label(field.method_name, field.label) +
+        input_for(field)
+      end
+    end
+
+    def input_for field
+      @template.content_tag(:div, :class => 'input') do
+        field_for(field) +
+        errors_for(field) +
+        help_for(field)
+      end
+    end
+
+    def errors_for field
+      field.errors.present? ? @template.content_tag(:span, "#{field.label} #{field.errors.first}", :class => 'help-inline') : ''
+    end
+
+    def help_for field
+      field.help.present? ? @template.content_tag(:span, field.help, :class => 'help-block') : ''
+    end
+
+    def field_for field
+      if field.read_only
+        field.pretty_value.to_s.html_safe
+      else
+        field.render.html_safe
+      end
+    end
+  end
+end

data/app/helpers/rails_admin/main_helper.rb

@@ -0,0 +1,100 @@
+require 'builder'
+
+module RailsAdmin
+  module MainHelper
+    def get_indicator(percent)
+      return "" if percent < 0          # none
+      return "notice" if percent < 34   # < 1/100 of max
+      return "success" if percent < 67  # < 1/10 of max
+      return "warning" if percent < 84  # < 1/3 of max
+      return "important"                # > 1/3 of max
+    end
+
+    def get_column_set(properties)
+      sets = calculate_width(properties)
+      current_set ||= params[:set].to_i
+
+      raise NotFound if sets.size <= current_set
+
+      selected_set = sets[current_set][:p]
+      style, other = justify_properties(sets, current_set)
+
+      return style, other, selected_set
+    end
+
+    private
+
+    def calculate_width(properties)
+      # local variables
+      total = 0
+      set = []
+
+      # variables used in loop
+      partial_total = 0
+      temp = []
+
+      # loop through properties
+      properties.each do |property|
+        # get width for the current property
+        width = property.column_width || 120
+
+        # if properties that were gathered so far have the width
+        # over 697 make a set for them
+        if partial_total + width >= RailsAdmin::Config.total_columns_width
+          set << {:p => temp, :size => partial_total}
+          partial_total = 0
+          temp = []
+        end
+
+        # continue to add properties to set
+        temp << property
+        partial_total += width
+        total += width
+      end
+
+      # add final set to returned value
+      set << {:p => temp, :size => partial_total}
+
+      return set
+    end
+
+    def justify_properties(sets, current_set)
+      total = 697
+      style = {}
+
+      properties = sets[current_set][:p]
+      # calculate the maximum distance
+      total = sets.size == 1 ? 784 : 744
+      max_sets = sets.size-2
+      total = current_set.between?(1, max_sets) ?  704 : total
+      column_offset = total-sets[current_set][:size]
+      per_property = properties.size != 0 ? column_offset / properties.size : 0
+      offset = column_offset - per_property * properties.size
+
+      properties.each do |property|
+        property_type = property.column_css_class
+        if width = property.column_width
+          style[property_type] ||= {:size => 0, :occ => 0, :width => 0}
+          style[property_type][:size] += per_property
+          style[property_type][:occ] += 1
+          style[property_type][:width] = width + style[property_type][:size] / style[property_type][:occ]
+        end
+      end
+
+      other = []
+
+      if total == 784
+        other = ["left", "right"]
+      elsif total == 744
+        if current_set == 0
+          other = ["left"]
+        else
+          other = ["right"]
+        end
+      end
+
+      return style, other
+    end
+
+  end
+end

data/app/models/rails_admin/history.rb

@@ -0,0 +1,64 @@
+class RailsAdmin::History < ActiveRecord::Base
+  set_table_name :rails_admin_histories
+
+  IGNORED_ATTRS = Set[:id, :created_at, :created_on, :deleted_at, :updated_at, :updated_on, :deleted_on]
+  
+  def self.create_update_history(model, object, associations_before, associations_after, modified_associations, old_object, user)
+    messages = []
+    changed_property_list = []
+    properties = model.properties.reject{|p| IGNORED_ATTRS.include?(p[:name])}
+    
+    properties.each do |p|
+      property_name = p[:name].to_param
+      changed_property_list << property_name if old_object.safe_send(property_name) != object.safe_send(property_name)
+    end
+    
+    model.associations.each do |t| 
+      assoc = changed_property_list.index(t[:child_key].to_param)
+      changed_property_list[assoc] = "associated #{t[:pretty_name]}" if assoc
+    end
+    
+    associations_after.each do |key, current|
+      removed_ids = (associations_before[key] - current).map{|m| '#' + m.to_s}
+      added_ids = (current - associations_before[key]).map{|m| '#' + m.to_s}
+      messages << "Removed #{key.to_s.capitalize} #{removed_ids.join(', ')} associations" if removed_ids.any?
+      messages << "Added #{key.to_s.capitalize} #{added_ids.join(', ')} associations" if added_ids.any?
+    end
+    
+    modified_associations.uniq.each { |t| changed_property_list << "associated #{t}" }
+    
+    messages << "Changed #{changed_property_list.join(", ")}" unless changed_property_list.empty?
+    create_history_item(messages, object, model, user) unless messages.empty?
+  end
+
+  def self.create_history_item(message, object, abstract_model, user)
+    create(
+       :message => [message].flatten.join(', '),
+       :item => object.id,
+       :table => abstract_model.pretty_name,
+       :username => user.try(:email)
+     )
+  end
+
+  def self.history_for_model(model, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+    history = where(:table => model.pretty_name)
+    history = history.where("message LIKE ? OR username LIKE ?", "%#{query}%", "%#{query}%") if query
+    if sort
+      history = history.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+    else
+      history = history.order('created_at DESC')
+    end
+    all ? history : history.page(page.presence || "1").per(per_page)
+  end
+
+  def self.history_for_object(model, object, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+    history = where(:table => model.pretty_name, :item => object.id)
+    history = history.where("message LIKE ? OR username LIKE ?", "%#{query}%", "%#{query}%") if query
+    if sort
+      history = history.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+    else
+      history = history.order('created_at DESC')
+    end
+    all ? history : history.page(page.presence || "1").per(per_page)
+  end
+end

data/app/views/kaminari/twitter-bootstrap/_gap.html.haml

@@ -0,0 +1,2 @@
+%li.disabled
+  %a{:href => '#'}= raw(t 'views.pagination.truncate')

data/app/views/kaminari/twitter-bootstrap/_next_page.html.haml

@@ -0,0 +1,4 @@
+- if current_page.last?
+  %li.next.disabled= link_to raw(t 'views.pagination.next'), '#'
+- else
+  %li.next= link_to raw(t 'views.pagination.next'), url, :remote => remote

data/app/views/kaminari/twitter-bootstrap/_page.html.haml

@@ -0,0 +1,4 @@
+- if page.current?
+  %li.active= link_to page, url, :remote => remote
+- else
+  %li= link_to page, url, :remote => remote

data/app/views/kaminari/twitter-bootstrap/_paginator.html.haml

@@ -0,0 +1,10 @@
+= paginator.render do
+  .pagination
+    %ul
+      = prev_page_tag
+      - each_page do |page|
+        - if page.left_outer? or page.right_outer? or page.inside_window?
+          = page_tag page
+        - elsif !page.was_truncated?
+          = gap_tag
+      = next_page_tag

data/app/views/kaminari/twitter-bootstrap/_prev_page.html.haml

@@ -0,0 +1,4 @@
+- if current_page.first?
+  %li.prev.disabled= link_to raw(t 'views.pagination.previous'), '#'
+- else
+  %li.prev= link_to raw(t 'views.pagination.previous'), url, :remote => remote

data/app/views/layouts/rails_admin/_navigation.html.haml

@@ -0,0 +1,19 @@
+- models = RailsAdmin::Config.visible_models.select { |model| authorized?(:index, model.abstract_model) }
+- root_models = models.select { |model| model.parent == :root }
+
+%ul#nav.navigation
+  %li{:class => ("active" if @page_type == "dashboard")}
+    = link_to(t("admin.dashboard.name"), dashboard_path)
+  - root_models.each do |model|
+    - children = [model] + models.select { |m| m.parent.to_s == model.abstract_model.model.to_s }
+    - tab_titles = children.map { |child| child.abstract_model.pretty_name.downcase }
+    - active = tab_titles.include? @page_type
+    %li{:class => "#{"active" if active} #{"more" unless children.empty?}"}
+      - if children.size == 1
+        = link_to(model.label_plural, index_path(:model_name => model.abstract_model.to_param))
+      - else
+        = model.navigation_label ? t(model.navigation_label, :default => model.navigation_label) : model.label_plural
+        %ul
+          - children.each_with_index do |child, index|
+            %li{:class => ("active" if @page_type == tab_titles[index])}
+              = link_to(child.label_plural, index_path(:model_name => child.abstract_model.to_param))

data/app/views/layouts/rails_admin/_secondary_navigation.html.haml

@@ -0,0 +1,9 @@
+%li= link_to t('admin.dashboard.name'), dashboard_path
+- if main_app_root_path = (main_app.root_path rescue false)
+  %li= link_to t('home.name').capitalize, main_app_root_path
+- if _current_user
+  - if authorized?(:edit, _current_user.class, _current_user) && _current_user.respond_to?(:email)
+    %li= link_to _current_user.email, edit_path(_current_user.class.name.underscore.pluralize, _current_user)
+  - if defined?(Devise) && (devise_scope = request.env["warden"].config[:default_scope] rescue false) && (logout_path = main_app.send("destroy_#{devise_scope}_session_path") rescue false)
+    %li= link_to content_tag('span', t('admin.credentials.log_out'), :class => 'label important'), logout_path, :method => Devise.sign_out_via
+  %li= image_tag "#{(request.ssl? ? 'https://secure' : 'http://www')}.gravatar.com/avatar/#{Digest::MD5.hexdigest _current_user.email}?s=30", :style => 'padding-top:5px'

data/app/views/layouts/rails_admin/application.html.haml

@@ -0,0 +1,41 @@
+!!! 5
+%html
+  %head
+    %title= "#{@abstract_model.try(:pretty_name) || @page_name} | #{[_get_plugin_name[0] || 'Rails', _get_plugin_name[1] || 'Admin'].join(' ')}"
+    %meta{:content => "text/html; charset=utf-8", "http-equiv" => "Content-Type"}
+    %meta{:content => "NONE,NOARCHIVE", :name => "robots"}
+    = csrf_meta_tag
+    = stylesheet_link_tag "rails_admin/rails_admin.css"
+    = javascript_include_tag "rails_admin/rails_admin.js"
+  %body.rails_admin{:style => "padding-top: 60px;"}
+    .topbar-wrapper{:style => "z-index: 5;"}
+      .topbar{:'data-dropdown' => 'dropdown'}
+        .topbar-inner
+          .container-fluid
+            %h3
+              = link_to dashboard_path do
+                = _get_plugin_name[0] || 'Rails'
+                %small= _get_plugin_name[1] || 'Admin'
+            %ul.nav.secondary-nav= render :partial => 'layouts/rails_admin/secondary_navigation'
+    .container-fluid
+      .sidebar
+        .well
+          %h3= t "admin.dashboard.navigation"
+          = render :partial => 'layouts/rails_admin/navigation'
+      .content
+        .page-header
+          %h1= @page_name
+        - flash && flash.each do |key, value|
+          .alert-message.fade.in{:class => key}
+            %a.close{:href => '#'}×
+            %p= value
+        = breadcrumbs_for params[:action].to_sym, @abstract_model, @object
+        - if @abstract_model
+          - if @object && !@object.new_record?
+            %ul.tabs= render :partial => 'rails_admin/main/object_links', :locals => { :add_active_class => true, :model_name => params[:model_name], :object => @object }
+          - else
+            %ul.tabs= render :partial => 'rails_admin/main/models_links', :locals => { :abstract_model => @abstract_model }
+        %span.row
+        = yield
+        %footer
+          %p © RailsAdmin 2011

data/app/views/rails_admin/history/_dashboard.html.haml

@@ -0,0 +1,10 @@
+%table.zebra-striped
+  %thead
+    %tr
+      %th.shrink.user= t("admin.history.user")
+      %th.changes= t("admin.history.changes")
+  %tbody
+    - @history.each do |t|
+      %tr
+        %td= t.try :username
+        %td= "#{m = t.message.downcase} #{m.to_s.rindex("changed") ? "for #{t.table.capitalize} ##{t.item}" : ''}"

data/app/views/rails_admin/history/show.html.haml

@@ -0,0 +1,42 @@
+- params = request.params.except(:action, :controller, :model_name)
+- query = params[:query]
+- filter = params[:filter]
+- sort = params[:sort]
+- sort_reverse = params[:sort_reverse]
+- path_method = params[:id] ? "history_object_path" : "history_model_path"
+
+= form_tag("", :method => "get", :class => "search") do
+  .row.clearfix
+    .span3
+      %input{:name => "query", :type => "search", :value => query, :placeholder => "#{t("admin.index.search")}"}
+    .span3
+      %button.btn.primary{:type => "submit", :'data-disable-with' => t("admin.index.search")}= t("admin.index.search")
+%table#history.zebra-striped
+  %thead
+    %tr
+      - columns = []
+      - columns << { :property_name => "created_at", :css_class => "created_at",:link_text => "DATE/TIME" }
+      - columns << { :property_name => "username",   :css_class => "username",  :link_text => "USER"      }
+      - columns << { :property_name => "item",       :css_class => "item",      :link_text => "ITEM"      } if @general
+      - columns << { :property_name => "message",    :css_class => "message",   :link_text => "ACTION"    }
+
+      - columns.each do |column|
+        - property_name = column[:property_name]
+        - selected = (sort == property_name)
+        - sort_direction = selected ? (sort_reverse ? "headerSortUp" : "headerSortDown") : nil
+        - sort_location = send(path_method, params.except("sort_reverse").merge(:model_name => @abstract_model.to_param, :sort => property_name).merge(selected && sort_reverse != "true" ? {:sort_reverse => "true"} : {}))
+        %th{:class => "header #{column[:css_class]} #{sort_direction if selected}", :'data-link' => sort_location}= column[:link_text]
+  %tbody
+    - @history.each_with_index do |object, index|
+      %tr
+        - unless object.created_at.nil?
+          %td= l(object.created_at, :format => :long, :default => l(object.created_at, :format => :long, :locale => :en))
+        %td= object.username
+        - if @general
+          %td= object.item
+        %td= object.message
+
+- unless params[:all] || !@history.respond_to?(:current_page)
+  = paginate(@history, :theme => 'twitter-bootstrap')
+  = link_to(t("admin.index.show_all"), send(path_method, params.merge(:all => true)), :class => "show-all btn") unless (tc = @history.total_count) <= @history.size || tc > 100
+