super 0.0.11 → 0.0.12

data/lib/super.rb

@@ -5,6 +5,8 @@ require "tsort"
 require "rails/engine"
 
 require "super/schema/common"
+require "super/useful/builder"
+require "super/useful/enum"
 
 require "super/action_inquirer"
 require "super/assets"

data/lib/super/configuration.rb

@@ -21,36 +21,27 @@ module Super
   # end
   # ```
   class Configuration
-    def initialize
-      self.title = "Super Admin"
-      self.index_records_per_page = 20
-      self.controller_namespace = "admin"
-      self.route_namespace = :admin
-
-      controller_plugins.use(prepend: Super::Pagination::ControllerMethods)
+    include ActiveSupport::Configurable
 
-      self.javascripts = [Super::Assets.auto("super/application")]
-      self.stylesheets = [Super::Assets.auto("super/application")]
+    config_accessor(:title) { "Super Admin" }
+    config_accessor(:index_records_per_page) { 100 }
+    config_accessor(:javascripts) do
+      [Super::Assets.auto("super/application")]
     end
-
-    attr_accessor :title
-    attr_accessor :index_records_per_page
-    attr_accessor :controller_namespace
-    attr_writer :route_namespace
-    def route_namespace
-      [@route_namespace].flatten
+    config_accessor(:stylesheets) do
+      [Super::Assets.auto("super/application")]
     end
 
-    attr_accessor :javascripts
-    attr_accessor :stylesheets
+    config_accessor(:path) { "/admin" }
+    config_accessor(:generator_module) { "admin" }
+    config_accessor(:generator_as) { "admin" }
 
-    def controller_plugins
-      Plugin::Registry.controller
+    def initialize
+      controller_plugins.use(prepend: Super::Pagination::ControllerMethods)
     end
 
-    # @api private
-    def path_parts(*parts)
-      route_namespace + parts
+    def controller_plugins
+      Plugin::Registry.controller
     end
   end
 end

data/lib/super/controls.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "super/controls/optional"
-require "super/controls/required"
 require "super/controls/steps"
 require "super/controls/view"
 
@@ -9,9 +8,15 @@ module Super
   # The base Controls class. Most parts of Super can be configured by
   # customizing its methods.
   class Controls
-    include Required
     include Optional
     include Steps
     include View
+
+    # Specifies the model. This is a required method
+    #
+    # @return [ActiveRecord::Base]
+    def model
+      raise NotImplementedError
+    end
   end
 end

data/lib/super/controls/optional.rb

@@ -98,6 +98,7 @@ module Super
         )
         attribute_names =
           display_schema(action: action).each_attribute.map do |key, val|
+            val = val.build if val.respond_to?(:build)
             key if val.real?
           end
 

data/lib/super/display.rb

@@ -45,25 +45,33 @@ module Super
         raise Super::Error::Initalization,
           "You must call the `#apply` method after instantiating Super::Display"
       elsif @action_inquirer.index?
-        "super_schema_display_index"
+        "display_index"
       elsif @action_inquirer.show?
-        "super_schema_display_show"
+        "display_show"
       else
-        "super_schema_display_#{@action_inquirer.action}"
+        "display_#{@action_inquirer.action}"
       end
     end
 
     # @private
-    def render_field(template:, record:, column:)
+    def render_attribute(template:, record:, column:)
       formatter = @fields[column]
+      formatter = formatter.build if formatter.respond_to?(:build)
 
       formatted =
-        if formatter.real?
+        SchemaTypes::TYPES
+        .case(formatter.type)
+        .when(:record) do
+          formatter.present(column, record)
+        end
+        .when(:column) do
           value = record.public_send(column)
-          formatter.present(value)
-        else
-          formatter.present
+          formatter.present(column, value)
+        end
+        .when(:none) do
+          formatter.present(column)
         end
+        .result
 
       if formatted.respond_to?(:to_partial_path)
         if formatted.respond_to?(:locals)

data/lib/super/display/schema_types.rb

@@ -3,35 +3,61 @@
 module Super
   class Display
     class SchemaTypes
-      class Dynamic
-        def initialize(ignore_nil: true, &transform_block)
-          @transform_block = transform_block
-          @ignore_nil = ignore_nil
-        end
+      TYPES = Useful::Enum.new(:column, :record, :none)
 
-        def present(value)
-          return nil if value.nil? && @ignore_nil
+      class Builder
+        extend Useful::Builder
 
-          @transform_block.call(value)
+        builder_with_block def transform(&block)
+          @transform_block = block
         end
 
-        def real?
-          true
+        builder def real; @real = true; end
+        builder def computed; @real = false; end
+
+        builder def column; @type = :column; end
+        builder def record; @type = :record; end
+        builder def none; @type = :none; end
+
+        builder def ignore_nil; @ignore_nil = true; end
+
+        def build
+          Built.new(
+            real: @real,
+            type: @type,
+            ignore_nil: !!@ignore_nil,
+            &@transform_block
+          )
         end
       end
 
-      class Bypass
-        def initialize(partial:, real:)
-          @partial = partial
+      class Built
+        def initialize(real:, type:, ignore_nil:, &transform_block)
           @real = real
+          @type = type
+          @ignore_nil = ignore_nil
+          @transform_block = transform_block
         end
 
-        def present
-          Partial.new(@partial)
-        end
+        def real?; @real; end
+        attr_reader :type
+
+        def present(attribute_name, value = nil)
+          if @transform_block.nil?
+            if attribute_name
+              raise Error::ArgumentError, "Transformation block is not set for column: #{attribute_name}"
+            else
+              raise Error::ArgumentError, "Transformation block is not set!"
+            end
+          end
+
+          return nil if value.nil? && @ignore_nil
 
-        def real?
-          @real
+          if @type == :none
+            @transform_block.call
+          else
+            @transform_block.call(value)
+          end
         end
       end
 
@@ -40,33 +66,44 @@ module Super
         @fields = fields
       end
 
-      def string
-        Dynamic.new(&:to_s)
+      def real(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.real.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.real.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.real.ignore_nil.none.transform(&transform_block) }
+          .result
       end
 
-      alias text string
+      def computed(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.computed.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.computed.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.computed.ignore_nil.none.transform(&transform_block) }
+          .result
+      end
 
-      def timestamp
-        Dynamic.new(&:iso8601)
+      def manual(&transform_block)
+        real(:column, &transform_block)
       end
 
+      def string; real(&:to_s); end
+      alias text string
+
+      def timestamp; real(&:to_s); end
+
       def rich_text
-        Dynamic.new do |value|
+        real do |value|
           Partial.new("display_rich_text", locals: { rich_text: value })
         end
       end
 
-      def manual(&transform_block)
-        Dynamic.new(&transform_block)
-      end
-
-      def dynamic(&transform_block)
-        Dynamic.new(&transform_block)
-      end
-
       def actions
         @actions_called = true
-        Bypass.new(partial: "super_schema_display_actions", real: false)
+        Builder.new.computed.none.transform do
+          Partial.new("display_actions")
+        end
       end
 
       # @private

data/lib/super/error.rb

@@ -27,5 +27,12 @@ module Super
     # Error raised when something wasn't initalized correctly, and if there isn't
     # a more specific error
     class Initalization < Error; end
+    class ArgumentError < Error; end
+
+    class Enum < Error
+      class ImpossibleValue < Enum; end
+      class ArgumentError < Enum; end
+      class UndefinedCase < Enum; end
+    end
   end
 end

data/lib/super/form.rb

@@ -31,7 +31,7 @@ module Super
     end
 
     def to_partial_path
-      "super_schema_form"
+      "form"
     end
   end
 end

data/lib/super/layout.rb

@@ -19,7 +19,7 @@ module Super
     attr_reader :footers
 
     def to_partial_path
-      "super_layout"
+      "layout"
     end
 
     def resolve(template)

data/lib/super/link.rb

@@ -80,6 +80,11 @@ module Super
       }
     end
 
+    def self.polymorphic_parts(*parts_tail)
+      parts_head = Super.configuration.path.strip.gsub(%r{\A/+}, "").gsub(%r{/+\z}, "").strip.split("/")
+      parts_head + parts_tail
+    end
+
     def initialize(text, href, **options)
       @text = text
       @href = href

data/lib/super/navigation/automatic.rb

@@ -5,8 +5,8 @@ module Super
     # Traverses the defined Rails Routes and attempts to build a list of links.
     # This is used for building the nav bar on each admin page.
     class Automatic
-      def initialize(route_namespace:)
-        route_namespace = route_namespace.to_s
+      def initialize(route_namespace: Super.configuration.path)
+        route_namespace = route_namespace.strip.gsub(%r{\A/+}, "").gsub(%r{/+\z}, "").strip
 
         if route_namespace.include?("/")
           raise "Can't be nested namespace"

data/lib/super/pagination.rb

@@ -55,7 +55,7 @@ module Super
     end
 
     def to_partial_path
-      "super_pagination"
+      "pagination"
     end
 
     private

data/lib/super/panel.rb

@@ -26,7 +26,7 @@ module Super
     end
 
     def to_partial_path
-      "super_panel"
+      "panel"
     end
   end
 end

data/lib/super/useful/builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Super
+  module Useful
+    module Builder
+      def builder(method_name)
+        alias_method("original_#{method_name}", method_name)
+
+        define_method(method_name) do
+          send("original_#{method_name}")
+          self
+        end
+      end
+
+      def builder_with_block(method_name)
+        alias_method("original_#{method_name}", method_name)
+
+        define_method(method_name) do |&block|
+          send("original_#{method_name}", &block)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/super/useful/enum.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Super
+  module Useful
+    class Enum
+      def initialize(*choices)
+        @choices = choices.flatten.map { |choice| [choice, nil] }.to_h
+      end
+
+      def case(chosen)
+        Case.new(@choices, chosen)
+      end
+
+      class Case
+        def initialize(choices, chosen)
+          if !choices.key?(chosen)
+            raise Error::Enum::ImpossibleValue,
+              "`#{chosen}` isn't in: #{choices.keys.map(&:inspect).join(", ")}"
+          end
+
+          @choices = choices
+          @chosen = chosen
+          @whens = {}
+        end
+
+        def when(*keys, &block)
+          if !block_given?
+            raise Error::ArgumentError, "must receive block"
+          end
+
+          keys.each do |key|
+            if !@choices.key?(key)
+              raise Error::Enum::ImpossibleValue, "`#{key.inspect}` is not a possibility"
+            end
+
+            @whens[key] = block
+          end
+
+          self
+        end
+
+        def result
+          if @choices.size != @whens.size
+            missing_keys = @choices.keys - @whens.keys
+            raise Error::Enum::UndefinedCase, "Unset cases: #{missing_keys.join(", ")}"
+          end
+
+          @whens[@chosen].call(@value)
+        end
+
+        private
+
+        def matching_possibilities_and_checks?
+          if @whens.size == @choices.size
+            return true
+          end
+
+          false
+        end
+      end
+    end
+  end
+end