yummy-guide-generic-administrate 0.1.0

data/app/helpers/yummy_guide/administrate/filter_form_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    module FilterFormHelper
+      def yummy_guide_administrate_filter_current_values(raw_values)
+        values =
+          if raw_values.respond_to?(:to_unsafe_h)
+            raw_values.to_unsafe_h
+          elsif raw_values.respond_to?(:to_h)
+            raw_values.to_h
+          else
+            raw_values || {}
+          end
+
+        values.deep_stringify_keys
+      end
+
+      def yummy_guide_administrate_filter_hour_options
+        @yummy_guide_administrate_filter_hour_options ||= [["", ""]] + (0..23).map { |hour| [format("%02d", hour), format("%02d", hour)] }
+      end
+
+      def yummy_guide_administrate_filter_minute_options
+        @yummy_guide_administrate_filter_minute_options ||= [["", ""], ["00", "00"], ["30", "30"], ["59", "59"]]
+      end
+
+      def yummy_guide_administrate_datetime_filter_parts(value, end_of_day: false)
+        raw_value = value.to_s.strip
+
+        if raw_value.blank?
+          { date: "", hour: "", minute: "" }
+        elsif raw_value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+          {
+            date: raw_value,
+            hour: (end_of_day ? "23" : "00"),
+            minute: (end_of_day ? "59" : "00")
+          }
+        else
+          parsed = Time.zone.parse(raw_value)
+
+          if parsed.present?
+            {
+              date: parsed.strftime("%Y-%m-%d"),
+              hour: parsed.strftime("%H"),
+              minute: parsed.strftime("%M")
+            }
+          else
+            { date: "", hour: "", minute: "" }
+          end
+        end
+      end
+
+      def yummy_guide_administrate_datetime_filter_combined_value(parts)
+        if parts[:date].blank?
+          ""
+        elsif parts[:hour].present? && parts[:minute].present?
+          "#{parts[:date]}T#{parts[:hour]}:#{parts[:minute]}"
+        else
+          parts[:date]
+        end
+      end
+
+      def yummy_guide_administrate_checkbox_group_options(options, label_method: nil, value_method: nil)
+        Array(options).map do |option|
+          if option.is_a?(Array) && option.size == 2
+            option
+          elsif label_method.present? || value_method.present?
+            [
+              option.public_send(label_method || :to_s),
+              option.public_send(value_method || :id)
+            ]
+          else
+            [option, option]
+          end
+        end
+      end
+    end
+  end
+end
+

data/app/views/fields/yummy_guide_administrate/area/picture/_form.html.erb

@@ -0,0 +1,36 @@
+<div class="field-unit__label">
+  <%= f.label field.attribute %>
+</div>
+<div class="field-unit__field">
+  <% attachments = field.attachments %>
+  <% empty_slots = [field.max_uploads - attachments.size, 0].max %>
+
+  <div class="yummy-guide-administrate-picture-slots">
+    <% attachments.each do |attachment| %>
+      <% preview_url = field.preview_url(attachment, view_context: self) %>
+      <div class="yummy-guide-administrate-picture-slot">
+        <% if preview_url.present? %>
+          <div class="yummy-guide-administrate-picture-slot__preview">
+            <%= image_tag preview_url, class: "yummy-guide-administrate-picture-list__image" %>
+          </div>
+        <% else %>
+          <div class="yummy-guide-administrate-picture-slot__placeholder"><%= field.attachment_label(attachment) %></div>
+        <% end %>
+
+        <% if (attachment_id = field.attachment_identifier(attachment)).present? %>
+          <label class="yummy-guide-administrate-picture-slot__delete">
+            <input type="checkbox" name="<%= field.purge_input_name %>" value="<%= attachment_id %>">
+            Delete
+          </label>
+        <% end %>
+      </div>
+    <% end %>
+
+    <% empty_slots.times do %>
+      <div class="yummy-guide-administrate-picture-slot">
+        <%= file_field_tag field.input_name, accept: "image/*", class: "yummy-guide-administrate-picture-slot__input" %>
+      </div>
+    <% end %>
+  </div>
+</div>
+

data/app/views/fields/yummy_guide_administrate/area/picture/_index.html.erb

@@ -0,0 +1,2 @@
+<%= render "fields/yummy_guide_administrate/area/picture/show", field: field %>
+

data/app/views/fields/yummy_guide_administrate/area/picture/_show.html.erb

@@ -0,0 +1,24 @@
+<% if field.attachments.any? %>
+  <div class="yummy-guide-administrate-picture-list">
+    <% field.attachments.each do |attachment| %>
+      <% preview_url = field.preview_url(attachment, view_context: self) %>
+      <% link_url = field.attachment_url(attachment, view_context: self) || preview_url %>
+      <div class="yummy-guide-administrate-picture-list__item">
+        <% if preview_url.present? %>
+          <% if link_url.present? %>
+            <%= link_to link_url, title: field.attachment_label(attachment) do %>
+              <%= image_tag preview_url, class: "yummy-guide-administrate-picture-list__image" %>
+            <% end %>
+          <% else %>
+            <%= image_tag preview_url, class: "yummy-guide-administrate-picture-list__image" %>
+          <% end %>
+        <% else %>
+          <span><%= field.attachment_label(attachment) %></span>
+        <% end %>
+      </div>
+    <% end %>
+  </div>
+<% else %>
+  No attachment
+<% end %>
+

data/app/views/fields/yummy_guide_administrate/json_pretty_field/_index.html.erb

@@ -0,0 +1,2 @@
+<%= render "fields/yummy_guide_administrate/json_pretty_field/show", field: field %>
+

data/app/views/fields/yummy_guide_administrate/json_pretty_field/_show.html.erb

@@ -0,0 +1,6 @@
+<% if field.data.present? %>
+  <pre class="json-pretty-field"><%= field.to_s %></pre>
+<% else %>
+  -
+<% end %>
+

data/app/views/fields/yummy_guide_administrate/version_item_field/_index.html.erb

@@ -0,0 +1,2 @@
+<%= render "fields/yummy_guide_administrate/version_item_field/show", field: field %>
+

data/app/views/fields/yummy_guide_administrate/version_item_field/_show.html.erb

@@ -0,0 +1,6 @@
+<% if field.linkable? %>
+  <%= link_to field.label, field.path, class: "action-show", onclick: "event.stopPropagation();" %>
+<% else %>
+  <%= field.label %>
+<% end %>
+

data/app/views/fields/yummy_guide_administrate/version_whodunnit_field/_index.html.erb

@@ -0,0 +1,2 @@
+<%= render "fields/yummy_guide_administrate/version_whodunnit_field/show", field: field %>
+

data/app/views/fields/yummy_guide_administrate/version_whodunnit_field/_show.html.erb

@@ -0,0 +1,6 @@
+<% if field.linkable? %>
+  <%= link_to field.label, field.path, class: "action-show", onclick: "event.stopPropagation();" %>
+<% elsif field.data.present? %>
+  <%= field.label %>
+<% end %>
+

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

@@ -0,0 +1,62 @@
+<div class="scroll-table">
+  <table aria-labelledby="<%= table_title %>" data-fixed-columns-count="<%= yummy_guide_administrate_collection_table_fixed_columns_count(page: page, collection_presenter: collection_presenter) %>">
+    <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) %> cell-label--<%= "#{collection_presenter.resource_name}_#{attr_name}" %>"
+            scope="col"
+            aria-sort="<%= sort_order(collection_presenter.ordered_html_class(attr_name)) %>"
+          >
+            <%= link_to(sanitized_order_params(page, collection_field_name).merge(
+                  collection_presenter.order_params_for(attr_name, key: collection_field_name)
+                )) do %>
+              <%= t(
+                    "helpers.label.#{collection_presenter.resource_name}.#{attr_name}",
+                    default: resource_class.human_attribute_name(attr_name).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 %>
+        <%= render(
+              yummy_guide_administrate_collection_actions_partial("collection_header_actions"),
+              collection_presenter: collection_presenter,
+              page: page,
+              resources: resources,
+              table_title: "page-title"
+            ) %>
+      </tr>
+    </thead>
+
+    <tbody>
+      <% resources.each do |resource| %>
+        <tr class="js-table-row">
+          <% collection_presenter.attributes_for(resource).each do |attribute| %>
+            <% cell_href = yummy_guide_administrate_collection_attribute_path(attribute: attribute, resource: resource, namespace: namespace) %>
+            <td class="cell-data cell-data--<%= attribute.html_class %>">
+              <%= yummy_guide_administrate_collection_wrap(render_field(attribute), href: cell_href) %>
+            </td>
+          <% end %>
+
+          <%= render(
+                yummy_guide_administrate_collection_actions_partial("collection_item_actions"),
+                collection_presenter: collection_presenter,
+                collection_field_name: collection_field_name,
+                page: page,
+                namespace: namespace,
+                resource: resource,
+                table_title: "page-title"
+              ) %>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+</div>
+

data/app/views/yummy_guide/administrate/filter_forms/_checkbox_group.html.erb

@@ -0,0 +1,30 @@
+<% normalized_options = yummy_guide_administrate_checkbox_group_options(options,
+                                                               label_method: local_assigns[:label_method],
+                                                               value_method: local_assigns[:value_method]) %>
+<% selected = Array(selected_values).map(&:to_s) %>
+<div class="filter-checkbox-group" data-checkbox-group="<%= group_name %>">
+  <div class="filter-checkbox-group__options">
+    <% normalized_options.each do |label, value| %>
+      <% value_string = value.to_s %>
+      <label style="display: flex; align-items: center; gap: 6px;">
+        <%= check_box_tag "#{form_scope}[#{field_name}][]",
+                          value,
+                          selected.include?(value_string),
+                          id: "#{form_scope}_#{field_name}_#{value_string.parameterize(separator: "_")}",
+                          data: { checkbox_group_item: group_name } %>
+        <span><%= label %></span>
+      </label>
+    <% end %>
+  </div>
+  <div class="filter-checkbox-group__actions">
+    <%= button_tag "Select all",
+                   type: "button",
+                   class: "button button--outline-primary filter-checkbox-group__action",
+                   data: { behavior: "checkbox-group-select-all", target: group_name } %>
+    <%= button_tag "Clear all",
+                   type: "button",
+                   class: "button button--outline-primary filter-checkbox-group__action",
+                   data: { behavior: "checkbox-group-clear-all", target: group_name } %>
+  </div>
+</div>
+

data/app/views/yummy_guide/administrate/filter_forms/_datetime_field.html.erb

@@ -0,0 +1,30 @@
+<% parts = yummy_guide_administrate_datetime_filter_parts(current_value, end_of_day: local_assigns[:end_of_day]) %>
+<div
+  class="filter-datetime-group"
+  data-datetime-filter="true"
+  data-datetime-field="<%= field_name %>"
+  <% if local_assigns[:end_target].present? %>
+    data-datetime-end-target="<%= end_target %>"
+  <% end %>
+>
+  <%= hidden_field_tag("#{form_scope}[#{field_name}]",
+                       yummy_guide_administrate_datetime_filter_combined_value(parts),
+                       class: css_class,
+                       data: { datetime_part: "combined" }) %>
+  <%= date_field_tag("#{form_scope}[#{field_name}_date]",
+                     parts[:date],
+                     class: "#{css_class} filter-datetime-group__date",
+                     data: { datetime_part: "date" }) %>
+  <%= select_tag("#{form_scope}[#{field_name}_hour]",
+                 options_for_select(yummy_guide_administrate_filter_hour_options, parts[:hour]),
+                 class: "#{css_class} #{css_class}--hour filter-datetime-group__time",
+                 data: { datetime_part: "hour" },
+                 disabled: parts[:date].blank?) %>
+  <span class="filter-datetime-group__separator">:</span>
+  <%= select_tag("#{form_scope}[#{field_name}_minute]",
+                 options_for_select(yummy_guide_administrate_filter_minute_options, parts[:minute]),
+                 class: "#{css_class} #{css_class}--minute filter-datetime-group__time",
+                 data: { datetime_part: "minute" },
+                 disabled: parts[:date].blank?) %>
+</div>
+

data/app/views/yummy_guide/administrate/filter_forms/_frame.html.erb

@@ -0,0 +1,28 @@
+<% current_values = yummy_guide_administrate_filter_current_values(local_assigns[:current_values] || local_assigns[:search_options] || {}) %>
+<% form_css_class = local_assigns[:form_css_class] || "yummy-guide-administrate-filter-form" %>
+<% form_attributes = { class: form_css_class, data: { yummy_guide_administrate_filter_form: true } } %>
+<% form_attributes[:id] = local_assigns[:form_id] if local_assigns[:form_id].present? %>
+<% if local_assigns[:form_data].present? %>
+  <% form_attributes[:data].merge!(local_assigns[:form_data]) %>
+<% end %>
+
+<%= form_with url: path, scope: form, method: method, html: form_attributes do |f| %>
+  <% Array(local_assigns[:hidden_fields]).each do |(key, value)| %>
+    <%= hidden_field_tag "#{form}[#{key}]", value %>
+  <% end %>
+
+  <h2 class="<%= "#{form_css_class}__title" %>"><%= local_assigns[:title] || "Filter Options" %></h2>
+  <div class="<%= "#{form_css_class}__body" %>">
+    <table class="filter_table">
+      <%= yield f, current_values %>
+    </table>
+  </div>
+  <div class="<%= "#{form_css_class}__actions" %>">
+    <%= button_tag local_assigns[:clear_label] || "Clear",
+                   type: "button",
+                   class: "button button--outline-primary js-filter-form-clear",
+                   data: { behavior: "filter-form-clear" } %>
+    <%= f.submit local_assigns[:submit_label] || "Filter", class: "submit_filter" %>
+  </div>
+<% end %>
+

data/lib/generic/administrate.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../yummy_guide/administrate"

data/lib/yummy_guide/administrate/engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    class Engine < ::Rails::Engine
+      initializer "yummy_guide.administrate.assets" do |app|
+        next unless app.config.respond_to?(:assets)
+
+        app.config.assets.precompile += %w[
+          yummy_guide_administrate/components.css
+          yummy_guide_administrate/filter_form.js
+          yummy_guide_administrate/sticky_left_columns.js
+        ]
+      end
+    end
+  end
+end
+

data/lib/yummy_guide/administrate/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module YummyGuide
+  module Administrate
+    VERSION = "0.1.0"
+  end
+end
+

data/lib/yummy_guide/administrate.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+require "administrate"
+
+require_relative "administrate/version"
+require_relative "administrate/engine"
+
+module YummyGuide
+  module Administrate
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rspec"
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "action_controller"
+require "action_view"
+
+require "generic/administrate"
+Dir[File.expand_path("../app/**/*.rb", __dir__)].sort.each { |path| require path }
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

data/spec/yummy_guide/administrate/application_dashboard_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::ApplicationDashboard do
+  describe ".index_fixed_columns_count" do
+    it "returns the subclass constant when defined" do
+      subclass = Class.new(described_class)
+      subclass.const_set(:INDEX_FIXED_COLUMNS_COUNT, 3)
+
+      expect(subclass.index_fixed_columns_count).to eq(3)
+    end
+
+    it "falls back to the superclass value" do
+      subclass = Class.new(described_class)
+
+      expect(subclass.index_fixed_columns_count).to eq(1)
+    end
+  end
+
+  describe ".collection_attribute_sortable?" do
+    it "uses collection attributes when explicit sortable attributes are absent" do
+      subclass = Class.new(described_class)
+      subclass.const_set(:COLLECTION_ATTRIBUTES, %i[id created_at])
+
+      expect(subclass.collection_attribute_sortable?(:created_at)).to be(true)
+      expect(subclass.collection_attribute_sortable?(:name)).to be(false)
+    end
+
+    it "prefers explicit sortable attributes when present" do
+      subclass = Class.new(described_class)
+      subclass.const_set(:COLLECTION_ATTRIBUTES, %i[id created_at])
+      subclass.const_set(:COLLECTION_SORTABLE_ATTRIBUTES, %i[name])
+
+      expect(subclass.collection_attribute_sortable?(:name)).to be(true)
+      expect(subclass.collection_attribute_sortable?(:created_at)).to be(false)
+    end
+  end
+end

data/spec/yummy_guide/administrate/collection_helper_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::CollectionHelper do
+  subject(:helper_host) do
+    Class.new do
+      include YummyGuide::Administrate::CollectionHelper
+    end.new
+  end
+
+  it "caps the fixed column count by the number of visible attributes" do
+    dashboard_class = Class.new do
+      def self.index_fixed_columns_count
+        4
+      end
+    end
+
+    page = Object.new
+    page.instance_variable_set(:@dashboard, dashboard_class.new)
+    collection_presenter = Struct.new(:attribute_types).new({ id: :integer, name: :string })
+
+    expect(helper_host.yummy_guide_administrate_collection_table_fixed_columns_count(page: page, collection_presenter: collection_presenter)).to eq(2)
+  end
+end

data/spec/yummy_guide/administrate/datetime_filter_parameters_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::DatetimeFilterParameters do
+  subject(:host) do
+    Class.new do
+      include YummyGuide::Administrate::DatetimeFilterParameters
+
+      def normalize(filters, keys:)
+        normalize_datetime_filter_params(filters, keys: keys)
+      end
+    end.new
+  end
+
+  it "combines date and time parts into a datetime-local string" do
+    filters = ActionController::Parameters.new(
+      start_date_date: "2026-05-07",
+      start_date_hour: "09",
+      start_date_minute: "30"
+    )
+
+    normalized = host.normalize(filters, keys: [:start_date])
+
+    expect(normalized[:start_date]).to eq("2026-05-07T09:30")
+    expect(normalized).not_to have_key(:start_date_date)
+  end
+
+  it "returns just the date when time parts are blank" do
+    filters = ActionController::Parameters.new(
+      end_date_date: "2026-05-07",
+      end_date_hour: "",
+      end_date_minute: ""
+    )
+
+    normalized = host.normalize(filters, keys: [:end_date])
+
+    expect(normalized[:end_date]).to eq("2026-05-07")
+  end
+
+  it "sets nil when the date is blank" do
+    filters = ActionController::Parameters.new(
+      start_date_date: "",
+      start_date_hour: "09",
+      start_date_minute: "30"
+    )
+
+    normalized = host.normalize(filters, keys: [:start_date])
+
+    expect(normalized[:start_date]).to be_nil
+  end
+end

data/spec/yummy_guide/administrate/fields/json_pretty_field_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::Fields::JsonPrettyField do
+  def build_field(data)
+    described_class.new(:payload, data, :show, resource: Object.new)
+  end
+
+  it "pretty prints JSON strings" do
+    field = build_field('{"a":1}')
+
+    expect(field.to_s).to include("\"a\": 1")
+  end
+
+  it "falls back to the raw string when parsing fails" do
+    field = build_field("not-json")
+
+    expect(field.to_s).to eq("not-json")
+  end
+end
+

data/spec/yummy_guide/administrate/fields/version_item_field_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::Fields::VersionItemField do
+  before do
+    stub_const("SpecVersionItemRecord", Class.new do
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+    end)
+  end
+
+  let(:record) { SpecVersionItemRecord.new(12) }
+  let(:resource) { Struct.new(:item_type, :item_id, :reify).new("Widget", 12, nil) }
+
+  def build_field(data = record)
+    described_class.new(:item, data, :show, resource: resource, namespace: :admin)
+  end
+
+  it "builds a readable label" do
+    expect(build_field.label).to eq("SpecVersionItemRecord #12")
+  end
+
+  it "uses a fallback label when the target resource is unavailable" do
+    expect(build_field(nil).label).to eq("Widget #12")
+  end
+end

data/spec/yummy_guide/administrate/fields/version_whodunnit_field_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::Fields::VersionWhodunnitField do
+  let(:user_class) do
+    Class.new do
+      def self.find_by(id:)
+        return unless id == 5
+
+        Struct.new(:id, :full_name) do
+          def self.model_name
+            ActiveModel::Name.new(self, nil, "User")
+          end
+        end.new(5, "Test User")
+      end
+    end
+  end
+
+  def build_field(data)
+    described_class.new(:whodunnit, data, :show, resource: Object.new, user_class: user_class)
+  end
+
+  it "uses the resolved user label when found" do
+    expect(build_field(5).label).to eq("Test User")
+  end
+
+  it "falls back to a generic label when the user is missing" do
+    expect(build_field(99).label).to eq("User #99")
+  end
+end

data/spec/yummy_guide/administrate/filter_form_helper_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe YummyGuide::Administrate::FilterFormHelper do
+  subject(:helper_host) do
+    Class.new do
+      include YummyGuide::Administrate::FilterFormHelper
+    end.new
+  end
+
+  before do
+    Time.zone = "Tokyo"
+  end
+
+  it "normalizes current values to string keys" do
+    values = ActionController::Parameters.new(start_date: "2026-05-07")
+
+    expect(helper_host.yummy_guide_administrate_filter_current_values(values)).to eq("start_date" => "2026-05-07")
+  end
+
+  it "builds end-of-day defaults for date-only inputs" do
+    parts = helper_host.yummy_guide_administrate_datetime_filter_parts("2026-05-07", end_of_day: true)
+
+    expect(parts).to eq(date: "2026-05-07", hour: "23", minute: "59")
+  end
+
+  it "combines parsed datetime parts back into a single value" do
+    combined = helper_host.yummy_guide_administrate_datetime_filter_combined_value(date: "2026-05-07", hour: "08", minute: "00")
+
+    expect(combined).to eq("2026-05-07T08:00")
+  end
+
+  it "maps checkbox group objects through label and value methods" do
+    option = Struct.new(:id, :name).new(10, "Japanese")
+
+    expect(helper_host.yummy_guide_administrate_checkbox_group_options([option], label_method: :name, value_method: :id)).to eq([["Japanese", 10]])
+  end
+end
+