releaf-core 0.2.1

data/app/builders/releaf/builders/tags/releaf_associated_set_field.rb

@@ -0,0 +1,40 @@
+module Releaf::Tags
+  module AssociatedSetField
+    def releaf_associated_set_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+      options = {field: {type: "associated-set"}}.deep_merge(options)
+      content = releaf_associated_set_content(name, input: input, options: options)
+      input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+    end
+
+    def releaf_associated_set_content(name, input: {}, options: {})
+      association_options = options[:association]
+      association = object.send(name)
+      key_field = association_options[:field]
+
+      list = []
+
+      association_options[:items].each_pair do|value, label_text|
+        item = association.find_by(key_field => value) || association.build(key_field => value)
+
+        list << fields_for(name, item, relation_name: name, builder: self.class) do |builder|
+          builder.releaf_associated_set_item(association_options, label_text)
+        end
+      end
+
+      safe_join do
+        list
+      end
+    end
+
+
+    def releaf_associated_set_item(association_options, label_text)
+      wrapper(class: "type-associated-set-item") do
+        [hidden_field(:_destroy, value: object.new_record?, class: "destroy"),
+         check_box(association_options[:field], {class: "keep", name: "keep"}, (object.send(association_options[:field]) if object.persisted?)),
+         label(association_options[:field], label_text),
+         hidden_field(association_options[:field])
+        ]
+      end
+    end
+  end
+end

data/app/builders/releaf/builders/template.rb

@@ -0,0 +1,8 @@
+module Releaf::Builders::Template
+  attr_accessor :template
+
+  def initialize(template)
+    self.template = template
+  end
+
+end

data/app/builders/releaf/builders/toolbox.rb

@@ -0,0 +1,23 @@
+module Releaf::Builders::Toolbox
+  def toolbox(resource, extra_params = {})
+    return '' if resource.new_record?
+
+    url = url_for({action: :toolbox, id: resource.id, context: action_name}.merge(extra_params))
+
+    tag(:div, class: "toolbox", data: {url: url}) do
+      [toolbox_button, toolbox_menu]
+    end
+  end
+
+  def toolbox_menu
+    tag(:menu, class: %w(toolbox-items), type: "toolbar") do
+      [icon("caret-up"), tag(:ul, "")]
+    end
+  end
+
+  def toolbox_button
+    tag(:button, class: %w(button trigger only-icon), type: "button", title: t("Tools")) do
+      icon("ellipsis-v")
+    end
+  end
+end

data/app/builders/releaf/builders/toolbox_builder.rb

@@ -0,0 +1,27 @@
+class Releaf::Builders::ToolboxBuilder
+  include Releaf::Builders::Base
+  include Releaf::Builders::Template
+  include Releaf::Builders::Resource
+
+  def output
+    safe_join do
+      items.map do |item|
+        tag('li', item)
+      end
+    end
+  end
+
+  def items
+    list = []
+    list << destroy_confirmation_link if feature_available? :destroy
+    list
+  end
+
+  def destroy_confirmation_link
+    button(t("Delete"), nil, class: %w(ajaxbox danger), href: destroy_confirmation_url, data: {modal: true})
+  end
+
+  def destroy_confirmation_url
+     url_for(action: :confirm_destroy, id: resource.id, index_url: index_url)
+  end
+end

data/app/builders/releaf/builders/view.rb

@@ -0,0 +1,132 @@
+module Releaf::Builders::View
+  include Releaf::Builders::Base
+  include Releaf::Builders::Template
+
+  def output
+    safe_join do
+      list = []
+      list << header unless dialog?
+      list << section
+    end
+  end
+
+  def dialog?
+    controller.ajax?
+  end
+
+  def dialog_name
+    self.class.name.split("::").last.gsub(/(Dialog)?Builder$/, "").underscore.dasherize
+  end
+
+  def header
+    tag(:header) do
+      [breadcrumbs, flash_notices, header_extras]
+    end
+  end
+
+  def section
+    tag(:section, section_attributes) do
+      section_blocks
+    end
+  end
+
+  def section_attributes
+    attributes = {}
+    attributes[:class] = ["dialog", dialog_name] if dialog?
+    attributes
+  end
+
+  def breadcrumbs
+    breadcrumb_items = template_variable("breadcrumbs")
+    return unless breadcrumb_items.present?
+
+    tag(:nav) do
+      tag(:ul, class: "breadcrumbs") do
+        safe_join do
+          last_item = breadcrumb_items.last
+          breadcrumb_items.each.collect do |item, index|
+            breadcrumb_item(item, item == last_item)
+          end
+        end
+      end
+    end
+  end
+
+  def breadcrumb_item(item, last)
+    content = []
+    if item[:url].present?
+      content << tag(:a, item[:name], href: item[:url])
+    else
+      content << item[:name]
+    end
+
+    content << icon("chevron-right") unless last
+
+    tag(:li) do
+      safe_join{ content }
+    end
+  end
+
+  def flash_notices
+    safe_join do
+      flash.collect{|name, item| flash_item(name, item) }
+    end
+  end
+
+  def flash_item(name, item)
+    tag(:div, class: "flash", 'data-type' => name, :'data-id' => (item.is_a? (Hash)) && (item.has_key? "id") ? item["id"] : nil) do
+      item.is_a?(Hash) ? item["message"] : item
+    end
+  end
+
+  def header_extras; end
+
+  def section_blocks
+    [section_header, section_body, section_footer]
+  end
+
+  def section_header
+    tag(:header) do
+      [tag(:h1, section_header_text), section_header_extras]
+    end
+  end
+
+  def section_header_text; end
+  def section_header_extras; end
+  def section_body; end
+
+  def section_footer
+    tag(:footer, class: section_footer_class) do
+      footer_tools
+    end
+  end
+
+  def section_footer_class
+    :main unless dialog?
+  end
+
+  def footer_tools
+    tag(:div, class: "tools") do
+      footer_blocks
+    end
+  end
+
+  def footer_blocks
+    [footer_primary_block, footer_secondary_block]
+  end
+
+  def footer_primary_block
+    tag(:div, class: "primary") do
+      footer_primary_tools
+    end
+  end
+
+  def footer_secondary_block
+    tag(:div, class: "secondary") do
+      footer_secondary_tools
+    end
+  end
+
+  def footer_primary_tools; end
+  def footer_secondary_tools; end
+end

data/app/builders/releaf/builders.rb

@@ -0,0 +1,38 @@
+class Releaf::Builders
+  def self.builder_class(scopes, type)
+    (scopes + inherited_builder_scopes).each do |scope|
+      builder_class = builder_class_at_scope(scope, type)
+      return builder_class if builder_class
+    end
+
+    raise ArgumentError, "unexisting builder (type: #{type}; scopes: #{scopes.join(", ")})"
+  end
+
+  def self.builder_class_at_scope(scope, type)
+    builder_class_name = "#{scope}::#{type.to_s.camelize}Builder"
+
+    if constant_defined_at_scope?(scope, Object) && constant_defined_at_scope?(builder_class_name, scope.constantize)
+      builder_class_name.constantize
+    end
+  end
+
+  def self.constant_defined_at_scope?(mapping, at)
+    constant_defined = false
+
+    begin
+      constant_defined = at.const_get(mapping).present? && mapping.constantize == at.const_get(mapping)
+    rescue NameError => error
+      raise unless constant_name_error?(error.message, mapping)
+    end
+
+    constant_defined
+  end
+
+  def self.constant_name_error?(error_message, mapping)
+    (error_message =~ /#{mapping}$/).present?
+  end
+
+  def self.inherited_builder_scopes
+    (ancestors.grep(Class) - [Object, BasicObject]).collect{|c| c.name }
+  end
+end

data/app/builders/releaf/core/settings/form_builder.rb

@@ -0,0 +1,21 @@
+module Releaf::Core::Settings
+  class FormBuilder < Releaf::Builders::FormBuilder
+    def field_names
+      [:value]
+    end
+
+    def render_value
+      method_name = "releaf_#{settings_field_type}_field"
+      send(method_name, :value, options: { label: { label_text: settings_field_label_text }})
+    end
+
+    def settings_field_label_text
+      label_text = Releaf::Settings.registry[object.var][:description]
+      label_text.present? ? t(label_text, scope: "settings") : "Value"
+    end
+
+    def settings_field_type
+      Releaf::Settings.registry[object.var].fetch(:type, :text)
+    end
+  end
+end

data/app/builders/releaf/core/settings/table_builder.rb

@@ -0,0 +1,11 @@
+module Releaf::Core::Settings
+  class TableBuilder < Releaf::Builders::TableBuilder
+    def column_names
+      [:var, :value, :updated_at]
+    end
+
+    def value_content(resource)
+      resource.value.to_s
+    end
+  end
+end

data/app/controllers/concerns/releaf/breadcrumbs.rb

@@ -0,0 +1,42 @@
+module Releaf
+  module Breadcrumbs
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :build_breadcrumbs
+    end
+
+    def build_breadcrumbs
+      @breadcrumbs = [home_breadcrumb, controller_breadcrumb].compact
+    end
+
+    def home_breadcrumb
+       { name: I18n.t('Home', scope: 'admin.breadcrumbs'), url: releaf_root_path }
+    end
+
+    def controller_breadcrumb
+      controller_params = Releaf.application.config.controllers[self.class.name.sub(/Controller$/, '').underscore]
+      if controller_params
+        {
+          name: I18n.t(controller_params[:name], scope: "admin.controllers"),
+          url: send("#{controller_params[:url_helper]}_path")
+        }
+      end
+    end
+
+    def add_resource_breadcrumb resource, url = nil
+      if resource.new_record?
+        name=  I18n.t('New record', scope: 'admin.breadcrumbs')
+        url = url_for(action: :new, only_path: true) if url.nil?
+      else
+        if resource.respond_to?(:to_text)
+          name = resource.send(:to_text)
+        else
+          name = I18n.t('Edit record', scope: 'admin.breadcrumbs')
+        end
+        url = url_for(action: :edit, id: resource.id, only_path: true) if url.nil?
+      end
+      @breadcrumbs << { name: name, url: url }
+    end
+  end
+end

data/app/controllers/concerns/releaf/richtext_attachments.rb

@@ -0,0 +1,20 @@
+module Releaf::RichtextAttachments
+  extend ActiveSupport::Concern
+
+  included do
+    skip_before_action :verify_authenticity_token, only: [:create_releaf_richtext_attachment]
+  end
+
+  def releaf_richtext_attachment_upload_url
+    begin
+      url_for(action: :create_releaf_richtext_attachment)
+    rescue ::ActionController::UrlGenerationError
+      nil
+    end
+  end
+
+  def create_releaf_richtext_attachment
+    return unless params[:upload]
+    @resource = Releaf::RichtextAttachment.create!(file_type: params[:upload].content_type, file: params[:upload])
+  end
+end

data/app/controllers/releaf/base_controller.rb

@@ -0,0 +1,458 @@
+module Releaf
+  class FeatureDisabled < StandardError; end
+
+  class BaseController < ActionController::Base
+    respond_to :html
+    respond_to :json, only: [:create, :update]
+    protect_from_forgery
+    include Releaf.application.config.access_control_module
+    include Releaf::Breadcrumbs
+    include Releaf::RichtextAttachments
+    include Releaf::Core::Responders
+
+    before_filter :manage_ajax, :setup, :verify_feature_availability!
+
+    rescue_from Releaf::Core::AccessDenied, with: :access_denied
+    rescue_from Releaf::FeatureDisabled, with: :feature_disabled
+
+    layout :layout
+
+    helper_method \
+      :form_options,
+      :table_options,
+      :ajax?,
+      :controller_scope_name,
+      :current_url,
+      :active_view,
+      :index_url,
+      :page_title,
+      :resource_class,
+      :feature_available?,
+      :builder_class,
+      :searchable_fields
+
+    def search(text)
+      return if text.blank?
+      return if searchable_fields.blank?
+      @collection = searcher_class.prepare(relation: @collection, fields: searchable_fields, text: text)
+    end
+
+    def searcher_class
+      Releaf::Core::Search
+    end
+
+    def index
+      prepare_index
+      respond_with(@collection)
+    end
+
+    def new
+      prepare_new
+      respond_with(@resource)
+    end
+
+    def show
+      if feature_available?(:show)
+        prepare_show
+      else
+        redirect_to url_for(action: 'edit', id: params[:id])
+      end
+    end
+
+    def edit
+      prepare_edit
+      respond_with(@resource)
+    end
+
+    def create
+      prepare_create
+      @resource.save
+      respond_with(@resource, location: (success_url if @resource.persisted?), redirect: true)
+    end
+
+    def update
+      prepare_update
+      @resource.update_attributes(resource_params)
+      respond_with(@resource, location: success_url)
+    end
+
+    def confirm_destroy
+      prepare_destroy
+      @restricted_relations = Releaf::Core::ResourceUtilities.restricted_relations(@resource)
+      respond_with(@resource, destroyable: destroyable?)
+    end
+
+    def toolbox
+      prepare_toolbox
+      respond_with(@resource)
+    end
+
+    def destroy
+      prepare_destroy
+      @resource.destroy if destroyable?
+      respond_with(@resource, location: index_url)
+    end
+
+    # Check if @resource has existing restrict relation and it can be deleted
+    #
+    # @return boolean true or false
+    def destroyable?
+      Releaf::Core::ResourceUtilities.destroyable?(@resource)
+    end
+
+    # Helper methods ##############################################################################
+
+    # Returns current url without internal params
+    #
+    # @return String
+    def current_url
+      @current_url ||= [request.path, (request.query_parameters.to_query if request.query_parameters.present?)].compact.join("?")
+    end
+
+    # Returns index url for current request
+    #
+    # @return String
+    def index_url
+      if @index_url.nil?
+        # use current url
+        if action_name == "index"
+          @index_url = current_url
+        # use from get params
+        elsif params[:index_url].present?
+          @index_url = params[:index_url]
+        # fallback to index view
+        else
+          @index_url = url_for(action: 'index')
+        end
+      end
+
+      @index_url
+    end
+
+    # Tries to return resource class.
+    #
+    # If it fails to return proper resource class for your controller, or your
+    # controllers name has no relation to resource class name, then simply
+    # override this method to return class that you want.
+    #
+    # @return class
+    def self.resource_class
+      self.name.split('::', 2).last.sub(/Controller$/, '').classify.constantize
+    end
+
+    # Tries to return resource class.
+    #
+    # If it fails to return proper resource class for your controller, or your
+    # controllers name has no relation to resource class name, then simply
+    # override this method to return class that you want.
+    #
+    # @return class
+    def resource_class
+      @resource_class ||= self.class.resource_class
+    end
+
+    # Returns action > view translation hash
+    # @return Hash
+    def action_views
+      {
+        new: :edit,
+        update: :edit,
+        create: :edit,
+      }
+    end
+
+    # Returns generic view name for given action
+    # @return String
+    def action_view(_action_name)
+      action_views[_action_name.to_sym] || _action_name
+    end
+
+    # Returns generic view name for current action
+    # @return String
+    def active_view
+      action_view(action_name)
+    end
+
+    def form_url(form_type, object)
+      url_for(action: object.new_record? ? 'create' : 'update', id: object.id)
+    end
+
+    def form_attributes(form_type, object, object_name)
+      action = object.respond_to?(:persisted?) && object.persisted? ? :edit : :new
+      action_object_name = "#{action}-#{object_name}"
+      classes = [ action_object_name ]
+      classes << "has-error" if object.errors.any?
+      {
+        multipart: true,
+        id: action_object_name,
+        class: classes,
+        data: {
+          "remote" => true,
+          "remote-validation" => true,
+          "type" => :json,
+        },
+        novalidate: ''
+      }
+    end
+
+
+
+    def builder_class(builder_type)
+      Releaf::Builders.builder_class(builder_scopes, builder_type)
+    end
+
+    def application_builder_scope
+      [application_scope, "Builders"].reject(&:blank?).join("::")
+    end
+
+    def application_scope
+      scope = Releaf.application.config.mount_location.capitalize
+      scope if scope.present? && Releaf::Builders.constant_defined_at_scope?(scope, Object)
+    end
+
+    def builder_scopes
+      [self.class.name.gsub(/Controller$/, ""), application_builder_scope]
+    end
+
+    def form_options(form_type, object, object_name)
+      {
+        builder: builder_class(:form),
+        as: object_name,
+        url: form_url(form_type, object),
+        html: form_attributes(form_type, object, object_name)
+      }
+    end
+
+    def table_options
+      {
+        builder: builder_class(:table),
+        toolbox: feature_available?(:toolbox)
+      }
+    end
+
+    # return contoller translation scope name for using
+    # with I18.translation call within hash params
+    # ex. t("save", scope: controller_scope_name)
+    def controller_scope_name
+      @controller_scope_name ||= 'admin.' + self.class.name.sub(/Controller$/, '').underscore.gsub('/', '_')
+    end
+
+    def feature_available? feature
+      @features[feature].present?
+    end
+
+    def page_title
+      I18n.t(params[:controller], scope: "admin.controllers") + " - " + Rails.application.class.parent_name
+    end
+
+    def render_notification(status, success_message_key: "#{params[:action]} succeeded", failure_message_key: "#{params[:action]} failed", now: false)
+      if now == true
+        flash_target = flash.now
+      else
+        flash_target = flash
+      end
+
+      if status
+        flash_target["success"] = { "id" => "resource_status", "message" => I18n.t(success_message_key, scope: notice_scope_name) }
+      else
+        flash_target["error"] = { "id" => "resource_status", "message" => I18n.t(failure_message_key, scope: notice_scope_name) }
+      end
+    end
+
+    def prepare_index
+      # load resource only if they are not loaded yet
+      @collection = resources unless collection_given?
+
+      search(params[:search])
+
+      unless @resources_per_page.nil?
+        @collection = @collection.page( params[:page] ).per_page( @resources_per_page )
+      end
+    end
+
+    def prepare_new
+      # load resource only if is not initialized yet
+      new_resource unless resource_given?
+      add_resource_breadcrumb(@resource)
+    end
+
+    def prepare_create
+      # load resource only if is not initialized yet
+      new_resource unless resource_given?
+      @resource.assign_attributes(resource_params)
+    end
+
+    def prepare_show
+      prepare_resource_view
+    end
+
+    def prepare_edit
+      prepare_resource_view
+    end
+
+    def prepare_resource_view
+      # load resource only if is not loaded yet
+      load_resource unless resource_given?
+      add_resource_breadcrumb(@resource)
+    end
+
+    def prepare_update
+      # load resource only if is not loaded yet
+      load_resource unless resource_given?
+    end
+
+    def prepare_destroy
+      load_resource
+    end
+
+    def prepare_toolbox
+      load_resource
+    end
+
+    def new_resource
+      @resource = resource_class.new
+    end
+
+    def load_resource
+      @resource = resource_class.find(params[:id])
+    end
+
+    def verify_feature_availability!
+      feature = action_feature(params[:action])
+      raise FeatureDisabled, feature.to_s if (feature.present? && !feature_available?(feature))
+    end
+
+    def action_feature action
+      action_features[action]
+    end
+
+    def action_features
+      {
+        index: :index,
+        new: :create,
+        create: :create,
+        show: (feature_available?(:show) ? :show : :edit),
+        edit: :edit,
+        update: :edit,
+        confirm_destroy: :destroy,
+        destroy: :destroy
+      }.with_indifferent_access
+    end
+
+    # Returns true if @resource is assigned (even if it's nil)
+    def resource_given?
+      !!defined? @resource
+    end
+
+    # Returns true if @collection is assigned (even if it's nil)
+    def collection_given?
+      !!defined? @collection
+    end
+
+    # Returns notice scope name
+    def notice_scope_name
+      'notices.' + controller_scope_name
+    end
+
+    # Return ActiveRecord::Relation used in index
+    #
+    # @return ActiveRecord::Relation
+    def resources
+      resource_class.all
+    end
+
+    def required_params
+      params.require(:resource)
+    end
+
+    # Called before each request by before_filter.
+    # It sets various instance variables, that are later used in views and # controllers
+    #
+    # == Defines
+    # @features::
+    #   Hash with symbol keys and boolean values. Each key represents action
+    #   (currently only `:edit`, `:create`, `:destroy` are supported). If one
+    #   of features is disabled, then routing to it will raise <tt>Releaf::FeatureDisabled</tt>
+    #   error
+    #
+    # @resources_per_page::
+    #   Integer - sets the number of resources to display on `#index` view
+    #
+    # To change controller settings `setup` method should be overriden like this
+    #
+    # @example
+    #   def setup
+    #     super
+    #     @features[:edit] = false
+    #     @resources_per_page = 20
+    #   end
+    def setup
+      @features = {
+        show:              false,
+        edit:              true,
+        create:            true,
+        create_another:    true,
+        destroy:           true,
+        index:             true,
+        toolbox:           true
+      }
+      @panel_layout = true
+      @resources_per_page = 40
+    end
+
+    def searchable_fields
+      @searchable_fields ||= Releaf::Core::DefaultSearchableFields.new(resource_class).find
+    end
+
+    def resource_params
+      required_params.permit(*permitted_params)
+    end
+
+    # Returns which resource attributes can be updated with mass assignment.
+    #
+    # The resulting array will be passed to strong_parameters ``permit``
+    def permitted_params
+      Releaf::Core::ResourceParams.new(resource_class).values
+    end
+
+    # Returns url to redirect after successul resource create/update actions
+    #
+    # @return [String] url
+    def success_url
+      if create_another?
+        url_for(action: 'new')
+      else
+        url_for(action: 'edit', id: @resource.id, index_url: index_url)
+      end
+    end
+
+    def create_another?
+      params[:after_save] == "create_another" && feature_available?(:create_another)
+    end
+
+    def feature_disabled exception
+      @feature = exception.message
+      respond_with(nil, responder: action_responder(:feature_disabled))
+    end
+
+    def access_denied
+      respond_with(nil, responder: action_responder(:access_denied))
+    end
+
+    def ajax?
+      @_ajax || false
+    end
+
+    def layout
+      ajax? ? false : "releaf/admin"
+    end
+
+    def manage_ajax
+      @_ajax = params.has_key? :ajax
+      if @_ajax
+        request.query_parameters.delete(:ajax)
+        params.delete(:ajax)
+      end
+    end
+  end
+end