faalis 1.0.0 → 2.0.0.rc2

data/lib/faalis/dashboard/dsl/form_fields_properties.rb

@@ -0,0 +1,62 @@
+module Faalis::Dashboard
+  class FormFieldsProperties
+
+    def initializer
+      @fields = {}
+    end
+
+    def fields=(all_fields)
+      fields.each do |name, field|
+        unless all_fields.include? name.to_s
+          raise ArgumentError, "'#{name}' is not a valid field"
+        end
+      end
+
+      all_fields.each do |name, field|
+        unless fields.include?(name.to_sym)
+
+          Rails.logger.debug("FIELD NAME: #{name}")
+          Rails.logger.debug("FIELD TYPE: #{field.type}")
+
+          if self.respond_to?("setup_#{field.type}".to_sym, true)
+            puts "sdasda" * 100
+            send("setup_#{field.type}", name)
+          end
+        end
+      end
+    end
+
+    def fields
+      @fields || {}
+    end
+
+    def []=(name, detail)
+      @fields ||= {}
+      @fields[name.to_sym] = detail
+    end
+
+    def [](index)
+      unless @fields.nil?
+        return @fields[index] || {}
+      end
+      {}
+    end
+
+    def method_missing(m, *args, &block)
+      @fields ||= {}
+      if self.respond_to? m
+        return self.send(m, *args, &block)
+      else
+        # FIXME: This probably is a bad idea. We should get the whole
+        # args
+        @fields[m] = args[0]
+      end
+    end
+
+    def to_hash
+      fields
+    end
+
+
+  end
+end

data/lib/faalis/dashboard/dsl/index.rb

@@ -0,0 +1,24 @@
+require_dependency 'faalis/dashboard/dsl/base'
+
+module Faalis::Dashboard::DSL
+  class Index < Base
+
+    # Allow user to specify an array of model attributes to be used
+    # in respected section. For example attributes to show as header
+    # columns in index section
+    def attributes(*fields_name, **options, &block)
+      if options.include? :except
+        @fields = resolve_model_reflections.reject do |field|
+          options[:except].include? field.to_sym
+        end
+      else
+        # set new value for fields
+        @fields = fields_name.map(&:to_s) unless fields_name.empty?
+      end
+
+      @fields.concat(block.call.map(&:to_s)) if block_given?
+    end
+
+    alias_method :table_fields, :attributes
+  end
+end

data/lib/faalis/dashboard/dsl/update.rb

@@ -0,0 +1,6 @@
+require_dependency 'faalis/dashboard/dsl/base'
+
+module Faalis::Dashboard::DSL
+  class Update < Base
+  end
+end

data/lib/faalis/dashboard/models/sidebar.rb

@@ -0,0 +1,92 @@
+module Faalis::Dashboard::Models
+  class Item
+
+    attr_reader :title, :url, :icon, :model
+    def initialize(title, options)
+      @title = title
+      extract_options(options)
+    end
+
+    private
+      def extract_options(options)
+        options.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+  end
+
+  class Menu < Item
+    def children
+      @children || []
+    end
+
+    def add_child(child)
+      @children ||= []
+      @children << child
+    end
+  end
+
+  class RootMenu < Array
+    alias :add_child :<<
+  end
+
+  class Sidebar
+
+    include ActionView::Helpers::TranslationHelper
+
+    def initialize(title, **options)
+      @title = title
+      extract_options(options)
+      @tree = RootMenu.new
+      @current_node = @tree
+    end
+
+    def children
+      @tree
+    end
+
+    def title
+      @title || I18n.t('faalis.dashboard.sidebar.title')
+    end
+
+    def menu(name, **options, &block)
+      item = Menu.new(name, options)
+
+
+      @current_node.add_child item
+
+      prev_node = @current_node
+      @current_node = item
+
+      block.call if block_given?
+
+      @current_node = prev_node
+    end
+
+    def item(name, **options)
+      item = Item.new(name, options)
+      @current_node.add_child item
+    end
+
+    def faalis_entries
+      menu(t('faalis.dashboard.user_management'),
+           icon: 'fa fa-users',
+           model: 'Faalis::User') do
+        item(I18n.t('faalis.dashboard.users'),
+             model: 'Faalis::User',
+             url: Faalis::Engine.routes.url_helpers.dashboard_auth_users_path)
+
+        item(I18n.t('faalis.dashboard.groups'),
+             model: 'Faalis::Group',
+             url: Faalis::Engine.routes.url_helpers.dashboard_auth_groups_path)
+      end
+    end
+
+    private
+      def extract_options(options)
+        @icon  = options.delete(:icon)
+        @id    = options.delete(:id)
+        @class = options.delete(:class)
+      end
+  end
+end

data/lib/faalis/dashboard/sections/resource.rb

@@ -0,0 +1,165 @@
+module Faalis::Dashboard::Sections
+  module Resource
+
+    extend ActiveSupport::Concern
+
+    def _resource_title
+      t(controller_name.humanize)
+    end
+
+    protected
+
+      def _resources
+        instance_variable_get("@{plural_name")
+      end
+
+      def plural_name
+        controller_name.underscore
+      end
+
+      def model_name
+        controller_path.gsub('dashboard/', '').classify
+      end
+
+      def model
+        "::#{model_name}".constantize
+      rescue
+        msg = "Can't find model '::#{model_name}'. Please override \
+              'model' method in your dashboard controller."
+        fail NameError, msg
+      end
+
+      def namespace
+        pieces = controller_path.gsub('dashboard/', '').split('/')
+        return '' if pieces.length == 1
+        pieces.pop
+        pieces.join('/')
+      end
+
+      def _route_engine
+        if namespace.empty?
+          Rails.application
+        else
+          "#{namespace.split('/')[0]}::Engine".classify.constantize
+        end
+      end
+
+    private
+
+      def _route_name
+        nil
+      end
+
+      def attachment_fields
+        if model.respond_to? :attachment_definitions
+          return model.attachment_definitions.keys
+        end
+
+        []
+      end
+
+      def has_attachment?
+        !attachment_fields.empty?
+      end
+
+      def guess_index_route(scope  = 'dashboard')
+        scope_ = "#{scope}_"
+        "#{scope_}#{controller_name}_path"
+      end
+
+      def guess_show_route(scope  = 'dashboard')
+        scope_        = "#{scope}_"
+        resource_name = controller_name.singularize.underscore
+        "#{scope_}#{resource_name}_path"
+      end
+
+      def guess_edit_route(scope  = 'dashboard')
+        scope_        = "#{scope}_"
+        resource_name = controller_name.singularize.underscore
+        "edit_#{scope_}#{resource_name}_path"
+      end
+
+      def guess_new_route(scope  = 'dashboard')
+        scope_        = "#{scope}_"
+        resource_name = controller_name.singularize.underscore
+        "new_#{scope_}#{resource_name}_path"
+      end
+
+      def guess_edit_route(scope  = 'dashboard')
+        scope_        = "#{scope}_"
+        resource_name = controller_name.singularize.underscore
+        "edit_#{scope_}#{resource_name}_path"
+      end
+
+      def setup_named_routes
+        @engine        = _route_engine
+        @index_route   = guess_index_route
+        @new_route     = guess_new_route
+        @show_route    = guess_show_route
+        @edit_route    = guess_edit_route
+      end
+
+      def successful_response(section, msg = nil)
+        @_msg = msg
+
+        respond_to do |f|
+          if _override_views.include? section.to_sym
+            f.js
+            f.html
+          else
+            flash[:success] = msg
+            path = Rails.application.routes.url_helpers.send(@index_route)
+            # TODO: We really need to put setup routed on top of this method
+            f.js { render "faalis/dashboard/resource/#{section}" }
+            f.html { redirect_to path }
+          end
+        end
+      end
+
+      def errorful_resopnse(section, msg = nil)
+        @_msg = msg
+
+        respond_to do |f|
+          if _override_views.include? section.to_sym
+            f.js { render :errors }
+            f.html { render :errors }
+          else
+            flash[:error] = msg
+            path = Rails.application.routes.url_helpers.send(@index_route)
+            # TODO: We really need to put setup routed on top of this method
+
+            f.js { render 'faalis/shared/errors' }
+            f.html { redirect_to path }
+          end
+        end
+      end
+
+      # TODO: Move this method to a suitable place
+      def symbolify_keys(hash)
+        hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      end
+
+    # The actual DSL for resource ages
+    module ClassMethods
+      # Via this method user can specify the engine or application name
+      # which current resource is defined under. Default value is:
+      # Rails.application
+      def route_engine(name, &block)
+        define_method(:_route_engine) do
+          return block.call if block_given?
+          name
+        end
+      end
+
+      # Via this method user can specify the name of current resource
+      # scope, Default value is `dashboard`
+      def route_scope(name, &block)
+        define_method(:_route_scope) do
+          return block.call if block_given?
+          name
+        end
+      end
+    end
+
+  end
+end

data/lib/faalis/dashboard/sections/resource_create.rb

@@ -0,0 +1,211 @@
+require 'set'
+require_dependency 'faalis/dashboard/dsl/create'
+
+module Faalis::Dashboard::Sections
+  module ResourceCreate
+
+    extend ActiveSupport::Concern
+
+    # The actual action method of a dashboard controller
+    def new
+      authorize model
+      setup_named_routes
+
+      collect_model_fields_for_form
+
+      @resource           = model.new
+      @resource_title     = _resource_title.singularize
+      @_fields_properties = form_properties._field_details
+      @multipart          = has_attachment?
+
+      return if _override_views.include? :new
+      render 'faalis/dashboard/resource/new'
+    end
+
+    def edit
+      # TODO: Handle nested resource in here
+      @resource = model.find(params[:id])
+      authorize @resource
+
+      setup_named_routes
+      collect_model_fields_for_form
+
+      @resource_title     = _resource_title.singularize
+      @_fields_properties = form_properties._field_details
+      @multipart          = has_attachment?
+
+      return if _override_views.include? :edit
+      render 'faalis/dashboard/resource/edit'
+    end
+
+    def update
+      # TODO: Handle nested resource in here
+      @resource = model.find(params[:id])
+      authorize @resource
+
+      setup_named_routes
+      new_params = creation_params
+      new_params.merge(reflections_hash) if reflections_hash
+
+      # TODO: Move this method to a suitable place instead of controller
+      #       itself
+      new_params = symbolify_keys(new_params)
+
+      @resource.assign_attributes(**new_params)
+
+      if @resource.save
+        successful_response(:update)
+      else
+        errorful_resopnse(:update)
+      end
+    end
+
+    # The actual action method for creating new resource.
+    def create
+      authorize model
+      setup_named_routes
+
+      @resource = model.new(creation_params)
+
+      @resource.assign_attributes(**reflections_hash) unless reflections_hash.nil?
+
+      # TODO: Handle M2M relations in here
+
+      if @resource.save
+        successful_response(:create)
+      else
+        errorful_resopnse(:create)
+      end
+    end
+
+    protected
+
+      def collect_model_fields_for_form
+        @_fields ||= form_properties.fields_for_form
+      end
+
+      def reflections_hash
+        # TODO: cach the result using and instance_var or something
+        reflections = model.reflections
+        result      = {}
+
+        reflections.each do |name, column|
+          has_many = ActiveRecord::Reflection::HasManyReflection
+          has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+
+          if !column.is_a?(has_many) && !column.is_a?(has_and_belongs_to_many)
+            value = creation_params[column.foreign_key]
+            result[column.foreign_key.to_sym] = value
+          end
+        end
+
+        return result unless result.empty?
+        nil
+      end
+
+      def creation_params
+        resource = model_name.underscore.to_sym
+
+        # TODO: replace this line with a better solution to not
+        #       allowing the blacklisted fields like id, created_at and ...
+        fields = model.columns_hash.keys.map(&:to_sym)
+        fields.concat(attachment_fields.map(&:to_sym ))
+        fields = Set.new(fields).map(&:to_sym)
+        params.require(resource).permit(*fields)
+      end
+
+    private
+
+      def all_valid_columns_for_form
+        return @all_valid_columns_for_form unless @all_valid_columns_for_form.nil?
+        columns   = model.columns_hash.dup
+        relations = model.reflections
+
+        relations.keys.each do |name|
+          has_many = ActiveRecord::Reflection::HasManyReflection
+          has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+
+          unless relations[name].is_a? has_many
+            if relations[name].is_a? has_and_belongs_to_many
+              columns[name] = Class.new { def self.type() :multiple_select end }
+            else
+              col    = relations[name]
+              column = columns.delete col.foreign_key
+              columns[name] = column
+            end
+          end
+        end
+
+        columns.delete('id')
+        columns.delete('created_at')
+        columns.delete('updated_at')
+
+        @all_valid_columns_for_form = columns
+      end
+
+      def form_properties
+        Faalis::Dashboard::DSL::Create.new(model)
+      end
+
+      def _new_form_fields
+        all_valid_columns_for_form.keys.map(&:to_sym)
+      end
+
+    # The actual DSL for index ages
+    module ClassMethods
+
+      # To specify any property and action for `form` section both new and edit
+      # You must use `in_form` class method with block of properties. For
+      # example:
+      #
+      #   class ExamplesController < Dashboard::Application
+      #     in_form do
+      #       attributes :name, :description
+      #       action_button :close, dashboard_example_close_path
+      #     end
+      #   end
+      def in_form(&block)
+        model = controller_name.classify.constantize
+        form_props = Faalis::Dashboard::DSL::Create.new(model)
+
+        unless block_given?
+          fail ArgumentError, "You have to provide a block for 'in_form'"
+        end
+
+        form_props.instance_eval(&block) if block_given?
+
+        define_method(:form_properties) do
+          return form_props
+        end
+
+        private :form_properties
+      end
+
+      # User can provides the fields that he/she wants to be shown
+      # in the form for resource creation page.
+      # for example:
+      #
+      # class Dashboard::PostsController < Dashboard::ApplicationController
+      #   new_form_fields :title, created_at
+      # end
+      def new_form_fields(*fields, **options)
+        define_method(:_new_form_fields) do
+          fields.map(&:to_sym)
+        end
+
+        private :_new_form_fields
+      end
+
+      def form_fields
+        form = ::Faalis::Dashboard::FormFieldsProperties.new
+        yield form
+
+        define_method(:_form_fields) do
+          form
+        end
+
+        private :_form_fields
+      end
+    end
+  end
+end