context.rb in human_routes-0.0.7

- old
+ new

@@ -14,17 +14,25 @@
     def controller_name
       @controller_name ||= options.delete(:name) { controller.to_s }
     end
 
     def singular_controller_name
-      @singular_controller_name ||= controller_name.singularize
+      @singular_controller_name ||= if options[:resource]
+                                      controller_name
+                                    else
+                                      controller_name.singularize
+                                    end
     end
 
     def resource?
-      controller_name == singular_controller_name
+      options[:resource] || controller_name == singular_controller_name
     end
 
+    def path_name
+      options[:path_name] || controller_name
+    end
+
     def routes
       @routes ||= []
     end
 
     def create(*args)
@@ -127,11 +135,11 @@
     def all
       create
       update
       remove
       show
-      list unless controller_name == controller_name.singularize
+      list unless resource?
     end
 
     def get(action, *args)
       path, name, options = extract_route_args(
         segment: action,
@@ -180,21 +188,26 @@
                       .merge(route_options)
 
       path = args.first || path_for(segment, route_options)
 
       path = [
-        route_options[:parent].to_s.split("/"),
+        route_options[:prefix].to_s.split("/"),
         path.to_s.split("/")
       ].flatten.compact
 
       path = path.map do |s|
         s.start_with?(":") ? s : s.dasherize
       end.join("/")
 
       name = route_options.delete(:as) { default_name.underscore.tr("/", "_") }
 
-      route_options.delete(:bare)
+      %i[
+        bare
+        prefix
+        path_name
+        resource
+      ].each {|key| route_options.delete(key) }
 
       [path, name, route_options]
     end
 
     private def default_options
@@ -214,24 +227,24 @@
 
       segments.compact.join("/")
     end
 
     private def resource_segments(segment, _param, options)
-      segments = [controller_name]
+      segments = [path_name]
       segments << segment unless options[:bare]
       segments
     end
 
     private def resources_segments(segment, param, _options)
       case segment
       when :list
-        [controller_name]
+        [path_name]
       when :new
-        [controller_name, segment]
+        [path_name, segment]
       when :show
-        [controller_name, ":#{param}"]
+        [path_name, ":#{param}"]
       else
-        [controller_name, ":#{param}", segment]
+        [path_name, ":#{param}", segment]
       end
     end
   end
 end