duck_map 0.8.3 → 0.8.4

data/lib/duck_map/filter_stack.rb

@@ -6,9 +6,8 @@ module DuckMap
   ##################################################################################
   class FilterStack
 
-    #DEFAULT_FILTER = {actions: [:new, :create, :edit, :update, :destroy],
-                        #verbs: [:post, :put, :delete], names: [], controllers: []}
-    DEFAULT_FILTER = {actions: [:index, :show], verbs: [], names: [], controllers: []}
+    DEFAULT_FILTER = {exclude: {actions: [], controllers: [], names: [], verbs: [:delete, :post, :put]},
+                      include: {actions: [:index, :show], controllers: [], names: [], verbs: []}}
 
     ##################################################################################
     def initialize
@@ -41,10 +40,16 @@ module DuckMap
     # Copies a filter
     # @return [Hash]
     def copy_filter(filter)
-      buffer = {}
-      filter.each do |part|
-        buffer[part[0]] = part[1].dup
+      buffer = {exclude: {}, include: {}}
+
+      filter[:exclude].each do |part|
+        buffer[:exclude][part[0]] = part[1].dup
+      end
+
+      filter[:include].each do |part|
+        buffer[:include][part[0]] = part[1].dup
       end
+
       return buffer
     end
 
@@ -79,6 +84,37 @@ module DuckMap
       return nil
     end
 
+    ##################################################################################
+    # Clears all types (:actions, :verbs, :names, :controllers) for the {#current_filter}.
+    # @return [Nil]
+    def clear_filters
+      self.current_filter = {exclude: {actions: [], verbs: [], names: [], controllers: []},
+                              include: {actions: [], verbs: [], names: [], controllers: []}}
+      return nil
+    end
+
+    ##################################################################################
+    # Clears a single type of filter.
+    # @param [Symbol]        section  The section of filter to update. :exclude or :include.
+    # @param [Symbol]        key      The key of filter to update. :actions, :verbs, :names, :controllers.
+    # @return [Nil]
+    def clear_filter(section, key)
+      key = key.kind_of?(Symbol) ? key : key.to_sym
+      self.current_filter[section][key] = []
+      return nil
+    end
+
+    ##################################################################################
+    # Removes value(s) from the {#current_filter}.  Basically, the opposite of {#include_filter}.
+    # @overload exclude_filter(key, value)
+    #   @param [Symbol, String]        key    The type of filter to update. :actions, :verbs, :names, :controllers.
+    #   @param [String, Symbol, Array] value  A single or Array of items to be added to the filter section specified via key.
+    # @return [NilClass]
+    def exclude_filter(*args)
+      args.insert(0, :exclude)
+      return update_filter(*args)
+    end
+
     ##################################################################################
     # Adds a value(s) to the {#current_filter}.  The filter stack is implemented as an Array of Hashes.
     # The {#current_filter} will always be a Hash of key/value pairs.  Each key represents a type of filter:
@@ -152,47 +188,28 @@ module DuckMap
         end
       end
 
-      if action == :include
+      self.current_filter[action][key].concat(list)
+      self.current_filter[action][key].uniq!
 
-        # now, simply concatenate the resulting list and make sure the final array is unique
-        self.current_filter[key].concat(list)
-        self.current_filter[key].uniq!
+      opposite_action = action.eql?(:exclude) ? :include : :exclude
 
-      elsif action == :exclude
+      self.current_filter[action][key].each do |value|
+#puts "action: #{action} key: #{key} value: #{value}"
+        self.current_filter[opposite_action][key].delete(value)
+      end
 
-        self.current_filter[key].reject! {|item| list.include?(item)}
+      #if action == :include
 
-      end
+        ## now, simply concatenate the resulting list and make sure the final array is unique
+        #self.current_filter[key].concat(list)
+        #self.current_filter[key].uniq!
 
-      return nil
-    end
+      #elsif action == :exclude
 
-    ##################################################################################
-    # Removes value(s) from the {#current_filter}.  Basically, the opposite of {#include_filter}.
-    # @overload exclude_filter(key, value)
-    #   @param [Symbol, String]        key    The type of filter to update. :actions, :verbs, :names, :controllers.
-    #   @param [String, Symbol, Array] value  A single or Array of items to be added to the filter section specified via key.
-    # @return [NilClass]
-    def exclude_filter(*args)
-      args.insert(0, :exclude)
-      return update_filter(*args)
-    end
+        #self.current_filter[key].reject! {|item| list.include?(item)}
 
-    ##################################################################################
-    # Clears all types (:actions, :verbs, :names, :controllers) for the {#current_filter}.
-    # @return [Nil]
-    def clear_filters
-      self.current_filter = {actions: [], verbs: [], names: [], controllers: []}
-      return nil
-    end
+      #end
 
-    ##################################################################################
-    # Clears a single type of filter.
-    # @param [Symbol, String]        key    The type of filter to update. :actions, :verbs, :names, :controllers.
-    # @return [Nil]
-    def clear_filter(key)
-      key = key.kind_of?(Symbol) ? key : key.to_sym
-      self.current_filter[key] = []
       return nil
     end
 

data/lib/duck_map/mapper.rb

@@ -156,8 +156,8 @@ module DuckMap
     end
 
     ##################################################################################
-    def clear_filter(key)
-      @set.sitemap_filters.clear_filter(key)
+    def clear_filter(section, key)
+      @set.sitemap_filters.clear_filter(section, key)
     end
 
     ##################################################################################

data/lib/duck_map/route_filter.rb

@@ -1,10 +1,3 @@
-# the rule is the filter criteria acts as a list of things to include.  period.
-# include methods will add to the list of criteria to include.
-# exclude methods will remove from the list of criteria to include.
-# for route level evaluations, the list of criteria to include is empty.  therefore, meaning nothing is included.
-# the include attributes are added to the list of criteria to include, then, the exclude attributes are processed
-# to remove attributes from the list of criteria to include.
-# this will match the default behavior of nothing being included unless explicitly included.
 require 'active_support/concern'
 
 module DuckMap
@@ -90,19 +83,35 @@ module DuckMap
 
           end
 
-          if match_any?(route.action_name, self.sitemap_filters.current_filter[:actions])
+          if match_any?(route.action_name, self.sitemap_filters.current_filter[:exclude][:actions])
+            raise ExplicitExclude, "exclude"
+          end
+
+          if match_any?(route.verb_symbol, self.sitemap_filters.current_filter[:exclude][:verbs])
+            raise ExplicitExclude, "exclude"
+          end
+
+          if match_any?(route.controller_name, self.sitemap_filters.current_filter[:exclude][:controllers])
+            raise ExplicitExclude, "exclude"
+          end
+
+          if match_any?(route.name, self.sitemap_filters.current_filter[:exclude][:names])
+            raise ExplicitExclude, "exclude"
+          end
+
+          if match_any?(route.action_name, self.sitemap_filters.current_filter[:include][:actions])
             raise ExplicitInclude, "include"
           end
 
-          if match_any?(route.verb_symbol, self.sitemap_filters.current_filter[:verbs])
+          if match_any?(route.verb_symbol, self.sitemap_filters.current_filter[:include][:verbs])
             raise ExplicitInclude, "include"
           end
 
-          if match_any?(route.controller_name, self.sitemap_filters.current_filter[:controllers])
+          if match_any?(route.controller_name, self.sitemap_filters.current_filter[:include][:controllers])
             raise ExplicitInclude, "include"
           end
 
-          if match_any?(route.name, self.sitemap_filters.current_filter[:names])
+          if match_any?(route.name, self.sitemap_filters.current_filter[:include][:names])
             raise ExplicitInclude, "include"
           end
 
@@ -122,6 +131,9 @@ module DuckMap
           DuckMap.logger.debug %(#{"Duckmap Include".rjust(30)} -> #{e})
           value = true
 
+        rescue ExplicitExclude => e
+          DuckMap.logger.debug %(#{"Explicit Exclude".rjust(30)} -> #{e})
+
         rescue ExplicitInclude => e
           DuckMap.logger.debug %(#{"Explicit Include".rjust(30)} -> #{e})
           value = true

data/lib/duck_map/version.rb

@@ -1,3 +1,3 @@
 module DuckMap
-  VERSION = "0.8.3"
+  VERSION = "0.8.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duck_map
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-24 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline