menuable 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7cd924adb10768078fdf03b62129b6bfd9a90ef7425777cc94d4bfa6fbd4ed7
-  data.tar.gz: 24f889651399a85900f5e6b18ca57a02e5fa129137021c45f94bc3c9c98ab8b1
+  metadata.gz: f3e428de3e6e6e19e26e5eebbdf163677fc2dac048610e572a0c1c9e8473375f
+  data.tar.gz: abdd56584c6ceeb8854dceea90bad7c41134b28c3211c2d4ae5a6a99c4415e0f
 SHA512:
-  metadata.gz: 15bd6260b99ffffab22ea211731a17c85ae5bb35978d78e5e7dac0d2b3a4112c24df2be5ec92f50898c4084dc70b9a95dcf942d8023dfe0210f9c45d3dffb9b7
-  data.tar.gz: 681c86be7c17653563d8f00ca77a841c5bacc2aacd4762ea61b10a278a499eafb03d995ba46d65ea7f96de0a09d77a40c3490f9640dba7267415bcf3dc4ddd27
+  metadata.gz: 410d422e140b3e3f922a763df3086cf982c31cb18e5dcda9d4203189a383ef7af55bb1ac18922fdf1853849eb2dda14ae9e4f241941979266ea449d97f44a6a6
+  data.tar.gz: b1c01be9f31432e70d7b5667361b54ed414ab9b19d09f01f74ca6cb672af7c31c4d869560f422ad2c53150d67dcb3af0a1c4b36e2dda3ecefa45789ef489233e

data/.rubocop.yml

@@ -1,5 +1,11 @@
+require:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
 AllCops:
   TargetRubyVersion: 3.2.2
+  NewCops: enable
 
 Style/StringLiterals:
   Enabled: true

data/lib/menuable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Menuable
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/menuable.rb

@@ -3,51 +3,65 @@
 require_relative "menuable/version"
 require "active_support/all"
 
+#
+# Menuable is a module for dynamically generating sidemenus
+#
 module Menuable
   extend ActiveSupport::Concern
 
   class_methods do
-    def menu(resource_name, &block)
-      namespace = self.name.to_s.deconstantize.constantize
+    def resource(resource_name, **options, &)
+      resources(resource_name, single: true, **options, &)
+    end
+
+    def resources(resource_name, single: false, **options, &block)
+      namespace = name.to_s.deconstantize.constantize
 
       menu = Class.new(MenuDefinition)
-      menu.namespace =
-        self.name.split("::").try do |token|
-          token.shift
-          token.pop
-          token.first&.underscore
-        end
+      menu.options = options
+      menu.single = single
       menu.resource_name = resource_name
       menu.model_name = ActiveModel::Name.new(nil, nil, "#{namespace}/#{resource_name.to_s.classify}")
       menu.instance_eval(&block) if block
 
-      self.class_eval do
+      class_eval do
         class_attribute :menu, default: menu
       end
     end
   end
 
+  #
+  # Value to set from controller
+  #
   class MenuDefinition
-    class_attribute :namespace
+    class_attribute :options
     class_attribute :resource_name
     class_attribute :model_name
-    class_attribute :name
+    class_attribute :single
 
     NOTHING = ->(_) { true }
 
+    def self.single?
+      single
+    end
+
     def self.loyalty(&value)
       return (@loyalty || NOTHING) if value.nil?
 
       @loyalty = value
     end
 
-    def self.member_actions(values = nil)
-      return Array(@member_actions) if values.nil?
+    def self.actions(&value)
+      return @actions if value.nil?
 
-      @member_actions = values
+      @actions = value
     end
   end
 
+  #
+  # A class for binding with view_content to convert the settings defined in yaml
+  # into something that can actually be used
+  #
   class MenuContext
     attr_reader :context
 
@@ -56,14 +70,15 @@ module Menuable
       @context = context
     end
 
-    def each
+    def each # rubocop:todo Metrics/MethodLength
+      return enum_for(:each) unless block_given?
+
       @menus.each do |config|
         case config
         in divider:
           yield config
-        in group:
-          items = config[:items].filter_map { |item| menu(item) }
-          yield menu({ **config, items: })
+        in items:
+          yield menu({ **config, items: items.filter_map { |item| menu(item) } })
         else
           menu(config).try { yield _1 }
         end
@@ -84,7 +99,7 @@ module Menuable
       path || config[:path] || "/"
     end
 
-    def active?(menu)
+    def active?(menu) # rubocop:todo Metrics/MethodLength
       case menu
       in items:
         items.any? do |item|
@@ -110,18 +125,37 @@ module Menuable
     end
   end
 
+  #
+  # The actual state of the definition body that reads YAML
+  #
   class Menu
-    def initialize(namespace, path)
-      @controllers = []
+    def initialize(namespace, path) # rubocop:todo Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      extract_namespace = lambda do |name|
+        if name
+          namespaces = name.split("/")
+          namespaces.pop
+          namespaces
+        else
+          []
+        end
+      end
+
+      @controllers = {}
       @menus = YAML.load_file(path).map do |config|
         config.deep_symbolize_keys!
-        controller = "#{namespace}/#{config[:name]}_controller".classify.safe_constantize
-        @controllers << controller if controller
+        namespaces = extract_namespace.call(config[:name])
+        controller = "#{namespace}/#{config[:name]&.pluralize}_controller".classify.safe_constantize
+        @controllers[namespaces] ||= []
+        @controllers[namespaces] << controller if controller
+
         config[:items]&.each do |item|
-          item[:controller] = "#{namespace}/#{item[:name]}_controller".classify.safe_constantize
-          @controllers << item[:controller] if item[:controller]
+          item[:controller] = "#{namespace}/#{item[:name]&.pluralize}_controller".classify.safe_constantize
+          item_namespaces = extract_namespace.call(item[:name])
+          @controllers[item_namespaces] ||= []
+          @controllers[item_namespaces] << item[:controller] if item[:controller]
         end
-        { **config, controller: }
+
+        { **config, controller:, namespaces: }
       end
     end
 
@@ -134,29 +168,47 @@ module Menuable
     end
 
     def first(current_user:)
-      @controllers.each do |controller|
+      @controllers.values.flatten.each do |controller|
         break controller.menu if controller.menu.loyalty.call(current_user)
       end
     end
 
-    def routes(routing)
-      controllers = @controllers
-      routing.instance_eval do
-        controllers.each do |controller|
-          if controller.menu.namespace
-            namespace controller.menu.namespace do
-              resources controller.menu.resource_name do
-                controller.menu.member_actions.each do |action_name|
-                  get action_name, on: :member
+    def routes(routing) # rubocop:todo Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+      controller_mappings = @controllers
+      routing.instance_eval do # rubocop:todo Metrics/BlockLength
+        controller_mappings.each do |namespaces, controllers| # rubocop:todo Metrics/BlockLength
+          define =
+            controllers.map do |controller|
+              if controller.menu.single?
+                lambda do |router|
+                  router.resource controller.menu.resource_name do
+                    router.instance_eval(&controller.menu.actions) if controller.menu.actions
+                  end
+                end
+              else
+                lambda do |router|
+                  router.resources controller.menu.resource_name do
+                    router.instance_eval(&controller.menu.actions) if controller.menu.actions
+                  end
                 end
               end
             end
-          else
-            resources controller.menu.resource_name do
-              controller.menu.member_actions.each do |action_name|
-                get action_name, on: :member
+
+          case namespaces.length
+          when 3
+            namespace namespaces[0] do
+              namespace namespaces[1] do
+                namespace namespaces[2] { define.each { _1.call(self) } }
               end
             end
+          when 2
+            namespace namespaces[0] do
+              namespace(namespaces[1]) { define.each { _1.call(self) } }
+            end
+          when 1
+            namespace(namespaces[0]) { define.each { _1.call(self) } }
+          when 0
+            define.each { _1.call(self) }
           end
         end
       end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: menuable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Masa (Aileron inc)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-17 00:00:00.000000000 Z
-dependencies: []
+date: 2023-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'This library provides menu.yml and controller macros to manage routes
   and sidebar implementations when implementing management functions in rails.
 
@@ -38,6 +52,7 @@ metadata:
   homepage_uri: https://github.com/aileron-inc/menuable
   source_code_uri: https://github.com/aileron-inc/menuable
   changelog_uri: https://github.com/aileron-inc/menuable
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: