releaf-core 0.2.1 → 1.0.3

data/app/lib/releaf/action_controller/features.rb

@@ -0,0 +1,47 @@
+module Releaf::ActionController::Features
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :verify_feature_availability!
+    helper_method :feature_available?
+    rescue_from Releaf::FeatureDisabled, with: :feature_disabled
+  end
+
+  def verify_feature_availability!
+    feature = action_feature(params[:action])
+    raise Releaf::FeatureDisabled, feature.to_s if feature.present? && !feature_available?(feature)
+  end
+
+  def action_feature(action)
+    action_features[action.to_sym]
+  end
+
+  def features
+    [:edit, :create, :create_another, :destroy, :index, :toolbox, :search]
+  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
+    }
+  end
+
+  def feature_disabled(exception)
+    @feature = exception.message
+    respond_with(nil, responder: action_responder(:feature_disabled))
+  end
+
+  def feature_available?(feature)
+    return false if feature.blank?
+    return false if feature == :create_another && !feature_available?(:create)
+    return false if feature == :search && !feature_available?(:index)
+    features.include? feature
+  end
+end

data/app/lib/releaf/action_controller/notifications.rb

@@ -0,0 +1,28 @@
+module Releaf::ActionController::Notifications
+  extend ActiveSupport::Concern
+
+  # 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.
+  #
+  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
+
+  # Returns notice scope name
+  def notice_scope_name
+    'notices.' + controller_scope_name
+  end
+end

data/app/lib/releaf/action_controller/resources.rb

@@ -0,0 +1,59 @@
+module Releaf::ActionController::Resources
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :resource_class,
+
+    # 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
+  end
+
+  def resource_params
+    required_params.permit(*permitted_params)
+  end
+
+  # It sets various instance variables, that are later used in views and # controllers
+  def resources_per_page
+    40
+  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::ResourceParams.new(resource_class).values
+  end
+
+  def new_resource
+    @resource = resource_class.new
+  end
+
+  def load_resource
+    @resource = resource_class.find(params[:id])
+  end
+
+  # Returns true if @resource is assigned (even if it's nil)
+  def resource_given?
+    !!defined? @resource
+  end
+
+  # Return ActiveRecord::Relation used in index
+  #
+  # @return ActiveRecord::Relation
+  def resources
+    resource_class.all
+  end
+
+  # @return class
+  def resource_class
+    @resource_class ||= self.class.resource_class
+  end
+end

data/app/{controllers/concerns/releaf → lib/releaf/action_controller}/richtext_attachments.rb

@@ -1,4 +1,4 @@
-module Releaf::RichtextAttachments
+module Releaf::ActionController::RichtextAttachments
   extend ActiveSupport::Concern
 
   included do

data/app/lib/releaf/action_controller/search.rb

@@ -0,0 +1,22 @@
+module Releaf::ActionController::Search
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :searchable_fields
+  end
+
+  def searchable_fields
+    @searchable_fields ||= Releaf::DefaultSearchableFields.new(resource_class).find
+  end
+
+  def search(text)
+    return unless feature_available?(:search)
+    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::Search
+  end
+end

data/app/lib/releaf/action_controller/urls.rb

@@ -0,0 +1,49 @@
+module Releaf::ActionController::Urls
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :current_path, :index_path
+  end
+
+  # Returns path to redirect after successul resource create/update actions
+  #
+  # @return [String] path
+  def success_path
+    if create_another?
+      url_for(action: :new, only_path: true)
+    else
+      url_for(action: :edit, id: @resource.id, only_path: true, index_path: index_path)
+    end
+  end
+
+  # Returns index path for current request
+  #
+  # @return [String] path
+  def index_path
+    @index_path ||= resolve_index_path
+  end
+
+  def resolve_index_path
+    # use current url
+    if action_name == "index"
+      current_path
+    # use from get params
+    elsif valid_index_path?(params[:index_path])
+      params[:index_path]
+    # fallback to index view
+    else
+      url_for(action: :index, only_path: true)
+    end
+  end
+
+  def valid_index_path?(value)
+    value.present? && value.is_a?(String) && value.first == "/"
+  end
+
+  # Returns current path without internal params
+  #
+  # @return String
+  def current_path
+    @current_path ||= [request.path, (request.query_parameters.to_query if request.query_parameters.present?)].compact.join("?")
+  end
+end

data/app/lib/releaf/action_controller/views.rb

@@ -0,0 +1,29 @@
+module Releaf::ActionController::Views
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :active_view
+  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(name_of_action)
+    action_views[name_of_action.to_sym] || name_of_action
+  end
+
+  # Returns generic view name for current action
+  # @return String
+  def active_view
+    action_view(action_name)
+  end
+end

data/app/lib/releaf/assets_resolver.rb

@@ -0,0 +1,51 @@
+module Releaf
+  class AssetsResolver
+    NONCOMPILED_PATTERN = /(javascripts|stylesheets)\/(controllers\/(.*?))\..*/
+    COMPILED_PATTERN = /controllers\/(.*?)\.(js|css)$/
+    TYPE_EXTENSION_MAP = {
+      "stylesheets" => "css",
+      "javascripts" => "js",
+    }
+
+    def self.base_assets
+      ["releaf/application"]
+    end
+
+    def self.controller_assets(controller, type)
+      asset_path = "controllers/#{controller}.#{TYPE_EXTENSION_MAP[type.to_s]}"
+      base_assets + [assets[asset_path]].compact
+    end
+
+    def self.noncompiled_assets
+      Rails.application.assets.each_file.map do|file|
+        match = file.to_s.match(NONCOMPILED_PATTERN)
+        "#{match[2]}.#{TYPE_EXTENSION_MAP[match[1]]}" if match
+      end.compact
+    end
+
+    def self.compiled_assets
+      Rails.application.assets_manifest.files.map do|_, asset|
+        match = asset["logical_path"].match(COMPILED_PATTERN)
+        asset["logical_path"] if match
+      end.compact.uniq
+    end
+
+    def self.compiled_assets?
+      Rails.application.assets.nil?
+    end
+
+    def self.assets_hash(assets)
+      assets.inject({}) do|hash, asset|
+        hash.update(asset => asset)
+      end
+    end
+
+    def self.assets
+      if compiled_assets?
+        @@compiled_assets ||= assets_hash(compiled_assets)
+      else
+        assets_hash(noncompiled_assets)
+      end
+    end
+  end
+end

data/app/lib/releaf/build_errors_hash.rb

@@ -0,0 +1,81 @@
+module Releaf
+  class BuildErrorsHash
+    include Releaf::Service
+    attribute :resource, Object
+    attribute :field_name_prefix, String
+
+    def call
+      errors.inject({}) do |h, item|
+        field_name = item.delete(:field_name)
+        h[field_name] ||= []
+        h[field_name] << item
+        h
+      end
+    end
+
+    def errors
+      resource.errors.map do |attribute, message|
+        format_error(attribute, message)
+      end.flatten
+    end
+
+    def attribute_error(attribute, message)
+      {
+        field_name: field_name(attribute),
+        error_code: message.error_code,
+        message: message.to_s,
+      }
+    end
+
+    def format_error(attribute, message)
+      if resource_attribute?(attribute)
+        attribute_error(attribute, message)
+      else
+        nested_attribute_errors(attribute)
+      end
+    end
+
+    def nested_attribute_errors(attribute)
+      association_name = attribute.to_s.split('.', 2).first
+      if single_association?(association_name)
+        prefix_template = "#{field_name_prefix}[#{association_name}_attributes]"
+        nested_resources = [resource.send(association_name)]
+      else
+        prefix_template = "#{field_name_prefix}[#{association_name}_attributes][%d]"
+        nested_resources = resource.send(association_name)
+      end
+
+      nested_resources.each_with_index.map do |nested_resource, i|
+        prefix = prefix_template % i
+        self.class.new(resource: nested_resource, field_name_prefix: prefix).errors
+      end
+    end
+
+    def single_association?(association_name)
+      [:belongs_to, :has_one].include? association_type(association_name)
+    end
+
+    def resource_attribute?(attribute)
+      attribute !~ /\./
+    end
+
+    def field_name(attribute)
+      return field_name_prefix if attribute.to_sym == :base
+
+      field = attribute
+      if association(attribute).present?
+        field = association(attribute).foreign_key.to_s
+      end
+
+      "#{field_name_prefix}[#{field}]"
+    end
+
+    def association_type(association_name)
+      association(association_name).macro
+    end
+
+    def association(association_name)
+      resource.class.reflect_on_association(association_name.to_sym)
+    end
+  end
+end

data/app/lib/releaf/controller_definition.rb

@@ -0,0 +1,22 @@
+class Releaf::ControllerDefinition
+  attr_accessor :name, :controller_name
+
+  def self.for(controller_name)
+    Releaf.application.config.controllers[controller_name]
+  end
+
+  def initialize(options)
+    options = {controller: options} if options.is_a? String
+    options[:name] ||= options[:controller]
+    self.name = options[:name]
+    self.controller_name = options[:controller]
+  end
+
+  def localized_name
+    I18n.t(name, scope: "admin.controllers")
+  end
+
+  def path
+    Rails.application.routes.url_helpers.url_for(action: :index, controller: controller_name, only_path: true)
+  end
+end

data/app/lib/releaf/controller_group_definition.rb

@@ -0,0 +1,12 @@
+class Releaf::ControllerGroupDefinition
+  attr_accessor :name, :controllers
+
+  def initialize(options)
+    self.name = options[:name]
+    self.controllers = options[:items].map{|option| Releaf::ControllerDefinition.new(option) }
+  end
+
+  def localized_name
+    I18n.t(name, scope: "admin.controllers")
+  end
+end

data/app/lib/releaf/{core/default_searchable_fields.rb → default_searchable_fields.rb}

@@ -1,4 +1,4 @@
-module Releaf::Core
+module Releaf
   class DefaultSearchableFields
     attr_accessor :klass
 

data/app/lib/releaf/{core/resource_base.rb → resource_base.rb}

@@ -1,4 +1,4 @@
-class Releaf::Core::ResourceBase
+class Releaf::ResourceBase
   attr_accessor :resource_class
 
   def initialize(resource_class)
@@ -14,21 +14,19 @@ class Releaf::Core::ResourceBase
   end
 
   def localized_attributes
-    resource_class.translated_attribute_names.collect { |a| a.to_s }
+    @localized_attributes ||= localized_attributes? ? resource_class.translated_attribute_names.map(&:to_s) : []
   end
 
   def base_attributes
-    resource_class.column_names - excluded_attributes
+    resource_class.column_names
   end
 
   def values(include_associations: true)
-    list = base_attributes
-    list += localized_attributes if localized_attributes?
+    list = base_attributes + localized_attributes - excluded_attributes
     list += associations_attributes if include_associations
     list
   end
 
-
   def associations_attributes
     associations.collect do |association|
       {association.name => association_attributes(association)}
@@ -63,4 +61,14 @@ class Releaf::Core::ResourceBase
   def excluded_associations
     [:translations]
   end
+
+  def self.title(resource)
+    title_methods.each do|method_name|
+      return resource.send(method_name) if resource.respond_to?(method_name)
+    end
+  end
+
+  def self.title_methods
+    [:releaf_title, :name, :title, :to_s]
+  end
 end

data/app/lib/releaf/{core/resource_fields.rb → resource_fields.rb}

@@ -1,4 +1,4 @@
-class Releaf::Core::ResourceFields < Releaf::Core::ResourceBase
+class Releaf::ResourceFields < Releaf::ResourceBase
 
   def excluded_attributes
     super + %w(password password_confirmation encrypted_password)

data/app/lib/releaf/{core/resource_params.rb → resource_params.rb}

@@ -1,4 +1,4 @@
-class Releaf::Core::ResourceParams < Releaf::Core::ResourceBase
+class Releaf::ResourceParams < Releaf::ResourceBase
 
   def file_attributes
     resource_class.dragonfly_attachment_classes.collect{|c| "#{c.attribute}_uid" }
@@ -16,7 +16,7 @@ class Releaf::Core::ResourceParams < Releaf::Core::ResourceBase
   def base_attributes
     super.inject([]) do|list, attribute|
       if file_attribute?(attribute)
-        list += file_attribute_params(attribute)
+        list + file_attribute_params(attribute)
       else
         list << attribute
       end
@@ -25,7 +25,7 @@ class Releaf::Core::ResourceParams < Releaf::Core::ResourceBase
 
   def localized_attributes
     super.inject([]) do |list, column|
-      list += localized_attribute_params(column)
+      list + localized_attribute_params(column)
     end
   end
 

data/app/lib/releaf/resource_table_fields.rb

@@ -0,0 +1,10 @@
+class Releaf::ResourceTableFields < Releaf::ResourceFields
+
+  def excluded_attributes
+    super + table_excluded_attributes
+  end
+
+  def table_excluded_attributes
+    (base_attributes + localized_attributes).select{|c| c.match(/.*(_uid|_html)$/) }
+  end
+end

data/app/lib/releaf/{core/resource_utilities.rb → resource_utilities.rb}

@@ -1,4 +1,4 @@
-class Releaf::Core::ResourceUtilities
+class Releaf::ResourceUtilities
     # Lists relations for @resource with dependent: :restrict_with_exception
     #
     # @return hash of all related objects, who have dependancy :restrict_with_exception
@@ -27,7 +27,7 @@ class Releaf::Core::ResourceUtilities
   # @return controller name
   def self.association_controller(association)
     guessed_name = association.name.to_s.pluralize
-    guessed_name if Releaf.application.config.controllers.values.map { |v| v[:controller] }.grep(/(\/#{guessed_name}$|^#{guessed_name}$)/).present?
+    guessed_name if Releaf.application.config.controllers.values.map { |v| v.controller_name }.grep(/(\/#{guessed_name}$|^#{guessed_name}$)/).present?
   end
 
   def self.destroyable?(resource)

data/app/lib/releaf/{core/responders → responders}/access_denied_responder.rb

@@ -1,6 +1,6 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class AccessDeniedResponder < ActionController::Responder
-    include Releaf::Core::Responders::ErrorResponder
+    include Releaf::Responders::ErrorResponder
 
     def status_code
       403

data/app/lib/releaf/{core/responders → responders}/after_save_responder.rb

@@ -1,9 +1,9 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class AfterSaveResponder < ActionController::Responder
     delegate :render_notification, to: :controller
 
     def json_resource_errors
-      {errors: Releaf::Core::ErrorFormatter.format_errors(resource)}
+      {errors: Releaf::BuildErrorsHash.call(resource: resource, field_name_prefix: :resource)}
     end
 
     def to_json
@@ -12,7 +12,7 @@ module Releaf::Core::Responders
       elsif options[:redirect]
         render json: {url: resource_location}, status: 303
       else
-        redirect_to resource_location, status: 303
+        redirect_to resource_location, status: 303, turbolinks: false
       end
     end
 

data/app/lib/releaf/{core/responders → responders}/confirm_destroy_responder.rb

@@ -1,4 +1,4 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class ConfirmDestroyResponder < ActionController::Responder
     delegate :render_notification, to: :controller
 

data/app/lib/releaf/{core/responders → responders}/destroy_responder.rb

@@ -1,4 +1,4 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class DestroyResponder < ActionController::Responder
     delegate :render_notification, to: :controller
 

data/app/lib/releaf/{core/responders → responders}/error_responder.rb

@@ -1,4 +1,4 @@
-module Releaf::Core::Responders::ErrorResponder
+module Releaf::Responders::ErrorResponder
   def template
     self.class.name.split("::").last.gsub(/Responder$/, "").underscore
   end

data/app/lib/releaf/{core/responders → responders}/feature_disabled_responder.rb

@@ -1,6 +1,6 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class FeatureDisabledResponder < ActionController::Responder
-    include Releaf::Core::Responders::ErrorResponder
+    include Releaf::Responders::ErrorResponder
 
     def status_code
       403

data/app/lib/releaf/{core/responders → responders}/page_not_found_responder.rb

@@ -1,6 +1,6 @@
-module Releaf::Core::Responders
+module Releaf::Responders
   class PageNotFoundResponder < ActionController::Responder
-    include Releaf::Core::Responders::ErrorResponder
+    include Releaf::Responders::ErrorResponder
 
     def status_code
       404

data/app/lib/releaf/responders.rb

@@ -0,0 +1,31 @@
+module Releaf::Responders
+
+  def respond_with(resource = nil, options = {}, &block)
+    options[:responder] = active_responder unless options.has_key? :responder
+    super
+  end
+
+  def action_responders
+    {
+      create: Releaf::Responders::AfterSaveResponder,
+      update: Releaf::Responders::AfterSaveResponder,
+      confirm_destroy: Releaf::Responders::ConfirmDestroyResponder,
+      destroy: Releaf::Responders::DestroyResponder,
+      access_denied: Releaf::Responders::AccessDeniedResponder,
+      feature_disabled: Releaf::Responders::FeatureDisabledResponder,
+      page_not_found: Releaf::Responders::PageNotFoundResponder,
+    }
+  end
+
+  # Returns generic view name for given action
+  # @return String
+  def action_responder(name_of_action)
+    action_responders[name_of_action.to_sym]
+  end
+
+  # Returns generic view name for current action
+  # @return String
+  def active_responder
+    action_responder(action_name)
+  end
+end

data/app/lib/releaf/{core/search.rb → search.rb}

@@ -1,4 +1,4 @@
-module Releaf::Core
+module Releaf
   class Search
     attr_accessor :relation, :fields, :text, :join_index, :searchable_arel_fields