super 0.0.0 → 0.0.5

data/lib/super/configuration.rb

@@ -0,0 +1,103 @@
+module Super
+  # @yield [Configuration]
+  # @return [Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+
+    if block_given?
+      yield(@configuration)
+    end
+
+    @configuration
+  end
+
+  # Allows setting global configuration
+  #
+  # ```ruby
+  # Super.configuration do |c|
+  #   c.title = "My Admin Site"
+  # end
+  # ```
+  class Configuration
+    module ConfigurationLogic # @api private
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def initialize
+        self.class.defaults.each do |key, value|
+          if value.respond_to?(:call)
+            value = value.call
+          end
+
+          public_send("#{key}=", value)
+        end
+      end
+
+      def configured?(attr)
+        instance_variable_defined?("@#{attr}")
+      end
+
+      module ClassMethods
+        def defaults
+          @defaults ||= {}
+        end
+
+        def wraps
+          @wraps ||= {}
+        end
+
+        def configure(attr, wrap: nil, enum: nil, **kwargs)
+          if kwargs.key?(:default)
+            defaults[attr] = kwargs[:default]
+          end
+
+          define_method(attr) do
+            if !configured?(attr)
+              raise Error::UnconfiguredConfiguration, "unconfigured: #{attr}"
+            end
+
+            result = instance_variable_get("@#{attr}")
+
+            if wrap.nil?
+              result
+            else
+              wrap.call(result)
+            end
+          end
+
+          define_method("#{attr}=") do |value|
+            if enum.is_a?(Array)
+              if !enum.include?(value)
+                raise Error::InvalidConfiguration,
+                  "tried to set `#{attr}` to `#{value.inspect}`, " \
+                  "expected: #{enum.join(", ")}"
+              end
+            end
+
+            instance_variable_set("@#{attr}", value)
+            value
+          end
+        end
+      end
+    end
+
+    include ConfigurationLogic
+
+    # @!attribute [rw]
+    configure :title
+    # @!attribute [rw]
+    configure :index_resources_per_page, default: 20
+    # @!attribute [rw]
+    configure :controller_namespace, default: "admin"
+    # @!attribute [rw]
+    configure :route_namespace, default: :admin, wrap: -> (val) { [val].flatten }
+    # @!attribute [rw]
+    configure :asset_handler, default: -> { Super::Assets.auto }
+
+    # @api private
+    def path_parts(*parts)
+      route_namespace + parts
+    end
+  end
+end

data/lib/super/controls.rb

@@ -0,0 +1,120 @@
+module Super
+  # A wrapper around the per-controller Controls classes. This class often
+  # directly delegates to the per-controller classes, but it can also provide
+  # some default implementation.
+  class Controls
+    def initialize(actual)
+      @actual = actual
+    end
+
+    attr_reader :actual
+
+    # This is an optional method
+    #
+    # @return [String]
+    def title
+      if @actual.respond_to?(:title)
+        return @actual.title
+      end
+
+      model.name.pluralize
+    end
+
+    # Specifies the model. This is a required method
+    #
+    # @return [ActiveRecord::Base]
+    def model
+      @actual.model
+    end
+
+    # Configures the actions linked to on the index page. This is an optional
+    # method
+    #
+    # @param params [ActionController::Parameters]
+    # @param action [ActionInquirer]
+    # @return [Array<Link>]
+    def resources_actions(params:, action:)
+      actions =
+        if @actual.respond_to?(:resources_actions)
+          @actual.resources_actions(params: params, action: action)
+        else
+          [:new]
+        end
+
+      actions.map do |link|
+        link = Link.resolve(link)
+
+        link.call(params: params)
+      end
+    end
+
+    # Configures the actions linked to on the show page as well as each row of
+    # the table on the index page. This is an optional method
+    #
+    # @param resource [ActiveRecord::Base]
+    # @param params [ActionController::Parameters]
+    # @param action [ActionInquirer]
+    # @return [Array<Link>]
+    def resource_actions(resource, params:, action:)
+      actions =
+        if @actual.respond_to?(:resource_actions)
+          @actual.resource_actions(resource, params: params, action: action)
+        else
+          if action.show?
+            [:edit, :destroy]
+          elsif action.edit?
+            [:show, :destroy]
+          else
+            [:show, :edit, :destroy]
+          end
+        end
+
+      actions.map do |link|
+        link = Link.resolve(link)
+
+        link.call(resource, params: params)
+      end
+    end
+
+    # Configures what database records are visible on load. This is an optional
+    # method, it defaults to "`all`" methods
+    #
+    # @param action [ActionInquirer]
+    # @return [ActiveRecord::Relation]
+    def scope(action:)
+      if @actual.respond_to?(:scope)
+        return @actual.scope(action: action)
+      end
+
+      model.all
+    end
+
+    # Configures which parameters could be written to the database. This is a
+    # required method
+    #
+    # @param params [ActionController::Parameters]
+    # @param action [ActionInquirer]
+    # @return [ActionController::Parameters]
+    def permitted_params(params, action:)
+      @actual.permitted_params(params, action: action)
+    end
+
+    # Configures the fields that are displayed on the index and show actions.
+    # This is a required method
+    #
+    # @param action [ActionInquirer]
+    # @return [Schema]
+    def display_schema(action:)
+      @actual.display_schema(action: action)
+    end
+
+    # Configures the editable fields on the new and edit actions. This is a
+    # required method
+    #
+    # @param action [ActionInquirer]
+    # @return [Schema]
+    def form_schema(action:)
+      @actual.form_schema(action: action)
+    end
+  end
+end

data/lib/super/display.rb

@@ -0,0 +1,9 @@
+module Super
+  class Display
+    def self.format(schema, resource, column)
+      value = resource.public_send(column)
+
+      schema.fields[column].present(value)
+    end
+  end
+end

data/lib/super/display/schema_types.rb

@@ -0,0 +1,40 @@
+module Super
+  class Display
+    # This schema type is meant to be used for +#index+ or +#show+ actions to
+    # transform database fields into something that is human friendly.
+    #
+    # ```
+    # class MembersController::Controls
+    #   # ...
+    #
+    #   def show_schema
+    #     Super::Schema.new(Super::Display::SchemaTypes.new) do |fields, type|
+    #       fields[:name] = type.dynamic { |name| name }
+    #       fields[:rank] = type.dynamic { |rank| rank }
+    #       fields[:position] = type.dynamic { |position| position }
+    #       fields[:ship] = type.dynamic { |ship| "#{ship.name} (Ship ##{ship.id})" }
+    #       fields[:created_at] = type.dynamic { |created_at| created_at.iso8601 }
+    #       fields[:updated_at] = type.dynamic { |updated_at| updated_at.iso8601 }
+    #     end
+    #   end
+    #
+    #   # ...
+    # end
+    # ```
+    class SchemaTypes
+      class Dynamic
+        def initialize(transform_block)
+          @transform_block = transform_block
+        end
+
+        def present(field)
+          @transform_block.call(field)
+        end
+      end
+
+      def dynamic(&transform_block)
+        Dynamic.new(transform_block)
+      end
+    end
+  end
+end

data/lib/super/engine.rb

@@ -1,4 +1,10 @@
 module Super
+  # Configures the host Rails app to work with Super
   class Engine < ::Rails::Engine
+    initializer "super.assets.precompile" do |app|
+      if Super::Assets.sprockets_available?
+        app.config.assets.precompile << "config/super_manifest.js"
+      end
+    end
   end
 end

data/lib/super/error.rb

@@ -0,0 +1,18 @@
+module Super
+  # A container class for all custom errors thrown by this library
+  class Error < StandardError
+    class UnconfiguredConfiguration < Error; end
+    class InvalidConfiguration < Error; end
+    class InvalidStyle < Error; end
+    class InvalidPluginArgument < Error; end
+    class ActionInquirerError < Error; end
+    class LinkNotRegistered < Error; end
+
+    class ClientError < Error; end
+    class BadRequest < ClientError; end
+    class Unauthorized < ClientError; end
+    class Forbidden < ClientError; end
+    class NotFound < ClientError; end
+    class UnprocessableEntity < ClientError; end
+  end
+end

data/lib/super/form/schema_types.rb

@@ -0,0 +1,115 @@
+module Super
+  class Form
+    # This schema type is used on your +#edit+ and +#new+ forms
+    #
+    # ```ruby
+    # class MembersController::Controls
+    #   # ...
+    #
+    #   def new_schema
+    #     Super::Schema.new(Super::Form::SchemaTypes.new) do |fields, type|
+    #       fields[:name] = type.generic("form_field_text")
+    #       fields[:rank] = type.generic("form_field_select", collection: Member.ranks.keys)
+    #       fields[:position] = type.generic("form_field_text")
+    #       fields[:ship_id] = type.generic(
+    #         "form_field_select",
+    #         collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+    #       )
+    #     end
+    #   end
+    #
+    #   # ...
+    # end
+    # ```
+    class SchemaTypes
+      class Generic
+        def initialize(partial_path:, extras:, nested:)
+          @partial_path = partial_path
+          @extras = extras
+          @nested_fields = nested
+        end
+
+        attr_reader :nested_fields
+
+        # This takes advantage of a feature of Rails. If the value of
+        # `#to_partial_path` is `my_form_field`, Rails renders
+        # `app/views/super/application/_my_form_field.html.erb`, and this
+        # instance of Generic is accessible via `my_form_field`
+        #
+        # @return [String] the filename of the partial that will be rendered.
+        def to_partial_path
+          @partial_path
+        end
+
+        def [](key)
+          @extras[key]
+        end
+
+        def reader
+          @extras[:reader]
+        end
+
+        def label
+          if @extras.key?(:label)
+            return @extras[:label]
+          end
+
+          if @extras.key?(:reader)
+            return @extras[:reader].to_s.singularize.humanize
+          end
+        end
+
+        def ==(other)
+          return false if other.class != self.class
+          return false if other.instance_variable_get(:@partial_path) != @partial_path
+          return false if other.instance_variable_get(:@extras) != @extras
+          return false if other.instance_variable_get(:@nested_fields) != @nested_fields
+
+          true
+        end
+      end
+
+      def setup(fields:)
+        @fields = fields
+      end
+
+      def generic(partial_path, **extras)
+        Generic.new(partial_path: partial_path, extras: extras, nested: {})
+      end
+
+      def has_many(reader, **extras)
+        nested = @fields.nested do
+          yield
+        end
+
+        Generic.new(
+          partial_path: "form_has_many",
+          extras: extras.merge(reader: reader),
+          nested: nested
+        )
+      end
+
+      def has_one(reader, **extras)
+        nested = @fields.nested do
+          yield
+        end
+
+        Generic.new(
+          partial_path: "form_has_one",
+          extras: extras.merge(reader: reader),
+          nested: nested
+        )
+      end
+
+      alias_method :belongs_to, :has_one
+
+      def _destroy(**extras)
+        Generic.new(
+          partial_path: "form_field__destroy",
+          extras: extras,
+          nested: {}
+        )
+      end
+    end
+  end
+end

data/lib/super/layout.rb

@@ -0,0 +1,19 @@
+module Super
+  class Layout
+    def initialize(headers: nil, asides: nil, mains: nil, footers: nil)
+      @headers = Array(headers).compact
+      @asides = Array(asides).compact
+      @mains = Array(mains).compact
+      @footers = Array(footers).compact
+    end
+
+    attr_reader :headers
+    attr_reader :asides
+    attr_reader :mains
+    attr_reader :footers
+
+    def to_partial_path
+      "super_layout"
+    end
+  end
+end

data/lib/super/link.rb

@@ -0,0 +1,87 @@
+module Super
+  # Links have three required attributes that are passed directly into Rails'
+  # `link_to` helper
+  class Link
+    def self.resolve(link)
+      if link.kind_of?(self)
+        return link
+      end
+
+      if registry.key?(link)
+        return registry[link]
+      end
+
+      raise Error::LinkNotRegistered, "Unknown link `#{link}`"
+    end
+
+    def self.registry
+      @registry ||= {
+        new: -> (params:) {
+          new(
+            "New",
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :new,
+              only_path: true
+            )
+          )
+        },
+        index: -> (params:) {
+          new(
+            "Index",
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :index,
+              only_path: true
+            )
+          )
+        },
+        show: -> (resource, params:) {
+          new(
+            "View",
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :show,
+              id: resource,
+              only_path: true
+            )
+          )
+        },
+        edit: -> (resource, params:) {
+          new(
+            "Edit",
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :edit,
+              id: resource,
+              only_path: true
+            )
+          )
+        },
+        destroy: -> (resource, params:) {
+          new(
+            "Delete",
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :destroy,
+              id: resource,
+              only_path: true
+            ),
+            method: :delete,
+            data: { confirm: "Really delete?" }
+          )
+        },
+      }
+    end
+
+    def initialize(text, href, **options)
+      @text = text
+      @href = href
+      @options = options
+    end
+
+    attr_reader :text
+    attr_reader :href
+    attr_reader :options
+  end
+end