menuable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7cd924adb10768078fdf03b62129b6bfd9a90ef7425777cc94d4bfa6fbd4ed7
-  data.tar.gz: 24f889651399a85900f5e6b18ca57a02e5fa129137021c45f94bc3c9c98ab8b1
+  metadata.gz: f0c4ea54013a825585c4b87cdf3e25e54d82c04b1b6aab36b436ac2cc588a3d1
+  data.tar.gz: 2b635cf422c7eed2068b5e1fad5fcb0518ca1f8402f7237a04971dab84f5ca0f
 SHA512:
-  metadata.gz: 15bd6260b99ffffab22ea211731a17c85ae5bb35978d78e5e7dac0d2b3a4112c24df2be5ec92f50898c4084dc70b9a95dcf942d8023dfe0210f9c45d3dffb9b7
-  data.tar.gz: 681c86be7c17653563d8f00ca77a841c5bacc2aacd4762ea61b10a278a499eafb03d995ba46d65ea7f96de0a09d77a40c3490f9640dba7267415bcf3dc4ddd27
+  metadata.gz: 650d34d9d2699828ea17994775f6f9230e1229bb853c2bbd87d354871a4e7d7ce83e26f4bc897e91e5a61e3663264511240a4a0fbeee400dd6351b20e7e30759
+  data.tar.gz: c5625b3c58e74e01a09f803088cd9b443113284d769fe6987bea16e3f461d9a5b73b4dad95c400c75132eabcdac028852b614441ae04e552d93bc186e672bf7a

data/lib/menuable/version.rb

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

data/lib/menuable.rb

@@ -7,44 +7,48 @@ 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, &block)
+      resources(resource_name, single: true, **options, &block)
+    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
 
   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
 
@@ -56,14 +60,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
@@ -111,17 +116,33 @@ module Menuable
   end
 
   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 +155,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: menuable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Masa (Aileron inc)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-17 00:00:00.000000000 Z
+date: 2023-07-18 00:00:00.000000000 Z
 dependencies: []
 description: 'This library provides menu.yml and controller macros to manage routes
   and sidebar implementations when implementing management functions in rails.