releaf-core 0.2.1 → 1.0.3

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

@@ -1,7 +1,6 @@
 class Releaf::Builders::TableBuilder
   include Releaf::Builders::Base
   include Releaf::Builders::Toolbox
-  include Releaf::Builders::Orderer
   attr_accessor :collection, :options, :template, :resource_class
 
   def initialize(collection, resource_class, template, options)
@@ -12,7 +11,7 @@ class Releaf::Builders::TableBuilder
   end
 
   def column_names
-    Releaf::Core::ResourceTableFields.new(resource_class).values(include_associations: false)
+    Releaf::ResourceTableFields.new(resource_class).values(include_associations: false)
   end
 
   def columns
@@ -57,7 +56,7 @@ class Releaf::Builders::TableBuilder
     tag(:thead) do
       tag(:tr) do
         content = ActiveSupport::SafeBuffer.new
-        columns.each_pair do|column, options|
+        columns.each_pair do|column, _options|
           content << head_cell(column)
         end
         content
@@ -73,8 +72,8 @@ class Releaf::Builders::TableBuilder
 
   def head_cell_content(column)
     unless column.to_sym == :toolbox
-      attribute = column.to_s.gsub(".", "_")
-      resource_class.human_attribute_name(attribute, create_default: false)
+      attribute = column.to_s.tr(".", "_")
+      resource_class.human_attribute_name(attribute)
     end
   end
 
@@ -98,14 +97,14 @@ class Releaf::Builders::TableBuilder
 
   def row_url(resource)
     resource_action = row_url_action(resource)
-    url_for(action: resource_action, id: resource.id, index_url: index_url) if resource_action
+    url_for(action: resource_action, id: resource.id, index_path: index_path) if resource_action
   end
 
-  def row_url_action(resource)
+  def row_url_action(_resource)
     if feature_available?(:show)
-      resource_action = :show
+      :show
     elsif feature_available?(:edit)
-      resource_action = :edit
+      :edit
     end
   end
 
@@ -148,11 +147,7 @@ class Releaf::Builders::TableBuilder
 
   def format_string_content(resource, column)
     value = column_value(resource, column)
-    if value.respond_to? :to_text
-      value.to_text
-    else
-      value.to_s
-    end
+    resource_title(value)
   end
 
   def format_boolean_content(resource, column)
@@ -169,13 +164,6 @@ class Releaf::Builders::TableBuilder
     I18n.l(value, format: :default, default: '%Y-%m-%d %H:%M:%S') unless value.nil?
   end
 
-  def format_image_content(resource, column)
-    if resource.send(column).present?
-      association_name = column.to_s.sub(/_uid$/, '')
-      image_tag(resource.send(association_name).thumb('x16').url, alt: '')
-    end
-  end
-
   def format_association_content(resource, column)
     format_string_content(resource, association_name(column))
   end
@@ -213,8 +201,14 @@ class Releaf::Builders::TableBuilder
 
   def column_type_format_method(column)
     klass = column_klass(resource_class, column)
+    type = column_type(klass, column)
+
+    type_format_method(type)
+  end
+
+  def type_format_method(type)
+    format_method = "format_#{type}_content".to_sym
 
-    format_method = "format_#{column_type(klass, column)}_content".to_sym
     if respond_to?(format_method)
       format_method
     else
@@ -242,23 +236,17 @@ class Releaf::Builders::TableBuilder
   def cell_format_method(column)
     if association_column?(column)
       :format_association_content
-    elsif image_column?(column)
-      :format_image_content
     else
       column_type_format_method(column)
     end
   end
 
-  def image_column?(column)
-    column =~ /(thumbnail|image|photo|picture|avatar|logo|icon)_uid$/
-  end
-
   def association_column?(column)
     !!(column =~ /_id$/) && resource_class.reflections[association_name(column).to_s].present?
   end
 
   def toolbox_cell(resource, options)
-    toolbox_args = {index_url: controller.index_url}.merge(options.fetch(:toolbox, {}))
+    toolbox_args = {index_path: index_path}.merge(options.fetch(:toolbox, {}))
     tag(:td, class: "only-icon toolbox-cell") do
       toolbox(resource, toolbox_args)
     end
@@ -269,7 +257,9 @@ class Releaf::Builders::TableBuilder
 
     tag(:td) do
       if options[:url].blank?
-        content
+        tag(:span) do
+          content
+        end
       else
         tag(:a, href: options[:url]) do
           content

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

@@ -22,6 +22,6 @@ class Releaf::Builders::ToolboxBuilder
   end
 
   def destroy_confirmation_url
-     url_for(action: :confirm_destroy, id: resource.id, index_url: index_url)
+     url_for(action: :confirm_destroy, id: resource.id, index_path: index_path)
   end
 end

data/app/builders/releaf/builders/utilities/date_fields.rb

@@ -0,0 +1,100 @@
+module Releaf::Builders::Utilities
+  class DateFields
+    RUBY_TO_JQUERY_DATE_FORMAT_MAP = {
+      '-d' => 'd',
+      '-j' => 'o',
+      '-m' => 'm',
+      '3N' => 'l',
+      ':z' => 'Z',
+      'B' => 'MM',
+      'D' => 'mm/dd/y',
+      'F' => 'yy-mm-dd',
+      'H' => 'HH',
+      'I' => 'h',
+      'L' => 'l',
+      'M' => 'mm',
+      'P' => 'tt',
+      'R' => 'HH:mm',
+      'S' => 'ss',
+      'T' => 'HH:mm:ss',
+      'X' => 'HH:mm:ss',
+      'Y' => 'yy',
+      '_m' => 'm',
+      'b' => 'M',
+      'c' => 'M d HH:mm:ss yy', # not exact translation
+      'd' => 'dd',
+      'e' => 'd',
+      'h' => 'M',
+      'j' => 'oo',
+      'k' => 'H',
+      'l' => 'hh',
+      'm' => 'mm',
+      'p' => 'TT',
+      'r' => 'h:mm:ss TT',
+      's' => '@',
+      'x' => 'mm/dd/y',
+      'y' => 'y'
+    }
+
+    # converts date format used by ruby to dateformat used by jquery (when possible)
+    #
+    # references:
+    #   http://www.ruby-doc.org/core-2.0/Time.html#strftime-method
+    #   http://api.jqueryui.com/datepicker/#utility-formatDate
+    #   http://trentrichardson.com/examples/timepicker/#tp-formatting
+    def self.jquery_date_format(ruby_date_format)
+      ruby_date_format.gsub(ruby_date_format_regexp) do |match|
+        RUBY_TO_JQUERY_DATE_FORMAT_MAP[match[1..-1]]
+      end
+    end
+
+    def self.ruby_date_format_regexp
+      @@jquery_date_replacement_regexp ||= Regexp.new("%(#{RUBY_TO_JQUERY_DATE_FORMAT_MAP.keys.join('|')})")
+    end
+
+    def self.normalize_date_or_time_value(value, type)
+      case type
+      when :date
+        value.to_date
+      when :datetime
+        value.to_datetime
+      when :time
+        value.to_time
+      end
+    end
+
+    def self.format_date_or_time_value(value, type)
+      return value if value.nil?
+
+      default_format = date_or_time_default_format(type)
+      value = normalize_date_or_time_value(value, type)
+
+      if type == :time
+        value.strftime(default_format)
+      else
+        I18n.l(value, default: default_format)
+      end
+    end
+
+    def self.time_format_for_jquery
+      format = date_or_time_default_format(:time)
+      jquery_date_format(format)
+    end
+
+    def self.date_format_for_jquery
+      format = date_or_time_default_format(:date)
+      jquery_date_format(I18n.t("default", scope: "date.formats", default: format))
+    end
+
+    def self.date_or_time_default_format(type)
+      case type
+      when :date
+        "%Y-%m-%d"
+      when :datetime
+        "%Y-%m-%d %H:%M"
+      when :time
+        "%H:%M"
+      end
+    end
+  end
+end

data/app/builders/releaf/builders/utilities/resolve_attribute_field_method_name.rb

@@ -0,0 +1,80 @@
+module Releaf::Builders::Utilities
+  class ResolveAttributeFieldMethodName
+    include Releaf::Service
+    attribute :object, Object
+    attribute :attribute_name, String
+
+    FIELD_TYPE_RESOLVERS = {
+      string: [:image, :file, :password, :email, :link, :text],
+      text: [:link, :richtext, :textarea],
+      integer: [:item],
+      datetime: [],
+      date: [],
+      time: [],
+      float: [],
+      decimal: [],
+      boolean: [],
+    }
+
+    def call
+      "releaf_#{field_type}_#{"i18n_" if localized_attribute?}field"
+    end
+
+    def field_type
+      column_field_type_resolvers.find{|resolver_name| send("#{resolver_name}?") == true } || column_type
+    end
+
+    def column_type
+      @column_type ||= columns_class.columns_hash[attribute_name] ? columns_class.columns_hash[attribute_name].type : :string
+    end
+
+    def columns_class
+      localized_attribute? ? object.class::Translation : object.class
+    end
+
+    def localized_attribute?
+      @localized_attribute ||= (object.class.respond_to?(:translates?) && object.class.translates? &&
+                                object.class.translated_attribute_names.include?(attribute_name.to_sym))
+    end
+
+    def column_field_type_resolvers
+      FIELD_TYPE_RESOLVERS[column_type]
+    end
+
+    def image?
+      attribute_name.match(/(thumbnail|image|photo|picture|avatar|logo|banner|icon)_uid$/).present? && file?
+    end
+
+    def file?
+      attribute_name.match(/_uid$/).present? && object.respond_to?(attribute_name.sub(/_uid$/, ''))
+    end
+
+    def password?
+      attribute_name.match(/(password|^pin$)/).present?
+    end
+
+    def email?
+      attribute_name.match(/(_email$|^email$)/).present?
+    end
+
+    def link?
+      attribute_name.match(/(_url$|_link$|^url$|^link$)/).present?
+    end
+
+    def richtext?
+      attribute_name.match(/(_html$|^html$)/).present?
+    end
+
+    def textarea?
+      column_type == :text
+    end
+
+    def text?
+      column_type == :string
+    end
+
+    def item?
+      attribute_name.match(/_id$/).present? && object.class.reflect_on_association(attribute_name[0..-4].to_sym).present?
+    end
+  end
+end

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

@@ -44,7 +44,7 @@ module Releaf::Builders::View
       tag(:ul, class: "breadcrumbs") do
         safe_join do
           last_item = breadcrumb_items.last
-          breadcrumb_items.each.collect do |item, index|
+          breadcrumb_items.each.collect do |item, _index|
             breadcrumb_item(item, item == last_item)
           end
         end
@@ -74,7 +74,10 @@ module Releaf::Builders::View
   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_data = {type: name}
+    item_data[:id] = item["id"] if item.is_a?(Hash)
+
+    tag(:div, class: "flash", data: item_data) do
       item.is_a?(Hash) ? item["message"] : item
     end
   end

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

@@ -0,0 +1,18 @@
+class Releaf::Settings::FormBuilder < Releaf::Builders::FormBuilder
+  def field_names
+    [:value]
+  end
+
+  def render_value
+    send(value_render_method_name, :value, options: { label: { label_text: value_label_text }})
+  end
+
+  def value_render_method_name
+    "releaf_#{object.input_type}_field"
+  end
+
+  def value_label_text
+    label_text = object.description
+    label_text.present? ? t(label_text, scope: "settings") : translate_attribute(:value)
+  end
+end

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

@@ -0,0 +1,9 @@
+class Releaf::Settings::TableBuilder < Releaf::Builders::TableBuilder
+  def column_names
+    [:var, :value, :updated_at]
+  end
+
+  def value_content(resource)
+    send(type_format_method(resource.input_type), resource, :value)
+  end
+end

data/app/controllers/releaf/action_controller.rb

@@ -0,0 +1,174 @@
+class Releaf::ActionController < ActionController::Base
+  # must be first other in stange way non-text env will
+  # have CSRF on richtext attachment upload
+  protect_from_forgery
+
+  include Releaf::ActionController::Notifications
+  include Releaf::ActionController::Resources
+  include Releaf::ActionController::Builders
+  include Releaf::ActionController::Search
+  include Releaf::ActionController::Features
+  include Releaf::ActionController::Ajax
+  include Releaf::ActionController::Urls
+  include Releaf::ActionController::Breadcrumbs
+  include Releaf::ActionController::RichtextAttachments
+  include Releaf::ActionController::Views
+  include Releaf::Responders
+
+  helper_method :controller_scope_name, :page_title
+  rescue_from Releaf::AccessDenied, with: :access_denied
+
+  respond_to :html
+  respond_to :json, only: [:create, :update]
+  layout :layout
+
+  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_path if @resource.persisted?), redirect: true)
+  end
+
+  def update
+    prepare_update
+    @resource.update_attributes(resource_params)
+    respond_with(@resource, location: success_path)
+  end
+
+  def confirm_destroy
+    prepare_destroy
+    @restricted_relations = Releaf::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_path)
+  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
+
+  # Returns true if @collection is assigned (even if it's nil)
+  def collection_given?
+    !!defined? @collection
+  end
+
+  def required_params
+    params.require(:resource)
+  end
+
+  def create_another?
+    params[:after_save] == "create_another" && feature_available?(:create_another)
+  end
+
+  def access_denied
+    respond_with(nil, responder: action_responder(:access_denied))
+  end
+
+  # Check if @resource has existing restrict relation and it can be deleted
+  #
+  # @return boolean true or false
+  def destroyable?
+    Releaf::ResourceUtilities.destroyable?(@resource)
+  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.tr('/', '_')
+  end
+
+  def page_title
+    title = Rails.application.class.parent_name
+    title = "#{definition.localized_name} - #{title}" if definition
+
+    title
+  end
+
+  def short_name
+    self.class.name.sub(/Controller$/, "").underscore
+  end
+
+  def definition
+    Releaf::ControllerDefinition.for(short_name)
+  end
+
+  ActiveSupport.run_load_hooks(:base_controller, self)
+end

data/app/controllers/releaf/{core/errors_controller.rb → errors_controller.rb}

@@ -1,4 +1,4 @@
-class Releaf::Core::ErrorsController < Releaf::BaseController
+class Releaf::ErrorsController < Releaf::ActionController
   def page_not_found
     respond_with(nil, responder: action_responder(:page_not_found))
   end

data/app/controllers/releaf/root_controller.rb

@@ -0,0 +1,23 @@
+class Releaf::RootController < Releaf::ActionController
+  def home
+    respond_to do |format|
+      format.html do
+        redirect_to Releaf.application.config.root.default_controller_resolver.call(current_controller: self)
+      end
+    end
+  end
+
+  # Store settings for menu collapsing and others
+  def store_settings
+    if params[:settings].is_a? Hash
+      params[:settings].each_pair do|key, value|
+        value = false if value == "false"
+        value = true if value == "true"
+        Releaf.application.config.settings_manager.write(controller: self, key: key, value: value)
+      end
+      render nothing: true, status: 200
+    else
+      render nothing: true, status: 422
+    end
+  end
+end

data/app/controllers/releaf/settings_controller.rb

@@ -0,0 +1,22 @@
+class Releaf::SettingsController < Releaf::ActionController
+
+  def self.resource_class
+    Releaf::Settings
+  end
+
+  def resources
+    resource_class.registered
+  end
+
+  def searchable_fields
+    [:var, :value]
+  end
+
+  def resource_params
+    {value: Releaf::Settings::NormalizeValue.call(value: super.fetch(:value, nil), input_type: @resource.input_type)}
+  end
+
+  def features
+    [:index, :edit, :search]
+  end
+end

data/app/helpers/releaf/application_helper.rb

@@ -30,7 +30,7 @@ module Releaf
 
       container.each do|element|
         text, value = i18n_option_text_and_value(element).map { |item| item.to_s }
-        text = I18n.t("#{prefix.to_s}-#{text}", i18n_options.merge(default: text))
+        text = I18n.t("#{prefix}-#{text}", i18n_options.merge(default: text))
         translated_container << [text, value]
       end
 

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

@@ -0,0 +1,24 @@
+module Releaf::ActionController::Ajax
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :ajax?
+    before_action :manage_ajax
+  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

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

@@ -0,0 +1,26 @@
+module Releaf::ActionController::Breadcrumbs
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :build_breadcrumbs
+  end
+
+  def build_breadcrumbs
+    @breadcrumbs = [controller_breadcrumb].compact
+  end
+
+  def controller_breadcrumb
+    {name: definition.localized_name, url: definition.path} if definition
+  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
+      name = Releaf::ResourceBase.title(resource)
+      url = url_for(action: :edit, id: resource.id, only_path: true) if url.nil?
+    end
+    @breadcrumbs << { name: name, url: url }
+  end
+end

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

@@ -0,0 +1,34 @@
+module Releaf::ActionController::Builders
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :builder_class
+
+    def self.own_builder_scope
+      name.gsub(/Controller$/, "")
+    end
+
+    def self.ancestor_controllers
+      # return all ancestor controllers up to but not including Releaf::ActionController
+      ancestor_classes = ancestors - included_modules
+      ancestor_classes.slice( 0...ancestor_classes.index(Releaf::ActionController) ) - [ self ]
+    end
+
+    def self.ancestor_builder_scopes
+      ancestor_controllers.map(&:own_builder_scope)
+    end
+  end
+
+  def builder_class(builder_type)
+    Releaf::Builders.builder_class(builder_scopes, builder_type)
+  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.own_builder_scope, self.class.ancestor_builder_scopes, application_scope].flatten
+  end
+end