super 0.0.13 → 0.0.14

data/lib/generators/super/webpacker/webpacker_generator.rb

@@ -5,10 +5,14 @@ module Super
     source_root File.expand_path("templates", __dir__)
 
     def copy_the_pack_file
-      template(
-        "pack_super_application.js.erb",
-        "app/javascript/packs/super/application.js.erb"
-      )
+      path =
+        if Gem::Dependency.new("webpacker", ">= 6.0.0.beta2", "!= 6.0.0.pre1", "!= 6.0.0.pre2").matching_specs.any?
+          "app/packs/entrypoints/super/application.js.erb"
+        else
+          "app/javascript/packs/super/application.js.erb"
+        end
+
+      template("pack_super_application.js.erb", path)
     end
 
     def set_asset_handler_to_webpacker
@@ -16,7 +20,7 @@ module Super
         "config/initializers/super.rb",
         "  c.javascripts = Super::Assets.use_webpacker(c.javascripts)\n" \
         "  c.stylesheets = Super::Assets.use_webpacker(c.stylesheets)\n",
-        before: /\bend\b/
+        before: /^end\b/
       )
     end
 

data/lib/super.rb

@@ -31,7 +31,8 @@ require "super/form/schema_types"
 require "super/form/strong_params"
 require "super/layout"
 require "super/link"
-require "super/navigation/automatic"
+require "super/link_builder"
+require "super/navigation"
 require "super/pagination"
 require "super/panel"
 require "super/partial"

data/lib/super/assets.rb

@@ -21,7 +21,7 @@ module Super
       assets.map do |asset|
         grep_matches = grep && asset === grep
         if grep_matches || !grep
-          asset.instance_variable_set(:@handler, Handler.webpacker)
+          asset.send(:handler=, Handler.webpacker)
         end
 
         asset
@@ -34,7 +34,7 @@ module Super
       assets.map do |asset|
         grep_matches = grep && asset === grep
         if grep_matches || !grep
-          asset.instance_variable_set(:@asset_handler, Handler.sprockets)
+          asset.send(:handler=, Handler.sprockets)
         end
 
         asset
@@ -52,6 +52,14 @@ module Super
       attr_reader :path
       attr_reader :arguments
 
+      def ==(other)
+        return false if handler != other.handler
+        return false if path != other.path
+        return false if arguments != other.arguments
+
+        true
+      end
+
       def ===(other)
         return true if path == other
         return true if other.is_a?(Regexp) && path.match?(other)
@@ -61,6 +69,10 @@ module Super
 
         false
       end
+
+      private
+
+      attr_writer :handler
     end
 
     def self.dist(gem_name, package_name)
@@ -74,29 +86,34 @@ module Super
     end
 
     class Handler
-      def self.auto
-        @auto ||=
-          if Gem::Dependency.new("sprockets", "~> 4.0").matching_specs.any?
-            sprockets
-          elsif Gem::Dependency.new("sprockets", "~> 3.0").matching_specs.any?
-            sprockets
-          elsif Gem::Dependency.new("sprockets", "~> 2.0").matching_specs.any?
-            sprockets
-          elsif Gem::Dependency.new("webpacker", "~> 6.0").matching_specs.any?
-            webpacker
-          elsif Gem::Dependency.new("webpacker", "~> 5.0").matching_specs.any?
-            webpacker
-          elsif Gem::Dependency.new("webpacker", "~> 4.0").matching_specs.any?
-            webpacker
-          elsif Gem::Dependency.new("webpacker", "~> 3.0").matching_specs.any?
-            webpacker
-          else
-            none
+      class << self
+        def auto
+          sprockets_spec = gem_specification("sprockets")
+          if sprockets_spec
+            major = sprockets_spec.version.segments.first
+            if major >= 2
+              return sprockets
+            end
+          end
+
+          webpacker_spec = gem_specification("webpacker")
+          if webpacker_spec
+            major = webpacker_spec.version.segments.first
+            if major >= 4
+              return webpacker
+            end
           end
-      end
 
-      def self.sprockets_available?
-        Gem::Dependency.new("sprockets").matching_specs.any? && defined?(Sprockets)
+          none
+        end
+
+        def sprockets_available?
+          !gem_specification("sprockets").nil? && defined?(Sprockets)
+        end
+
+        def gem_specification(gem_name)
+          Gem::Dependency.new(gem_name).matching_specs&.sort_by(&:version)&.first
+        end
       end
 
       def self.sprockets
@@ -115,6 +132,10 @@ module Super
         @asset_handler = asset_handler
       end
 
+      def ==(other)
+        to_sym == other.to_sym
+      end
+
       def sprockets?
         @asset_handler == :sprockets
       end

data/lib/super/cheat.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Super
+  class Cheat
+    def controls
+      paths = %w[controls.rb controls/optional.rb controls/steps.rb controls/view.rb]
+      methods =
+        paths
+        .map { |f| File.read(File.join(__dir__, f)) }
+        .flat_map { |content| content.scan(/^\s+def .*$/) }
+        .map { |method| method.strip.sub(/^def /, "#") }
+
+      puts "== Super::Controls"
+      puts methods.join("\n")
+    end
+  end
+end

data/lib/super/compatibility.rb

@@ -23,5 +23,24 @@ module Super
         ActiveRecord::Base.sanitize_sql_like(query)
       end
     end
+
+    def polymorphic_path_container
+      if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR == 0
+        @polymorphic_path_container ||=
+          begin
+            klass = Class.new do
+              include ActionDispatch::Routing::PolymorphicRoutes
+
+              def method_missing(method_name)
+                Rails.application.routes.url_helpers.public_send(method_name)
+              end
+            end
+
+            klass.new
+          end
+      else
+        Rails.application.routes.url_helpers
+      end
+    end
   end
 end

data/lib/super/link.rb

@@ -22,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?" }
@@ -91,27 +91,33 @@ module Super
       @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