obitum-rails_admin 0.0.1

data/lib/rails_admin/config/has_groups.rb

@@ -0,0 +1,23 @@
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module HasGroups      
+      # Accessor for a group
+      #
+      # If group with given name does not yet exist it will be created. If a
+      # block is passed it will be evaluated in the context of the group
+      def group(name, &block)
+        group = parent.groups.find {|g| name == g.name }
+        group ||= (parent.groups << RailsAdmin::Config::Fields::Group.new(self, name)).last
+        group.tap{|g| g.section = self}.instance_eval &block if block
+        group
+      end
+
+      # Reader for groups that are marked as visible
+      def visible_groups
+        parent.groups.map {|f| f.section = self; f.with(bindings) }.select(&:visible).select{|g| g.visible_fields.present?}
+      end
+    end
+  end
+end

data/lib/rails_admin/config/hideable.rb

@@ -0,0 +1,28 @@
+module RailsAdmin
+  module Config
+    # Defines a visibility configuration
+    module Hideable
+      # Visibility defaults to true.
+      def self.included(klass)
+        klass.register_instance_option(:visible?) do
+          !root.try :excluded?
+        end
+      end
+
+      # Reader whether field is hidden.
+      def hidden?
+        not visible
+      end
+
+      # Writer to hide field.
+      def hide(&block)
+        visible block ? proc { false == (instance_eval &block) } : false
+      end
+
+      # Writer to show field.
+      def show(&block)
+        visible block || true
+      end
+    end
+  end
+end

data/lib/rails_admin/config/model.rb

@@ -0,0 +1,82 @@
+require 'rails_admin/config'
+require 'rails_admin/config/base'
+require 'rails_admin/config/hideable'
+require 'rails_admin/config/has_groups'
+require 'rails_admin/config/fields/group'
+require 'rails_admin/config/fields'
+require 'rails_admin/config/has_fields'
+require 'rails_admin/config/sections'
+require 'rails_admin/config/actions'
+
+
+module RailsAdmin
+  module Config
+    # Model specific configuration object.
+    class Model < RailsAdmin::Config::Base
+      include RailsAdmin::Config::Hideable
+      include RailsAdmin::Config::Sections
+      
+      attr_reader :abstract_model
+      attr_accessor :groups
+      
+      def initialize(entity)
+        @abstract_model = begin
+          if entity.kind_of?(RailsAdmin::AbstractModel)
+            entity
+          elsif entity.kind_of?(Class) || entity.kind_of?(String) || entity.kind_of?(Symbol)
+            RailsAdmin::AbstractModel.new(entity)
+          else
+            RailsAdmin::AbstractModel.new(entity.class)
+          end
+        end
+        
+        @groups = [ RailsAdmin::Config::Fields::Group.new(self, :default).tap {|g| g.label{I18n.translate("admin.form.basic_info")} } ]
+        @bindings = {}
+        @parent = nil
+        @root = self
+      end
+
+      def excluded?
+        @excluded ||= !RailsAdmin::AbstractModel.all.map(&:model).include?(abstract_model.model)
+      end
+
+      def object_label
+        bindings[:object].send object_label_method
+      end
+
+      # The display for a model instance (i.e. a single database record).
+      # Unless configured in a model config block, it'll try to use :name followed by :title methods, then
+      # any methods that may have been added to the label_methods array via Configuration.
+      # Failing all of these, it'll return the class name followed by the model's id.
+      register_instance_option(:object_label_method) do
+        @object_label_method ||= Config.label_methods.find { |method| (@dummy_object ||= abstract_model.model.new).respond_to? method } || :rails_admin_default_object_label_method
+      end
+
+      register_instance_option(:label) do
+        (@label ||= {})[::I18n.locale] ||= abstract_model.model.model_name.human(:default => abstract_model.model.model_name.demodulize.underscore.humanize)
+      end
+
+      register_instance_option(:label_plural) do
+        (@label_plural ||= {})[::I18n.locale] ||= abstract_model.model.model_name.human(:count => 2, :default => label.pluralize)
+      end
+
+      register_instance_option(:weight) do
+        0
+      end
+
+      register_instance_option(:parent) do
+        :root
+      end
+
+      register_instance_option(:navigation_label) do
+        false
+      end
+
+      # Act as a proxy for the base section configuration that actually
+      # store the configurations.
+      def method_missing(m, *args, &block)
+        self.send(:base).send(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/rails_admin/config/proxy.rb

@@ -0,0 +1,40 @@
+module RailsAdmin
+  module Config
+    class Proxy
+
+      instance_methods.each {|m| undef_method m unless m =~ /^(__|instance_eval|object_id)/ }
+
+      attr_reader :bindings
+
+      def initialize(object, bindings = {})
+        @object = object
+        @bindings = bindings
+      end
+
+      # Bind variables to be used by the configuration options
+      def bind(key, value = nil)
+        if key.kind_of?(Hash)
+          @bindings = key
+        else
+          @bindings[key] = value
+        end
+        self
+      end
+
+      def method_missing(name, *args, &block)
+        if @object.respond_to?(name)
+          reset = @object.instance_variable_get("@bindings")
+          begin
+            @object.instance_variable_set("@bindings", @bindings)
+            response = @object.__send__(name, *args, &block)
+          ensure
+            @object.instance_variable_set("@bindings", @reset)
+          end
+          response
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/config/sections/base'
+require 'rails_admin/config/sections/edit'
+require 'rails_admin/config/sections/update'
+require 'rails_admin/config/sections/create'
+require 'rails_admin/config/sections/nested'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/config/sections/export'
+require 'rails_admin/config/sections/show'
+
+
+module RailsAdmin
+  module Config
+    # Sections describe different views in the RailsAdmin engine. Configurable sections are
+    # list and navigation.
+    #
+    # Each section's class object can store generic configuration about that section (such as the
+    # number of visible tabs in the main navigation), while the instances (accessed via model
+    # configuration objects) store model specific configuration (such as the visibility of the
+    # model).
+    module Sections
+      def self.included(klass)
+        # Register accessors for all the sections in this namespace
+        constants.each do |name|
+          section = "RailsAdmin::Config::Sections::#{name}".constantize
+          name = name.to_s.underscore.to_sym
+          klass.send(:define_method, name) do |&block|
+            @sections = {} unless @sections
+            @sections[name] = section.new(self) unless @sections[name]
+            @sections[name].instance_eval &block if block
+            @sections[name]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_admin/config/sections/base.rb

@@ -0,0 +1,19 @@
+require 'rails_admin/config/base'
+require 'rails_admin/config/has_fields'
+require 'rails_admin/config/has_groups'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the show view for a new object
+      class Base < RailsAdmin::Config::Base
+        include RailsAdmin::Config::HasFields
+        include RailsAdmin::Config::HasGroups
+        
+        def initialize(parent)
+          super(parent)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/create.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the edit view for a new object
+      class Create < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/edit.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the edit view for an existing object
+      class Edit < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/export.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the navigation view
+      class Export < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/list.rb

@@ -0,0 +1,27 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the list view
+      class List < RailsAdmin::Config::Sections::Base
+        register_instance_option :filters do
+          []
+        end
+
+        # Number of items listed per page
+        register_instance_option :items_per_page do
+          RailsAdmin::Config.default_items_per_page
+        end
+
+        register_instance_option :sort_by do
+          parent.abstract_model.model.primary_key
+        end
+
+        register_instance_option :sort_reverse? do
+          true # By default show latest first
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/nested.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Nested < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/show.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Show < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/update.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Update < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/engine.rb

@@ -0,0 +1,21 @@
+require 'rails'
+require 'jquery-rails'
+require 'remotipart'
+require 'bootstrap-sass'
+require 'kaminari'
+require 'rack-pjax'
+require 'nested_form'
+require 'rails_admin'
+
+module RailsAdmin
+  class Engine < Rails::Engine
+    isolate_namespace RailsAdmin
+    initializer "RailsAdmin precompile hook" do |app|
+      app.config.assets.precompile += ['rails_admin/rails_admin.js', 'rails_admin/rails_admin.css', 'rails_admin/jquery.colorpicker.js', 'rails_admin/jquery.colorpicker.css']
+    end
+
+    initializer "RailsAdmin pjax hook" do |app|
+      app.config.middleware.use Rack::Pjax
+    end
+  end
+end

data/lib/rails_admin/extension.rb

@@ -0,0 +1,29 @@
+
+module RailsAdmin
+  EXTENSIONS = []
+  AUTHORIZATION_ADAPTERS = {}
+  AUDITING_ADAPTERS = {}
+  CONFIGURATION_ADAPTERS = {}
+
+  # Extend RailsAdmin
+  #
+  # The extension may define various adapters (e.g., for authorization) and
+  # register those via the options hash.
+  def self.add_extension(extension_key, extension_definition, options = {})
+    options.assert_valid_keys(:authorization, :configuration, :auditing)
+
+    EXTENSIONS << extension_key
+
+    if(authorization = options[:authorization])
+      AUTHORIZATION_ADAPTERS[extension_key] = extension_definition::AuthorizationAdapter
+    end
+
+    if(configuration = options[:configuration])
+      CONFIGURATION_ADAPTERS[extension_key] = extension_definition::ConfigurationAdapter
+    end
+    
+    if(configuration = options[:auditing])
+      AUDITING_ADAPTERS[extension_key] = extension_definition::AuditingAdapter
+    end
+  end
+end

data/lib/rails_admin/extensions/cancan.rb

@@ -0,0 +1,5 @@
+require 'rails_admin/extensions/cancan/authorization_adapter'
+
+RailsAdmin.add_extension(:cancan, RailsAdmin::Extensions::CanCan, {
+  :authorization => true
+})

data/lib/rails_admin/extensions/cancan/authorization_adapter.rb

@@ -0,0 +1,59 @@
+module RailsAdmin
+  module Extensions
+    module CanCan
+      # This adapter is for the CanCan[https://github.com/ryanb/cancan] authorization library.
+      # You can create another adapter for different authorization behavior, just be certain it
+      # responds to each of the public methods here.
+      class AuthorizationAdapter
+        # See the +authorize_with+ config method for where the initialization happens.
+        def initialize(controller, ability = ::Ability)
+          @controller = controller
+          @controller.instance_variable_set '@ability', ability
+          @controller.extend ControllerExtension
+          @controller.current_ability.authorize! :access, :rails_admin
+        end
+
+        # This method is called in every controller action and should raise an exception
+        # when the authorization fails. The first argument is the name of the controller
+        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
+        # AbstractModel instance that applies. The third argument is the actual model
+        # instance if it is available.
+        def authorize(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.authorize!(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This method is called primarily from the view to determine whether the given user
+        # has access to perform the action on a given model. It should return true when authorized.
+        # This takes the same arguments as +authorize+. The difference is that this will
+        # return a boolean whereas +authorize+ will raise an exception when not authorized.
+        def authorized?(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.can?(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This is called when needing to scope a database query. It is called within the list
+        # and bulk_delete/destroy actions and should return a scope which limits the records
+        # to those which the user can perform the given action on.
+        def query(action, abstract_model)
+          abstract_model.model.accessible_by(@controller.current_ability, action)
+        end
+
+        # This is called in the new/create actions to determine the initial attributes for new
+        # records. It should return a hash of attributes which match what the user
+        # is authorized to create.
+        def attributes_for(action, abstract_model)
+          @controller.current_ability.attributes_for(action, abstract_model && abstract_model.model)
+        end
+
+        private
+
+        module ControllerExtension
+          def current_ability
+            # use _current_user instead of default current_user so it works with
+            # whatever current user method is defined with RailsAdmin
+            @current_ability ||= @ability.new(_current_user)
+          end
+        end
+      end
+    end
+  end
+end