super 0.0.10 → 0.0.15

data/lib/super/form/guesser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Form
     class Guesser
@@ -20,7 +22,16 @@ module Super
       private
 
       def attribute_type_for(attribute_name)
-        @type.string
+        case @model.type_for_attribute(attribute_name).type
+        when :datetime
+          @type.datetime_flatpickr
+        when :time
+          @type.time_flatpickr
+        when :date
+          @type.date_flatpickr
+        else
+          @type.string
+        end
       end
     end
   end

data/lib/super/form/inline_errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Form
     module InlineErrors

data/lib/super/form/schema_types.rb

@@ -1,6 +1,40 @@
+# frozen_string_literal: true
+
 module Super
   class Form
     class SchemaTypes
+      class Direct
+        def initialize(super_builder:, method_name:, args:, kwargs:)
+          @super_builder = super_builder
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+        end
+
+        attr_reader :super_builder
+        attr_reader :method_name
+        attr_reader :args
+        attr_reader :kwargs
+
+        def nested_fields
+          {}
+        end
+
+        def to_partial_path
+          "form_field"
+        end
+
+        def ==(other)
+          return false if other.class != self.class
+          return false if other.super_builder != super_builder
+          return false if other.method_name != method_name
+          return false if other.args != args
+          return false if other.kwargs != kwargs
+
+          true
+        end
+      end
+
       class Generic
         def initialize(partial_path:, extras:, nested:)
           @partial_path = partial_path
@@ -9,6 +43,7 @@ module Super
         end
 
         attr_reader :nested_fields
+        attr_reader :extras
 
         def each_attribute
           if block_given?
@@ -66,24 +101,57 @@ module Super
         Generic.new(partial_path: partial_path, extras: extras, nested: {})
       end
 
+      def direct(method_name, *args, super_builder: true, **kwargs)
+        Direct.new(super_builder: super_builder, method_name: method_name, args: args, kwargs: kwargs)
+      end
+
       def select(**extras)
         Generic.new(partial_path: "form_field_select", extras: extras, nested: {})
       end
 
-      def string(**extras)
-        Generic.new(partial_path: "form_field_text", extras: extras, nested: {})
+      def text_field(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :text_field!, args: args, kwargs: kwargs)
+      end
+
+      alias string text_field
+      alias text text_field
+
+      def rich_text_area(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :rich_text_area!, args: args, kwargs: kwargs)
+      end
+
+      def check_box(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :check_box!, args: args, kwargs: kwargs)
+      end
+
+      alias checkbox check_box
+
+      def date_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :date_flatpickr!, args: args, kwargs: kwargs)
+      end
+
+      alias flatpickr_date date_flatpickr
+
+      def datetime_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :datetime_flatpickr!, args: args, kwargs: kwargs)
       end
 
-      alias text string
+      alias flatpickr_datetime datetime_flatpickr
+
+      def hidden_field(*args, **kwargs)
+        Direct.new(super_builder: false, method_name: :hidden_field, args: args, kwargs: kwargs)
+      end
 
-      def rich_text_area(**extras)
-        Generic.new(partial_path: "form_field_rich_text_area", extras: extras, nested: {})
+      def password_field(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :password_field!, args: args, kwargs: kwargs)
       end
 
-      def checkbox(**extras)
-        Generic.new(partial_path: "form_field_checkbox", extras: extras, nested: {})
+      def time_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :time_flatpickr!, args: args, kwargs: kwargs)
       end
 
+      alias flatpickr_time time_flatpickr
+
       def has_many(reader, **extras)
         nested = @fields.nested do
           yield

data/lib/super/form/strong_params.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Form
     class StrongParams

data/lib/super/layout.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "super/partial/resolving"
 
 module Super
@@ -17,7 +19,7 @@ module Super
     attr_reader :footers
 
     def to_partial_path
-      "super_layout"
+      "layout"
     end
 
     def resolve(template)

data/lib/super/link.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # Links have three required attributes that are passed directly into Rails'
   # `link_to` helper
@@ -20,57 +22,57 @@ module Super
 
     def self.registry
       @registry ||= {
-        new: new(
+        new: LinkBuilder.new(
           "New",
           -> (params:) {
-            Rails.application.routes.url_for(
+            {
               controller: params[:controller],
               action: :new,
               only_path: true
-            )
+            }
           }
         ),
-        index: new(
+        index: LinkBuilder.new(
           "Index",
           -> (params:) {
-            Rails.application.routes.url_for(
+            {
               controller: params[:controller],
               action: :index,
               only_path: true
-            )
+            }
           }
         ),
-        show: new(
+        show: LinkBuilder.new(
           "View",
           -> (record:, params:) {
-            Rails.application.routes.url_for(
+            {
               controller: params[:controller],
               action: :show,
               id: record,
               only_path: true
-            )
+            }
           }
         ),
-        edit: new(
+        edit: LinkBuilder.new(
           "Edit",
           -> (record:, params:) {
-            Rails.application.routes.url_for(
+            {
               controller: params[:controller],
               action: :edit,
               id: record,
               only_path: true
-            )
+            }
           }
         ),
-        destroy: new(
+        destroy: LinkBuilder.new(
           "Delete",
           -> (record:, params:) {
-            Rails.application.routes.url_for(
+            {
               controller: params[:controller],
               action: :destroy,
               id: record,
               only_path: true
-            )
+            }
           },
           method: :delete,
           data: { confirm: "Really delete?" }
@@ -78,33 +80,44 @@ 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
       @options = options
     end
 
-    def to_s(default_options: nil, **proc_arguments)
+    attr_reader :text
+    attr_reader :options
+
+    def href
+      if @href.is_a?(String)
+        return @href
+      end
+
+      if @href.is_a?(Hash)
+        @href = Rails.application.routes.url_for(**@href)
+        return @href
+      end
+
+      @href = Super::Compatability.polymorphic_path_container.polymorphic_path(@href)
+    end
+
+    def to_s(default_options: nil)
       default_options ||= {}
       ActionController::Base.helpers.link_to(
-        value(text, proc_arguments),
-        value(href, proc_arguments),
-        default_options.deep_merge(value(options, proc_arguments))
+        text,
+        href,
+        default_options.deep_merge(options)
       )
     end
 
-    private
-
-    attr_reader :text
-    attr_reader :href
-    attr_reader :options
-
-    def value(proc_or_value, proc_arguments)
-      if proc_or_value.kind_of?(Proc)
-        proc_or_value.call(**proc_arguments)
-      else
-        proc_or_value
-      end
+    def ==(other)
+      self.class == other.class && text == other.text && href == other.href && options == other.options
     end
   end
 end

data/lib/super/link_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Super
+  class LinkBuilder
+    def initialize(text, href, **options)
+      @text = text
+      @href = href
+      @options = options
+      @requirements = []
+      @requirements += gather_requirements(text)
+      @requirements += gather_requirements(href)
+      @requirements += gather_requirements(options)
+
+      unknown_arguments = @requirements - known_requirements
+      if unknown_arguments.any?
+        raise Error::ArgumentError, "Unknown arguments: #{unknown_arguments.join(", ")}"
+      end
+    end
+
+    attr_reader :requirements
+
+    def to_s(default_options: nil, **kwargs)
+      resolve(**kwargs).to_s(default_options: default_options)
+    end
+
+    def resolve(**kwargs)
+      Link.new(
+        into_value(@text, kwargs),
+        into_value(@href, kwargs),
+        **into_value(@options, kwargs),
+      )
+    end
+
+    private
+
+    def known_requirements
+      %i[params record].freeze
+    end
+
+    def gather_requirements(value_or_proc)
+      return [] if !value_or_proc.is_a?(Proc)
+
+      requirements =
+        value_or_proc
+          .parameters
+          .select { |(kind, name)| kind = :keyreq }
+          .map(&:last)
+    end
+
+    def into_value(value_or_proc, kwargs)
+      if value_or_proc.kind_of?(Proc)
+        value_or_proc.call(**kwargs)
+      else
+        value_or_proc
+      end
+    end
+  end
+end

data/lib/super/navigation.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Super
+  class Navigation
+    def initialize
+      @builder = Builder.new
+      @definition = yield @builder
+      if !@definition.is_a?(Array)
+        @definition = [@definition]
+      end
+    end
+
+    def definition
+      return @defs if instance_variable_defined?(:@defs)
+
+      searcher = RouteFormatterButReallySearcher.new
+      inspector = ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
+      inspector.format(searcher)
+      all_matches = searcher.matches
+      unused_matches = all_matches.each_with_object({}) { |match, hash| hash[match] = true }
+
+      defs = expand_proc_syntax_sugar(@definition)
+      defs = validate_and_determine_explicit_links(defs, unused_matches)
+      @defs = expand_directives(defs, all_matches, unused_matches.keys)
+    end
+
+    private
+
+    # This expands the syntax sugar that allows `nav.menu("Name")[nav.link(Item)]`
+    def expand_proc_syntax_sugar(definition)
+      definition.map do |link_or_menu_or_rest_or_menuproc|
+        link_or_menu_or_rest =
+          if link_or_menu_or_rest_or_menuproc.is_a?(Proc)
+            link_or_menu_or_rest_or_menuproc.call
+          else
+            link_or_menu_or_rest_or_menuproc
+          end
+
+        if link_or_menu_or_rest.is_a?(Menu)
+          link_or_menu_or_rest.links = link_or_menu_or_rest.links.map do |menu_item|
+            if menu_item.is_a?(Proc)
+              menu_item.call
+            else
+              menu_item
+            end
+          end
+        end
+
+        link_or_menu_or_rest
+      end
+    end
+
+    def validate_and_determine_explicit_links(definition, unused_links)
+      definition.each do |link_or_menu_or_rest|
+        if link_or_menu_or_rest.is_a?(Super::Link)
+          unused_links.delete(link_or_menu_or_rest.href)
+        elsif link_or_menu_or_rest.is_a?(Menu)
+          link_or_menu_or_rest.links.each do |link_or_rest|
+            if link_or_rest.is_a?(Menu)
+              raise Super::Error::ArgumentError, "Navigation menus can't be nested"
+            end
+
+            if link_or_rest.is_a?(Link)
+              unused_links.delete(link_or_rest.href)
+            end
+          end
+        end
+      end
+    end
+
+    def expand_directives(defs, all_hrefs, rest_hrefs)
+      defs.flat_map do |link_or_menu_or_rest|
+        if link_or_menu_or_rest.is_a?(Menu)
+          link_or_menu_or_rest.links = link_or_menu_or_rest.links.flat_map do |link_or_rest|
+            if link_or_rest == ALL
+              linkify_hrefs(all_hrefs)
+            elsif link_or_rest == REST
+              linkify_hrefs(rest_hrefs)
+            else
+              link_or_rest
+            end
+          end
+
+          link_or_menu_or_rest
+        elsif link_or_menu_or_rest == ALL
+          linkify_hrefs(all_hrefs)
+        elsif link_or_menu_or_rest == REST
+          linkify_hrefs(rest_hrefs)
+        else
+          link_or_menu_or_rest
+        end
+      end
+    end
+
+    def linkify_hrefs(hrefs)
+      hrefs.map do |href|
+        Super::Link.new(href.split("/").last.humanize, href)
+      end
+    end
+
+    ALL = Object.new
+    REST = Object.new
+    Menu = Struct.new(:title, :links)
+
+    class Builder
+      def link(model, **kwargs)
+        text = model.model_name.human.pluralize
+        parts = Super::Link.polymorphic_parts(model)
+
+        Super::Link.new(text, parts, **kwargs)
+      end
+
+      def link_to(*args, **kwargs)
+        Super::Link.new(*args, **kwargs)
+      end
+
+      def menu(title, *links)
+        menu = Menu.new(title, links)
+        proc do |*more_links|
+          menu.links += more_links
+          menu
+        end
+      end
+
+      def rest
+        REST
+      end
+
+      def all
+        ALL
+      end
+    end
+
+    class RouteFormatterButReallySearcher
+      def initialize(route_namespace: Super.configuration.path)
+        @route_namespace = route_namespace.strip.gsub(%r{\A/+}, "").gsub(%r{/+\z}, "").strip
+        @route_namespace = "/#{@route_namespace}/"
+        @matches = []
+      end
+
+      def matches
+        @matches.map do |route|
+          route[:path].sub(/\(.*\)\Z/, "")
+        end
+      end
+
+      def section(routes)
+        @matches += routes.select do |route|
+          next false unless route[:verb] == "GET" || route[:verb] == ""
+          next false unless route[:path].start_with?(@route_namespace)
+          next false if route[:path].include?("/:")
+          next false if route[:reqs].end_with?("#new")
+
+          true
+        end
+      end
+
+      def header(routes); end
+      def no_routes(routes, filter); end
+      def result; end
+      def section_title(title); end
+    end
+  end
+end