underworld 1.0.0

data/lib/underworld/dashboard/sections/resource_destroy.rb

@@ -0,0 +1,27 @@
+module Underworld::Dashboard::Sections
+  module ResourceDestroy
+
+    extend ActiveSupport::Concern
+
+    # The actual action method of a dashboard controller
+    def destroy
+      @resource = model.find(params[:id])
+      authorize @resource
+
+      @resource_title = t(_resource_title.singularize)
+
+      before_destroy_hook(@resource)
+      @resource.destroy
+
+      return if _override_views.include? :destroy
+      render 'underworld/dashboard/resource/destroy'
+    end
+
+    private
+
+      # You can override this method to change the behaviour of `destroy`
+      # action
+      def before_destroy_hook(resource)
+      end
+  end
+end

data/lib/underworld/dashboard/sections/resource_show.rb

@@ -0,0 +1,96 @@
+require_dependency 'underworld/dashboard/dsl/show'
+
+module Underworld::Dashboard::Sections
+  module ResourceShow
+
+    extend ActiveSupport::Concern
+
+    # The actual action method of a dashboard controller
+    def show
+      @resource = model.find(params[:id])
+      authorize @resource
+
+      collect_model_fields_for_show
+
+      @resource_title = t(_resource_title.singularize)
+
+      show_hook(@resource)
+
+      return if _override_views.include? :show
+      render 'underworld/dashboard/resource/show'
+    end
+
+    protected
+
+      def collect_model_fields_for_show
+        @_fields ||= show_properties.fields
+        #valid_columns = all_valid_columns_for_show
+      end
+
+      def show_properties
+        Underworld::Dashboard::DSL::Show.new(model)
+      end
+
+    private
+
+
+      # def all_valid_columns_for_show
+      #   return @all_valid_columns_for_show unless @all_valid_columns_for_show.nil?
+      #   columns   = model.columns_hash.dup
+      #   relations = model.reflections
+
+      #   relations.keys.each do |name|
+      #     col    = relations[name]
+      #     column = columns.delete col.foreign_key
+      #     columns[name] = column
+      #   end
+
+      #   @all_valid_columns_for_show = columns
+      # end
+      def _show_fields
+        all_valid_columns_for_show.keys.map(&:to_sym)
+      end
+
+      # You can override this method to change the behaviour of `show`
+      # action
+      def show_hook(resource)
+      end
+
+    # The actual DSL for index ages
+    module ClassMethods
+      # To specify any property and action for `show` section
+      # you must use `in_index` class method with block of
+      # properties. For example:
+      #
+      # ```ruby
+      #   class ExamplesController < Dashboard::Application
+      #     in_show do
+      #       attributes :name, :description
+      #       action_button :close, label: 'Close', href: dashboard_example_close_path
+      #     end
+      #   end
+      # ```
+      #
+      def in_show(&block)
+        name  = controller_name
+        path  = controller_path.gsub(name, '').gsub(/dashboard\//, '')
+        model = "#{path}#{name}".classify.constantize
+        show_props = Underworld::Dashboard::DSL::Show.new(model)
+
+        unless block_given?
+          fail ArgumentError, "You have to provide a block for 'in_show'"
+        end
+
+        show_props.instance_eval(&block) if block_given?
+
+        define_method(:show_properties) do
+          unless defined? @__show_props__
+            instance_exec(show_props, &block)
+            @__show_props__ = show_props
+          end
+          return @__show_props__
+        end
+      end
+    end
+  end
+end

data/lib/underworld/dashboard/sections/resources_index.rb

@@ -0,0 +1,113 @@
+require_dependency 'underworld/dashboard/dsl/index'
+
+module Underworld::Dashboard::Sections
+  module ResourcesIndex
+
+    extend ActiveSupport::Concern
+
+    # The actual action method of a dashboard controller
+    def index
+      authorize model
+      fetch_and_set_all
+      action_buttons(index_properties)
+
+      @_tools_buttons = index_properties.tool_buttons || {}
+      index_hook(@resources)
+
+      return if _override_views.include? :index
+      render 'underworld/dashboard/resource/index'
+    end
+
+    protected
+
+      # Fetch all or part of the corresponding resource
+      # from data base with respect to `scope` DSL.
+      #
+      # The important thing here is that by using `scope`
+      # DSL this method will chain the resulted scope
+      # with other scopes like `page` and `policy_scope`
+    def fetch_index_objects
+      scope = index_properties.default_scope
+
+        if !scope.nil?
+
+          # If user provided an scope for `index` section.
+
+          if scope.respond_to? :call
+            # If scope provided by a block
+            scope = scope.call
+          else
+            # If scope provided by a symbol
+            # which should be a method name
+            scope = self.send(scope)
+          end
+
+        else
+          scope = model.all
+          #scope = ApplicationPolicy::Scope.new(current_user, model.all).resolve
+        end
+
+        scope = scope.order('created_at DESC').page(params[:page])
+        policy_scope(scope)
+
+      end
+
+      def index_properties
+        Underworld::Dashboard::DSL::Index.new(model)
+      end
+
+    private
+
+      def fetch_and_set_all
+        result = fetch_index_objects
+        instance_variable_set("@#{plural_name}", result)
+
+        @index_fields = index_properties.fields
+        @resources    = result
+      end
+
+      # You can override this method to change the behaviour of `index`
+      # action
+      def index_hook(resources)
+
+      end
+    # The actual DSL for index ages
+    module ClassMethods
+
+      # To specify any property and action for `index` section
+      # you must use `in_index` class method with block of
+      # properties. For example:
+      #
+      # ```ruby
+      #   class ExamplesController < Dashboard::Application
+      #     in_index do
+      #       attributes :name, :description
+      #       action_button :close, label: 'Close', href: dashboard_example_close_path
+      #     end
+      #   end
+      # ```
+      #
+      def in_index(&block)
+        name  = controller_name
+        path  = controller_path.gsub(name, '').gsub(/dashboard\//, '')
+        model = "#{path}#{name}".classify.constantize
+
+        index_props = Underworld::Dashboard::DSL::Index.new(model)
+
+        unless block_given?
+          fail ArgumentError, "You have to provide a block for 'in_index'"
+        end
+
+        define_method(:index_properties) do
+          unless defined? @__index_props__
+            instance_exec(index_props, &block)
+            @__index_props__ = index_props
+          end
+
+          return @__index_props__
+        end
+      end
+
+    end
+  end
+end

data/lib/underworld/dashboard/sections/sidebar.rb

@@ -0,0 +1,41 @@
+require_dependency 'underworld/dashboard/models/sidebar'
+
+module Underworld::Dashboard::Sections
+  module Sidebar
+
+    extend ActiveSupport::Concern
+
+    protected
+
+      def setup_sidebar
+        @sidebar = sidebar(t('dashboard')) do |sidebar|
+          sidebar.underworld_entries
+        end
+      end
+
+    private
+
+      def sidebar(name, **options, &block)
+        sidebar = Underworld::Dashboard::Models::Sidebar.new(name, **options)
+
+        yield sidebar if block_given?
+
+        sidebar
+      end
+
+    module ClassMethods
+
+      def sidebar(name, **options, &block)
+        side = Underworld::Dashboard::Models::Sidebar.new(name, **options)
+
+        side.instance_eval do
+          block.call if block_given?
+        end
+
+        define_method(:setup_sidebar) do
+          instance_variable_set('@sidebar', side)
+        end
+      end
+    end
+  end
+end

data/lib/underworld/discovery.rb

@@ -0,0 +1,8 @@
+module Underworld
+  # This module contains all the code snippets
+  # to discover special entities in project
+  module Discovery
+  end
+end
+
+require 'underworld/discovery/permissions'

data/lib/underworld/discovery/permissions.rb

@@ -0,0 +1,49 @@
+module Underworld
+  module Discovery
+    # This class is responsible to discoering all Permissions
+    # classes and provide a list of available permissions
+    class Permissions
+
+      # Run the given block for each object with permissions
+      def self.permission_objects(&block)
+        objects = []
+
+        # Walkthrough all models in application by using
+        # model_discovery gem and check for `permission_strings`
+        # method in models (If `Underworld::Permissions` included in
+        # model it has the permission_strings). And concat the
+        # permissions to `@permissions` instance method.
+        ::ApplicationModels.to_adapter.find_all.each do |m|
+          # `m` is a string contains name of a model and
+          # we use contstantize to get the model class with
+          # such name
+          model = m.model.constantize
+          if model.respond_to? :permission_strings
+            block.call(model)
+          end
+        end
+      end
+
+      def self.all_permissions
+        permissions = []
+        permission_objects do |object|
+          permissions.concat(object.permission_strings(object))
+        end
+
+        permissions.uniq
+      end
+
+      # Creating all possible permissions in database using
+      # `Underworld::Permission` model
+      def self.create_all_permissions
+
+        permission_objects do |object|
+          object.possible_permissions.each do |perm|
+            Underworld::Permission.where(model: object.to_s,
+                                     permission_type: perm).first_or_create
+          end
+        end
+      end
+    end
+  end
+end

data/lib/underworld/engine.rb

@@ -0,0 +1,53 @@
+require_relative './middlewares/locale'
+require_relative './configuration'
+
+module Underworld
+
+  # `Engine` class of **Underworld**.
+  class Engine < ::Rails::Engine
+    extend ::Underworld::Configuration
+
+    # TODO: Add a facility to allow developers to select
+    #       features of underworld
+    isolate_namespace Underworld
+    engine_name 'underworld'
+
+    # Map `api` to `API` in Rails autoload
+    ActiveSupport::Inflector.inflections(:en) do |inflect|
+      inflect.acronym 'API'
+      inflect.acronym 'DSL'
+    end
+
+    config.generators do |g|
+      g.test_framework      :minitest, fixture_replacement: :fabrication
+      g.fixture_replacement :fabrication, dir: "test/fabricators"
+      g.integration_tool    :minitest
+      g.assets              false
+      g.helper              false
+    end
+
+    # The actual setup method which is responsible for configuring
+    # `Underworld` environment. This method simply yield the current
+    # class and allows developers to change the configuration via
+    # the class methods defined in `Underworld::Configuration` ( which is
+    # extended in this class ).
+    def self.setup
+      yield self
+
+      # Load the dependencies needed by each particular feature.
+      load_dependencies_based_on_configuration
+    end
+
+    # Override devise layout
+    config.to_prepare do
+      Devise::SessionsController.layout 'underworld/simple'
+      Devise::RegistrationsController.layout  'underworld/simple'
+      Devise::ConfirmationsController.layout 'underworld/application'
+      Devise::UnlocksController.layout 'underworld/application'
+      Devise::PasswordsController.layout 'underworld/application'
+    end
+
+    middleware.use Underworld::Middlewares::Locale
+
+  end
+end

data/lib/underworld/exceptions.rb

@@ -0,0 +1,7 @@
+module Underworld
+  module Exceptions
+    class AuthorizationError < Exception
+
+    end
+  end
+end

data/lib/underworld/extension.rb

@@ -0,0 +1,18 @@
+module Underworld
+  # Extension module of Underworld which contains all the related
+  # stuff to a Underworld extension.
+  module Extension
+
+    @@extensions = {}
+
+    def self.extensions
+      @@extensions
+    end
+
+    def self.extensions=(value)
+      @@extensions = value
+    end
+  end
+end
+
+require 'underworld/extension/base'

data/lib/underworld/extension/base.rb

@@ -0,0 +1,29 @@
+module Underworld
+  module Extension
+    # This module provide basic functionallity of a Underworld extension
+    # to a rails engine.
+    # It should be included in engine of all the Underworld extionsions
+    module Base
+
+      def included(base)
+        extend ClassMethods
+      end
+
+      class ClassMethods
+        def register_extension(name, klass)
+          # TODO: Replace this mechanism with more elegant one
+          #       For example use [] method or someting
+          Underworld::Extension.extensions[name] = klass
+        end
+
+        # This method tells underworld that this extension will override
+        # the generators templates of underworld from `template_path` location
+        def override_generator_templates(template_path)
+          send(:define_singleton_method, 'generator_templates_path') do
+            template_path
+          end
+        end
+      end
+    end
+  end
+end