goodmin 0.0.1

data/lib/goodmin/fields/association.rb

@@ -0,0 +1,62 @@
+module Goodmin
+  module Fields
+    class Association < Base
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      def many_to_many?
+        reflection = record.class.reflect_on_association(attribute)
+        return false unless reflection
+        reflection.macro == :has_and_belongs_to_many ||
+          (reflection.macro == :has_many && reflection.options[:through].present?)
+      end
+
+      def has_many?
+        return false unless reflection
+        macro == :has_many && !many_to_many?
+      end
+
+      def select_attribute
+        belongs_to? ? :"#{attribute}_id" : :"#{attribute.to_s.singularize}_ids"
+      end
+
+      def collection
+        klass = reflection&.klass
+        return [] unless klass
+
+        if associated_service
+          klass.all.map { |a| [display_name_for(a), a.id] }
+        else
+          method_name = resource_service.option_text_for_association(attribute)
+          klass.all.map { |a| [a.public_send(method_name), a.id] }
+        end
+      end
+
+      def display_name_for(associated_record)
+        return nil unless associated_record
+        service = associated_service
+        service ? service.display_name(associated_record) : associated_record.to_s
+      end
+
+      def associated_service
+        @associated_service ||= begin
+          service_class = find_associated_service_class(reflection&.klass)
+          service_class&.new
+        rescue StandardError
+          nil
+        end
+      end
+
+      private
+
+      def macro
+        reflection&.macro
+      end
+
+      def reflection
+        record.class.reflect_on_association(attribute)
+      end
+    end
+  end
+end

data/lib/goodmin/fields/base.rb

@@ -0,0 +1,57 @@
+module Goodmin
+  module Fields
+    class Base
+      attr_reader :attribute, :record, :resource_service, :options
+
+      def initialize(attribute:, record:, resource_service:, **options)
+        @attribute = attribute
+        @record = record
+        @resource_service = resource_service
+        @options = options
+      end
+
+      def value
+        record.public_send(attribute)
+      end
+
+      def hint
+        hint_option = options[:hint]
+        result = if hint_option.is_a?(Proc)
+          hint_option.call(record)
+        elsif hint_option.present?
+          hint_option
+        else
+          i18n_hint
+        end
+        result&.html_safe
+      end
+
+      def find_associated_service_class(klass)
+        Goodmin::ServiceLocator.find_service_class_for(klass, context_service_class: resource_service.class)
+      end
+
+      def self.partial_index
+        "goodmin/fields/#{field_type}/index"
+      end
+
+      def self.partial_show
+        "goodmin/fields/#{field_type}/show"
+      end
+
+      def self.partial_form
+        "goodmin/fields/#{field_type}/form"
+      end
+
+      private_class_method def self.field_type
+        name.demodulize.underscore
+      end
+
+      private
+
+      def i18n_hint
+        model_key = record.class.model_name.i18n_key
+        I18n.t("activerecord.hints.#{model_key}.#{attribute}", default: nil)
+      end
+    end
+  end
+end

data/lib/goodmin/fields/boolean.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class Boolean < Base
+    end
+  end
+end

data/lib/goodmin/fields/date.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class Date < Base
+    end
+  end
+end

data/lib/goodmin/fields/date_time.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class DateTime < Base
+    end
+  end
+end

data/lib/goodmin/fields/enum.rb

@@ -0,0 +1,15 @@
+module Goodmin
+  module Fields
+    class Enum < Select
+      def self.partial_form
+        Fields::Select.partial_form
+      end
+
+      def collection
+        (record.class.defined_enums[attribute.to_s] || {}).keys.map do |key|
+          [key.humanize, key]
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/fields/nested_has_one.rb

@@ -0,0 +1,41 @@
+module Goodmin
+  module Fields
+    class NestedHasOne < Base
+      def associated_record
+        @associated_record ||= begin
+          existing = record.public_send(attribute)
+          return existing if existing
+
+          build_method = :"build_#{attribute}"
+          record.public_send(build_method) if record.respond_to?(build_method)
+        end
+      end
+
+      def associated_service
+        @associated_service ||= associated_service_class&.new
+      end
+
+      def nested_attributes
+        associated_service&.attrs_for_form || []
+      end
+
+      def nested_form_nodes
+        associated_service&.form_nodes || []
+      end
+
+      private
+
+      def reflection
+        record.class.reflect_on_association(attribute)
+      end
+
+      def associated_model_class
+        reflection&.klass
+      end
+
+      def associated_service_class
+        find_associated_service_class(associated_model_class)
+      end
+    end
+  end
+end

data/lib/goodmin/fields/number.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class Number < Base
+    end
+  end
+end

data/lib/goodmin/fields/password.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class Password < Base
+    end
+  end
+end

data/lib/goodmin/fields/select.rb

@@ -0,0 +1,19 @@
+module Goodmin
+  module Fields
+    class Select < Base
+      def collection
+        col = options[:collection]
+        return [] if col.nil?
+        col.respond_to?(:call) ? col.call(record) : col
+      end
+
+      def select_options
+        options.fetch(:options, {})
+      end
+
+      def select_html_options
+        { class: "form-control" }.merge(options.fetch(:html_options, {}))
+      end
+    end
+  end
+end

data/lib/goodmin/fields/string.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class String < Base
+    end
+  end
+end

data/lib/goodmin/fields/text.rb

@@ -0,0 +1,6 @@
+module Goodmin
+  module Fields
+    class Text < Base
+    end
+  end
+end

data/lib/goodmin/generators/base.rb

@@ -0,0 +1,49 @@
+require "active_support/all"
+
+module Goodmin
+  module Generators
+    class Base < Rails::Generators::Base
+      def self.source_paths
+        %w[authentication install policy resource].map do |path|
+          File.expand_path("../../../generators/goodmin/#{path}/templates", __FILE__)
+        end
+      end
+
+      private
+
+      def namespace
+        @_namespace ||= Rails::Generators.namespace
+      end
+
+      def namespaced?
+        @_namespaced ||= namespace.present?
+      end
+
+      def namespaced_path
+        @_namespaced_path ||= begin
+          if namespaced?
+            namespace.name.split("::").map(&:underscore)
+          else
+            []
+          end
+        end
+      end
+
+      def module_namespacing(&block)
+        content = capture(&block)
+        content = wrap_with_namespace(content) if namespaced?
+        concat(content)
+      end
+
+      def indent(content, multiplier = 2)
+        spaces = " " * multiplier
+        content.each_line.map { |line| line.blank? ? line : "#{spaces}#{line}" }.join
+      end
+
+      def wrap_with_namespace(content)
+        content = indent(content).chomp
+        "module #{namespace.name}\n#{content}\nend\n"
+      end
+    end
+  end
+end

data/lib/goodmin/generators/named_base.rb

@@ -0,0 +1,31 @@
+require "goodmin/generators/base"
+
+module Goodmin
+  module Generators
+    class NamedBase < Base
+      argument :name, type: :string
+
+      private
+
+      def full_class_name
+        if namespaced?
+          "#{namespace}::#{class_name}"
+        else
+          class_name
+        end
+      end
+
+      def class_name
+        @_class_name ||= name.classify
+      end
+
+      def class_path
+        @_class_path ||= namespaced_path + name.classify.deconstantize.split("::").map(&:underscore)
+      end
+
+      def file_name
+        @_file_name ||= class_name.demodulize.underscore
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/application.rb

@@ -0,0 +1,47 @@
+module Goodmin
+  module Helpers
+    module Application
+      # Renders the provided partial with locals if it exists, otherwise
+      # yields the given block. The lookup context call is cached for
+      # each partial.
+      # Returns the display name for a resource record by looking up its service
+      # class via ServiceLocator and calling display_name on it. Falls back to
+      # record.to_s if no service class is found.
+      def resource_display_name(record)
+        service_class = Goodmin::ServiceLocator.find_service_class_for(
+          record.class,
+          context_service_class: @resource_service&.class
+        )
+        service = service_class&.new
+        service ? service.display_name(record) : record.to_s
+      rescue StandardError
+        record.to_s
+      end
+
+      def partial_override(partial, locals = {}, &block)
+        @_partial_override ||= {}
+
+        unless @_partial_override.key?(partial)
+          @_partial_override[partial] = lookup_context.exists?(partial, nil, true)
+        end
+
+        if @_partial_override[partial]
+          render partial: partial, locals: locals
+        else
+          capture(&block)
+        end
+      end
+
+      # Wraps the policy helper so that it is always accessible, even when
+      # authorization is not enabled. When that is the case, it returns a
+      # policy that always returns true.
+      def policy(resource)
+        if authorization_enabled?
+          controller.policy(resource)
+        else
+          Authorization::Policy.new(nil, nil, default: true)
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/batch_actions.rb

@@ -0,0 +1,21 @@
+module Goodmin
+  module Helpers
+    module BatchActions
+      def batch_action_link(name, options)
+        return unless @resource_service.include_batch_action?(name)
+
+        link_to(
+          translate_scoped("batch_actions.labels.#{name}", default: name.to_s.titleize),
+          [*@resource_parents, @resource_class],
+          class: "btn btn-default hidden",
+          data: {
+            batch_actions_target: "actionLink",
+            action: "click->batch-actions#triggerAction",
+            confirm: options[:confirm] ? translate_scoped("batch_actions.confirm_message") : false,
+            value: name
+          }
+        )
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/filters.rb

@@ -0,0 +1,123 @@
+module Goodmin
+  module Helpers
+    module Filters
+      def filter_form(url: params.to_unsafe_h)
+        builder = FormBuilders::FilterFormBuilder.new("", nil, self, {})
+        form_tag(url, method: :get, class: "form-inline") do
+          yield(builder)
+        end
+      end
+    end
+  end
+
+  module FormBuilders
+    class FilterFormBuilder < ActionView::Helpers::FormBuilder
+      def filter_field(name, options, html_options = {})
+        case options[:as]
+        when :string
+          string_filter_field(name, options, html_options)
+        when :select
+          select_filter_field(name, options, html_options)
+        when :multiselect
+          multiselect_filter_field(name, options, html_options)
+        end
+      end
+
+      def string_filter_field(name, _options, html_options = {})
+        label_text = @template.translate_scoped("filters.labels.#{name}", default: name.to_s.titleize)
+        @template.content_tag(:div, class: "form-group filter") do
+          @template.concat(@template.label_tag(name, label_text, class: "control-label"))
+          @template.concat(@template.text_field_tag(
+            "filter[#{name}]",
+            default_filter_value(name),
+            { placeholder: label_text, class: "form-control", id: name }.merge(html_options)
+          ))
+        end
+      end
+
+      def select_filter_field(name, options, html_options = {})
+        filter_select(
+          name, options, {
+            name: "filter[#{name}]",
+            data: {
+              placeholder: @template.translate_scoped("filters.select.placeholder.one")
+            }
+          }.deep_merge(html_options)
+        )
+      end
+
+      def multiselect_filter_field(name, options, html_options = {})
+        filter_select(
+          name, {
+            include_hidden: false
+          }.deep_merge(options), {
+            name: "filter[#{name}][]",
+            multiple: true,
+            data: {
+              placeholder: @template.translate_scoped("filters.select.placeholder.many")
+            }
+          }.deep_merge(html_options)
+        )
+      end
+
+      def apply_filters_button
+        submit @template.translate_scoped("filters.buttons.apply"), class: "btn btn-primary"
+      end
+
+      def clear_filters_button
+        @template.link_to(
+          @template.translate_scoped("filters.buttons.clear"),
+          @template.url_for(
+            @template.params.to_unsafe_h.slice(:scope, :order)
+          ),
+          class: "btn btn-default"
+        )
+      end
+
+      private
+
+      def filter_select(name, options, html_options)
+        unless options[:collection].is_a? Proc
+          raise "A collection proc must be specified for select filters"
+        end
+
+        options = options.dup
+
+        collection = options.delete(:collection).call
+        options.delete(:include_hidden)
+
+        label_text = @template.translate_scoped("filters.labels.#{name}", default: name.to_s.titleize)
+
+        choices =
+          if collection.is_a? ActiveRecord::Relation
+            @template.options_from_collection_for_select(
+              collection,
+              options.delete(:option_value),
+              options.delete(:option_text),
+              selected: default_filter_value(name)
+            )
+          else
+            @template.options_for_select(
+              collection,
+              selected: default_filter_value(name)
+            )
+          end
+
+        blank_option = @template.content_tag(:option, "", value: "")
+
+        @template.content_tag(:div, class: "form-group filter") do
+          @template.concat(@template.label_tag(name, label_text, class: "control-label"))
+          @template.concat(@template.select_tag(
+            html_options[:name] || "filter[#{name}]",
+            @template.safe_join([blank_option, choices]),
+            { class: "form-control", id: name }.merge(html_options.except(:name))
+          ))
+        end
+      end
+
+      def default_filter_value(name)
+        @template.params[:filter] ? @template.params[:filter][name] : nil
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/forms.rb

@@ -0,0 +1,42 @@
+module Goodmin
+  module Helpers
+    module Forms
+      def form_for(record, options = {}, &block)
+        super(record, {
+          url: [*@resource_parents, record]
+        }.merge(options), &block)
+      end
+
+      def render_form_nodes(nodes, f)
+        safe_join(nodes.map { |node| render_form_node(node, f) })
+      end
+
+      def render_form_nodes_for(nodes, f, record:, resource_service:)
+        old_resource = @resource
+        old_resource_service = @resource_service
+        @resource = record
+        @resource_service = resource_service
+        render_form_nodes(nodes, f)
+      ensure
+        @resource = old_resource
+        @resource_service = old_resource_service
+      end
+
+      private
+
+      def render_form_node(node, f)
+        case node
+        when Resources::AttributeNode
+          field = node.attribute.to_field(record: @resource, resource_service: @resource_service)
+          render partial: field.class.partial_form, locals: { field: field, f: f }
+        when Resources::HtmlNode
+          content_tag(node.tag, node.html_attrs) do
+            render_form_nodes(node.children, f)
+          end
+        when Resources::ComponentNode
+          node.component.render(self, f)
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/navigation.rb

@@ -0,0 +1,52 @@
+module Goodmin
+  module Helpers
+    module Navigation
+      def navbar_item(resource, url = resource, show: nil, icon: nil, **options)
+        show ||= lambda do
+          resource.is_a?(String) ? true : policy(resource).index?
+        end
+
+        return unless show.call
+
+        link_text =
+          if block_given?
+            capture do
+              yield
+            end
+          else
+            resource.respond_to?(:model_name) ? resource.model_name.human(count: :many) : resource
+          end
+
+        content_tag :li do
+          link_to url, options do
+            if icon.present?
+              concat content_tag :span, "", class: "glyphicon glyphicon-#{icon}"
+              concat " "
+            end
+            concat link_text
+          end
+        end
+      end
+
+      def navbar_dropdown(title)
+        dropdown_toggle = link_to "#", class: "dropdown-toggle", data: { toggle: "dropdown" } do
+          concat "#{title} "
+          concat content_tag :span, "", class: "caret"
+        end
+
+        dropdown_menu = content_tag :ul, class: "dropdown-menu" do
+          yield
+        end
+
+        content_tag :li, class: "dropdown" do
+          concat dropdown_toggle
+          concat dropdown_menu
+        end
+      end
+
+      def navbar_divider
+        content_tag :li, "", class: "divider"
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/tables.rb

@@ -0,0 +1,25 @@
+module Goodmin
+  module Helpers
+    module Tables
+      def column_header(attribute)
+        if @resource_service.orderable_column?(attribute.name.to_s)
+          direction =
+            if params[:order].present?
+              if params[:order].match(/\A#{attribute.name.to_s}_(asc|desc)\z/)
+                $1 == "desc" ? "asc" : "desc"
+              elsif params[:order].match(/\A\w+_(asc|desc)\z/)
+                $1
+              else
+                "desc"
+              end
+            else
+              "desc"
+            end
+          link_to @resource_class.human_attribute_name(attribute.name.to_s), url_for(params.to_unsafe_h.merge(order: "#{attribute.name}_#{direction}"))
+        else
+          @resource_class.human_attribute_name(attribute.name.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/goodmin/helpers/translations.rb

@@ -0,0 +1,19 @@
+module Goodmin
+  module Helpers
+    module Translations
+      def translate_scoped(translate, scope: nil, default: nil, **options)
+        if @resource_class
+          scope ||= @resource_class.to_s.underscore
+        end
+
+        defaults = [
+          ["goodmin", scope, translate].compact.join(".").to_sym,
+          ["goodmin", translate].compact.join(".").to_sym,
+          default
+        ]
+
+        t(defaults.shift, default: defaults, **options)
+      end
+    end
+  end
+end