semantic-administrate 0.1.0

data/app/assets/stylesheets/docs.scss

@@ -0,0 +1,93 @@
+$blue: #53adc6;
+$red: #cf726e;
+$green: #5bc89e;
+$white: #f0f0f0;
+
+$code-black: #202020;
+$code-white: #e0e0dc;
+$code-green: #b0bf82;
+$code-blue: #8fbdcc;
+$code-yellow: #f8d29d;
+$code-red: #b95c56;
+
+html,
+body {
+  font-family: 'Lato', serif;
+  font-size: 18px;
+  line-height: 1.62em;
+  margin: 0;
+}
+
+img {
+  max-width: 100%;
+}
+
+h1,
+h2,
+h3 {
+  font-family: 'Fjalla One', sans-serif;
+  margin-top: 2em;
+}
+
+a {
+  color: $blue;
+  text-decoration: none;
+}
+
+.content {
+  margin-bottom: 2em;
+  margin-left: auto;
+  margin-right: auto;
+  margin-top: 2em;
+  width: 60em;
+
+  .sidebar {
+    float: left;
+    width: 20em;
+
+    &-links {
+      list-style: none;
+      padding-left: 0;
+    }
+  }
+
+  .main {
+    float: right;
+    width: 40em;
+  }
+}
+
+.flash-wrapper {
+  background-color: $red;
+  color: $white;
+  padding: 1em;
+
+  .flash {
+    margin-left: auto;
+    margin-right: auto;
+    width: 40em;
+  }
+}
+
+code {
+  font-family: "Source Code Pro";
+  font-size: 0.8rem;
+  padding: 0.4em 0.2em 0;
+
+  &.hljs {
+    background-color: $code-black;
+    color: $code-white;
+    padding-left: 1rem;
+
+    .hljs-string { color: $code-green; }
+    .hljs-subst { color: $code-white; }
+    .hljs-constant { color: $code-blue; }
+    .hljs-symbol { color: $code-red; }
+    .hljs-keyword { color: $code-yellow; }
+
+    .hljs-title,
+    .hljs-parent { color: $code-blue; }
+
+    .hljs-tag { color: $code-yellow; }
+  }
+}

data/app/controllers/administrate/application_controller.rb

@@ -0,0 +1,162 @@
+module Administrate
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    def index
+      search_term = params[:search].to_s.strip
+      resources = Administrate::Search.new(scoped_resource,
+                                           dashboard_class,
+                                           search_term).run
+      resources = resources.includes(*resource_includes) if resource_includes.any?
+      resources = order.apply(resources)
+      resources = resources.page(params[:page]).per(records_per_page)
+      page = Administrate::Page::Collection.new(dashboard, order: order)
+
+      render locals: {
+        resources: resources,
+        search_term: search_term,
+        page: page,
+        show_search_bar: show_search_bar?
+      }
+    end
+
+    def show
+      render locals: {
+        page: Administrate::Page::Show.new(dashboard, requested_resource),
+      }
+    end
+
+    def new
+      render locals: {
+        page: Administrate::Page::Form.new(dashboard, resource_class.new),
+      }
+    end
+
+    def edit
+      render locals: {
+        page: Administrate::Page::Form.new(dashboard, requested_resource),
+      }
+    end
+
+    def create
+      resource = resource_class.new(resource_params)
+
+      if resource.save
+        redirect_to(
+          [namespace, resource],
+          notice: translate_with_resource("create.success"),
+        )
+      else
+        render :new, locals: {
+          page: Administrate::Page::Form.new(dashboard, resource),
+        }
+      end
+    end
+
+    def update
+      if requested_resource.update(resource_params)
+        redirect_to(
+          [namespace, requested_resource],
+          notice: translate_with_resource("update.success"),
+        )
+      else
+        render :edit, locals: {
+          page: Administrate::Page::Form.new(dashboard, requested_resource),
+        }
+      end
+    end
+
+    def destroy
+      requested_resource.destroy
+      flash[:notice] = translate_with_resource("destroy.success")
+      redirect_to action: :index
+    end
+
+    private
+
+    helper_method :nav_link_state
+    def nav_link_state(resource)
+      resource_name.to_s.pluralize == resource.to_s ? :active : :inactive
+    end
+
+    helper_method :valid_action?
+    def valid_action?(name, resource = resource_class)
+      !!routes.detect do |controller, action|
+        controller == resource.to_s.underscore.pluralize && action == name.to_s
+      end
+    end
+
+    def routes
+      @routes ||= Namespace.new(namespace).routes
+    end
+
+    def records_per_page
+      params[:per_page] || 20
+    end
+
+    def order
+      @_order ||= Administrate::Order.new(params[:order], params[:direction])
+    end
+
+    def dashboard
+      @_dashboard ||= dashboard_class.new
+    end
+
+    def requested_resource
+      @_requested_resource ||= find_resource(params[:id])
+    end
+
+    def find_resource(param)
+      scoped_resource.find(param)
+    end
+
+    def scoped_resource
+      resource_class.default_scoped
+    end
+
+    def resource_includes
+      dashboard.association_includes
+    end
+
+    def resource_params
+      params.require(resource_class.model_name.param_key).
+        permit(dashboard.permitted_attributes).
+        transform_values { |v| read_param_value(v) }
+    end
+
+    def read_param_value(data)
+      if data.is_a?(ActionController::Parameters) && data[:type]
+        if data[:type] == Administrate::Field::Polymorphic.to_s
+          GlobalID::Locator.locate(data[:value])
+        else
+          raise "Unrecognised param data: #{data.inspect}"
+        end
+      else
+        data
+      end
+    end
+
+    delegate :dashboard_class, :resource_class, :resource_name, :namespace,
+      to: :resource_resolver
+    helper_method :namespace
+    helper_method :resource_name
+
+    def resource_resolver
+      @_resource_resolver ||=
+        Administrate::ResourceResolver.new(controller_path)
+    end
+
+    def translate_with_resource(key)
+      t(
+        "administrate.controller.#{key}",
+        resource: resource_resolver.resource_title,
+      )
+    end
+
+    def show_search_bar?
+      dashboard.attribute_types_for(
+        dashboard.collection_attributes
+      ).any? { |_name, attribute| attribute.searchable? }
+    end
+  end
+end

data/app/helpers/administrate/application_helper.rb

@@ -0,0 +1,51 @@
+require 'digest'
+
+module Administrate
+  module ApplicationHelper
+    PLURAL_MANY_COUNT = 2.1
+
+    def gravatar_for_email(email, size = 120)
+      hash = Digest::MD5.hexdigest(email)
+
+      "//www.gravatar.com/avatar/#{hash}?s=#{size}"
+    end
+
+    def render_field(field, locals = {})
+      locals.merge!(field: field)
+      render locals: locals, partial: field.to_partial_path
+    end
+
+    def class_from_resource(resource_name)
+      resource_name.to_s.classify.constantize
+    end
+
+    def display_resource_name(resource_name)
+      class_from_resource(resource_name).
+        model_name.
+        human(
+          count: PLURAL_MANY_COUNT,
+          default: resource_name.to_s.pluralize.titleize,
+        )
+    end
+
+    def sort_order(order)
+      case order
+      when "asc" then "ascending"
+      when "desc" then "descending"
+      else "none"
+      end
+    end
+
+    def resource_index_route_key(resource_name)
+      ActiveModel::Naming.route_key(class_from_resource(resource_name))
+    end
+
+    def sanitized_order_params
+      params.permit(:search, :id, :order, :page, :per_page, :direction, :orders)
+    end
+
+    def clear_search_params
+      params.except(:search, :page).permit(:order, :direction, :per_page)
+    end
+  end
+end

data/app/views/administrate/application/_collection.html.erb

@@ -0,0 +1,92 @@
+<%#
+# Collection
+
+This partial is used on the `index` and `show` pages
+to display a collection of resources in an HTML table.
+
+## Local variables:
+
+- `collection_presenter`:
+  An instance of [Administrate::Page::Collection][1].
+  The table presenter uses `ResourceDashboard::COLLECTION_ATTRIBUTES` to determine
+  the columns displayed in the table
+- `resources`:
+  An ActiveModel::Relation collection of resources to be displayed in the table.
+  By default, the number of resources is limited by pagination
+  or by a hard limit to prevent excessive page load times
+
+[1]: http://www.rubydoc.info/gems/administrate/Administrate/Page/Collection
+%>
+
+<table class="ui very basic table" aria-labelledby="<%= table_title %>">
+  <thead>
+    <tr>
+      <% collection_presenter.attribute_types.each do |attr_name, attr_type| %>
+        <th class="cell-label
+        cell-label--<%= attr_type.html_class %>
+        cell-label--<%= collection_presenter.ordered_html_class(attr_name) %>"
+        scope="col"
+        role="columnheader"
+        aria-sort="<%= sort_order(collection_presenter.ordered_html_class(attr_name)) %>">
+        <%= link_to(sanitized_order_params.merge(
+          collection_presenter.order_params_for(attr_name)
+        )) do %>
+        <%= t(
+          "helpers.label.#{collection_presenter.resource_name}.#{attr_name}",
+          default: attr_name.to_s,
+        ).titleize %>
+
+            <% if collection_presenter.ordered_by?(attr_name) %>
+              <span class="cell-label__sort-indicator cell-label__sort-indicator--<%= collection_presenter.ordered_html_class(attr_name) %>">
+                <svg aria-hidden="true">
+                  <use xlink:href="#icon-up-caret" />
+                </svg>
+              </span>
+            <% end %>
+          <% end %>
+        </th>
+      <% end %>
+      <% [valid_action?(:edit, collection_presenter.resource_name),
+          valid_action?(:destroy, collection_presenter.resource_name)].count(true).times do %>
+        <th scope="col"></th>
+      <% end %>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% resources.each do |resource| %>
+      <tr class="js-table-row"
+          tabindex="0"
+          <% if valid_action? :show, collection_presenter.resource_name %>
+            <%= %(role=link data-url=#{polymorphic_path([namespace, resource])}) %>
+          <% end %>
+          >
+        <% collection_presenter.attributes_for(resource).each do |attribute| %>
+          <td class="cell-data cell-data--<%= attribute.html_class %>">
+            <a href="<%= polymorphic_path([namespace, resource]) -%>"
+               class="action-show"
+               >
+              <%= render_field attribute %>
+            </a>
+          </td>
+        <% end %>
+
+        <% if valid_action? :edit, collection_presenter.resource_name %>
+          <td><%= link_to(
+            t("administrate.actions.edit"),
+            [:edit, namespace, resource],
+          ) %></td>
+        <% end %>
+
+        <% if valid_action? :destroy, collection_presenter.resource_name %>
+          <td class="cell-data--red"><%= link_to(
+            t("administrate.actions.destroy"),
+            [namespace, resource],
+            method: :delete,
+            data: { confirm: t("administrate.actions.confirm") }
+          ) %></td>
+        <% end %>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/app/views/administrate/application/_flashes.html.erb

@@ -0,0 +1,20 @@
+<%#
+# Flash Partial
+
+This partial renders flash messages on every page.
+
+## Relevant Helpers:
+
+- `flash`:
+  Returns a hash,
+  where the keys are the type of flash (alert, error, notice, etc)
+  and the values are the message to be displayed.
+%>
+
+<% if flash.any? %>
+  <div class="flashes">
+    <% flash.each do |key, value| -%>
+      <div class="flash flash-<%= key %>"><%= value %></div>
+    <% end -%>
+  </div>
+<% end %>

data/app/views/administrate/application/_form.html.erb

@@ -0,0 +1,42 @@
+<%#
+# Form Partial
+
+This partial is rendered on a resource's `new` and `edit` pages,
+and renders all form fields for a resource's editable attributes.
+
+## Local variables:
+
+- `page`:
+  An instance of [Administrate::Page::Form][1].
+  Contains helper methods to display a form,
+  and knows which attributes should be displayed in the resource's form.
+
+[1]: http://www.rubydoc.info/gems/administrate/Administrate/Page/Form
+%>
+
+<%= form_for([namespace, page.resource], html: { class: "form" }) do |f| %>
+  <% if page.resource.errors.any? %>
+    <div id="error_explanation">
+      <h2>
+        <%= pluralize(page.resource.errors.count, "error") %>
+        prohibited this <%= page.resource_name %> from being saved:
+      </h2>
+
+      <ul>
+        <% page.resource.errors.full_messages.each do |message| %>
+          <li class="flash-error"><%= message %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <% page.attributes.each do |attribute| -%>
+    <div class="field-unit field-unit--<%= attribute.html_class %>">
+      <%= render_field attribute, f: f %>
+    </div>
+  <% end -%>
+
+  <div class="form-actions">
+    <%= f.submit %>
+  </div>
+<% end %>