releaf-core 0.2.1

data/app/builders/releaf/builders/pagination_builder.rb

@@ -0,0 +1,107 @@
+class Releaf::Builders::PaginationBuilder
+  include Releaf::Builders::Base
+  include Releaf::Builders::Template
+
+  attr_accessor :collection
+  attr_accessor :params
+
+  delegate :total_pages, :current_page, :total_entries, :per_page, to: :collection
+
+  def initialize( template, options = {} )
+    self.collection = options[:collection]
+    self.params     = options[:params]
+    super template
+  end
+
+  def output
+    return nil unless collection.total_pages > 1
+    pagination_block
+  end
+
+  def pagination_block
+    content_tag( :div, class: :pagination ) do
+      safe_join { pagination_parts }
+    end
+  end
+
+  def pagination_parts
+    [
+      previous_page_button,
+      pagination_select,
+      next_page_button
+    ]
+  end
+
+  def previous_page_button
+    page_button( -1, 'previous', 'chevron-left' )
+  end
+
+  def next_page_button
+    page_button( 1, 'next', 'chevron-right' )
+  end
+
+  def page_button( offset, class_name, icon_name )
+    attributes =
+    {
+      class: ['secondary', class_name ],
+      title: t( "#{class_name.capitalize} page", scope: 'pagination')
+    }
+
+    page_number = relative_page_number( offset )
+
+    if page_number.present?
+      attributes[:rel]  = relative_page_relationship(offset)
+      attributes[:href] = page_url(page_number)
+    else
+      attributes[:disabled] = true
+    end
+
+    button( nil, icon_name, attributes )
+  end
+
+  def page_numbers
+    (1..total_pages).to_a
+  end
+
+  def relative_page_number( offset )
+    page_number = current_page + offset
+    page_numbers.include?(page_number) ? page_number : nil
+  end
+
+  def relative_page_relationship(offset)
+    if offset == -1
+      :prev
+    elsif offset == 1
+      :next
+    else
+      nil
+    end
+  end
+
+  def page_url(page_number)
+    template.url_for( params.merge( page: page_number ))
+  end
+
+  def pagination_select
+    content_tag('select', name: :page) do
+      safe_join do
+        pagination_options
+      end
+    end
+  end
+
+  def pagination_options
+    page_numbers.map do |page_number|
+      attributes = { value: page_number }
+      attributes[:selected] = true if page_number == current_page
+      content_tag(:option, attributes) { page_label(page_number) }
+    end
+  end
+
+  def page_label page_number
+    first_item_in_page = (page_number - 1) * per_page + 1
+    last_item_in_page  = [page_number * per_page, total_entries].min
+    "#{first_item_in_page}-#{last_item_in_page}"
+  end
+
+end

data/app/builders/releaf/builders/refused_destroy_dialog_builder.rb

@@ -0,0 +1,68 @@
+class Releaf::Builders::RefusedDestroyDialogBuilder
+  include Releaf::Builders::ResourceDialog
+
+  def section_body
+    tag(:div, class: "body") do
+      [
+        icon("ban"),
+        tag(:div, t("Deletion of %{resource} was refused due to existing relations:", default: "Deletion of %{resource} restricted, due to existing relations:", resource: resource_to_text(resource)), class: "description"),
+        restricted_relations
+      ]
+    end
+  end
+
+  def restricted_relations
+    tag(:ul, class: "restricted-relations") do
+      template_variable("restricted_relations").collect do|key, relation|
+        tag(:li) do
+          restricted_relation(relation, key)
+        end
+      end
+    end
+  end
+
+  def relation_description(relation, key)
+      (
+        unless relation[:controller].nil?
+          I18n.t(relation[:controller], scope: 'admin.controllers')
+        else
+          I18n.t(key, scope: 'admin.controllers')
+        end
+      ) << " (#{relation[:objects].count})"
+  end
+
+  def relation_objects(relation)
+    tag(:ul, class: "relations") do
+      relation[:objects][0..2].collect do |item|
+          relation_objects_item(item, relation)
+      end + [(tag(:li, "...") if relation[:objects].count > 3)]
+    end
+  end
+
+  def relation_objects_item(item, relation)
+    tag(:li) do
+      unless relation[:controller].nil?
+        link_to(resource_to_text(item), controller: relation[:controller], action: "edit", id: item)
+      else
+        resource_to_text(item)
+      end
+    end
+  end
+
+  def restricted_relation(relation, key)
+    [
+      relation_description(relation, key),
+      relation_objects(relation)
+    ]
+  end
+
+  def footer_primary_tools
+    [
+      button(t("Ok"), "check", href: index_url, data: {type: 'cancel'})
+    ]
+  end
+
+  def section_header_text
+    t("Deletion refused")
+  end
+end

data/app/builders/releaf/builders/resource.rb

@@ -0,0 +1,9 @@
+module Releaf::Builders::Resource
+  attr_accessor :resource
+
+  def initialize(template)
+    super
+    self.resource = template_variable("resource")
+  end
+
+end

data/app/builders/releaf/builders/resource_dialog.rb

@@ -0,0 +1,8 @@
+module Releaf::Builders::ResourceDialog
+  include Releaf::Builders::View
+  include Releaf::Builders::Resource
+
+  def dialog?
+    true
+  end
+end

data/app/builders/releaf/builders/resource_view.rb

@@ -0,0 +1,54 @@
+module Releaf::Builders::ResourceView
+  include Releaf::Builders::View
+  include Releaf::Builders::Resource
+  include Releaf::Builders::Toolbox
+
+  def section
+    tag(:section, section_attributes) do
+      section_content
+    end
+  end
+
+  def section_content
+    section_blocks
+  end
+
+  def section_header_text
+    resource.new_record? ? t("Create new resource") : resource_to_text(resource)
+  end
+
+  def section_header_extras
+    return unless feature_available? :toolbox
+    tag(:div, class: "extras toolbox-wrap") do
+      toolbox(resource, index_url: index_url)
+    end
+  end
+
+  def section_body
+    tag(:div, section_body_attributes) do
+      section_body_blocks
+    end
+  end
+
+  def section_body_attributes
+    {class: ["body"]}
+  end
+
+  def section_body_blocks
+    []
+  end
+
+  def footer_secondary_tools
+    list = []
+    list << back_to_list_button if back_to_list?
+    list
+  end
+
+  def back_to_list?
+    feature_available?(:index) && params[:index_url].present?
+  end
+
+  def back_to_list_button
+    button(t("Back to list"), "caret-left", class: "secondary", href: index_url)
+  end
+end

data/app/builders/releaf/builders/show_builder.rb

@@ -0,0 +1,3 @@
+class Releaf::Builders::ShowBuilder
+  include Releaf::Builders::ResourceView
+end

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

@@ -0,0 +1,280 @@
+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)
+    self.collection = collection
+    self.options = options
+    self.template = template
+    self.resource_class = resource_class
+  end
+
+  def column_names
+    Releaf::Core::ResourceTableFields.new(resource_class).values(include_associations: false)
+  end
+
+  def columns
+    @columns ||= columns_schema
+  end
+
+  def columns_schema
+    data = {}
+
+    final_column_names = []
+    final_column_names += column_names
+    final_column_names << :toolbox if options[:toolbox] == true
+
+    final_column_names.map do|column|
+      if cell_method(column)
+        data[column] = {cell_method: cell_method(column)}
+      elsif cell_content_method(column)
+        data[column] = {content_method: cell_content_method(column)}
+      else
+        data[column] = {format_method: cell_format_method(column)}
+      end
+    end
+
+    data
+  end
+
+  def output
+    tag(:table, table_attributes) do
+      if collection.empty?
+        empty_body
+      else
+        head << body
+      end
+    end
+  end
+
+  def table_attributes
+    {class: ["table", resource_class.name.pluralize.underscore.dasherize]}
+  end
+
+  def head
+    tag(:thead) do
+      tag(:tr) do
+        content = ActiveSupport::SafeBuffer.new
+        columns.each_pair do|column, options|
+          content << head_cell(column)
+        end
+        content
+      end
+    end
+  end
+
+  def head_cell(column)
+    tag(:th) do
+      head_cell_content(column)
+    end
+  end
+
+  def head_cell_content(column)
+    unless column.to_sym == :toolbox
+      attribute = column.to_s.gsub(".", "_")
+      resource_class.human_attribute_name(attribute, create_default: false)
+    end
+  end
+
+  def empty_body
+    tag(:tr) do
+      tag(:th) do
+        tag(:div, class: "nothing-found") do
+          t("Nothing found")
+        end
+      end
+    end
+  end
+
+  def body
+    tag(:tbody, class: "tbody") do
+      collection.collect do |resource|
+        row(resource)
+      end
+    end
+  end
+
+  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
+  end
+
+  def row_url_action(resource)
+    if feature_available?(:show)
+      resource_action = :show
+    elsif feature_available?(:edit)
+      resource_action = :edit
+    end
+  end
+
+  def row_attributes(resource)
+    {
+      class: "row",
+      data: {
+        id: resource.id
+      }
+    }
+  end
+
+  def row(resource)
+    url = row_url(resource)
+    tag(:tr, row_attributes(resource)) do
+      content = ActiveSupport::SafeBuffer.new
+      columns.each_pair do|column, options|
+        cell_options = options.merge(url: url)
+        if options[:cell_method]
+          content << send(options[:cell_method], resource, cell_options)
+        else
+          content << cell(resource, column, cell_options)
+        end
+      end
+      content
+    end
+  end
+
+  def cell_content(resource, column, options)
+    if options[:content_method]
+      send(options[:content_method], resource)
+    else
+      send(options[:format_method], resource, column)
+    end
+  end
+
+  def format_text_content(resource, column)
+    truncate(column_value(resource, column).to_s, length: 32, separator: ' ')
+  end
+
+  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
+  end
+
+  def format_boolean_content(resource, column)
+    t(column_value(resource, column) == true ? "Yes" : "No")
+  end
+
+  def format_date_content(resource, column)
+    value = column_value(resource, column)
+    I18n.l(value, format: :default, default: '%Y-%m-%d') unless value.nil?
+  end
+
+  def format_datetime_content(resource, column)
+    value = column_value(resource, column)
+    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
+
+  def association_name(column)
+    column.to_s.sub(/_id$/, '').to_sym
+  end
+
+  def cell_method(column)
+    method_name = "#{column}_cell"
+    if respond_to? method_name
+      method_name
+    else
+      nil
+    end
+  end
+
+  def cell_content_method(column)
+    method_name = "#{column}_content"
+    if respond_to? method_name
+      method_name
+    else
+      nil
+    end
+  end
+
+  def column_type(klass, column)
+    column_description = klass.columns_hash[column.to_s]
+    if column_description
+      column_description.type
+    else
+      :string
+    end
+  end
+
+  def column_type_format_method(column)
+    klass = column_klass(resource_class, column)
+
+    format_method = "format_#{column_type(klass, column)}_content".to_sym
+    if respond_to?(format_method)
+      format_method
+    else
+      :format_string_content
+    end
+  end
+
+  def column_klass(klass, column)
+    column.to_s.split(".")[0..-2].each do|part|
+      reflection = klass.reflect_on_association(part)
+      klass = reflection.klass if reflection
+    end
+
+    klass
+  end
+
+  def column_value(resource_or_value, column)
+    column.to_s.split(".").each do|part|
+      resource_or_value = resource_or_value.send(part) if resource_or_value.present?
+    end
+
+    resource_or_value
+  end
+
+  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, {}))
+    tag(:td, class: "only-icon toolbox-cell") do
+      toolbox(resource, toolbox_args)
+    end
+  end
+
+  def cell(resource, column, options)
+    content = cell_content(resource, column, options)
+
+    tag(:td) do
+      if options[:url].blank?
+        content
+      else
+        tag(:a, href: options[:url]) do
+          content
+        end
+      end
+    end
+  end
+end