duck_map 0.8.0

data/lib/duck_map/controller_helpers.rb

@@ -0,0 +1,206 @@
+require 'active_support/concern'
+
+module DuckMap
+
+  ##################################################################################
+# NOT empty anymore...
+  # This module is empty on purpose.  Sitemap::Mapper will create a sitemap method on this
+  # module when a sitemap is actually created via config/routes.rb.  This module is included in the SitemapBaseController
+  # and therefore will have all of the methods defined via config/routes.rb.
+  # Originally, methods were defined directly on SitemapBaseController, however, it was creating
+  # some wierd problems during development.  Meaning, if you tried to edit and refresh (Rails standard)
+  # the Rails stack would blow up.  Adding the methods to a module and including the module seemed to fix
+  # the problem.
+  module SitemapControllerHelpers
+
+    ##################################################################################
+    def sitemap_build(request_path = nil)
+
+      self.sitemap_model = []
+
+      begin
+
+        request_path = request_path.blank? ? request.path : request_path
+
+        sitemap_route = Rails.application.routes.find_sitemap_route(request_path)
+        unless sitemap_route.blank?
+          Rails.application.routes.sitemap_routes(sitemap_route).each do |route|
+
+          begin
+
+            DuckMap.logger.info "processing route:  name: #{route.name}  controller: #{route.controller_name}  action: #{route.action_name}"
+
+            clazz = ClassHelpers.get_controller_class(route.controller_name)
+
+            if clazz.blank?
+              DuckMap.logger.debug "sorry, could not determine controller class...: route name: #{route.name} controller: #{route.controller_name}  action: #{route.action_name}"
+            else
+
+              controller_object = clazz.new
+              controller_object.request = request
+              controller_object.response = ActionDispatch::Response.new
+
+              begin
+
+                options = { action_name: route.action_name,
+                            controller_name: route.controller_name,
+                            model: ClassHelpers.get_model_class(route.controller_name),
+                            route: route,
+                            source: :sitemap}
+
+                rows = controller_object.sitemap_setup(options)
+                if rows.kind_of?(Array) && rows.length > 0
+                  self.sitemap_model.concat(rows)
+                end
+
+              rescue Exception => e
+                DuckMap.logger.exception(e)
+              end
+
+            end
+
+          rescue Exception => e
+            DuckMap.logger.exception(e)
+          end
+
+          end
+        end
+
+        self.sitemap_model.each do |item|
+          unless item[:lastmod].kind_of?(String)
+            item[:lastmod] = item[:lastmod].to_s(:sitemap)
+          end
+        end
+
+      rescue Exception => e
+        DuckMap.logger.exception(e)
+      end
+
+      return nil
+    end
+
+  end
+
+  ##################################################################################
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    ##################################################################################
+    # Determines all of the attributes defined for a controller, then, calls the handler method on the controller
+    # to generate and return an Array of Hashes representing all of the url nodes to be included in the sitemap
+    # for the current route being processed.
+    # @return [Array] An Array of Hashes.
+    def sitemap_setup(options = {})
+      rows = []
+
+      DuckMap.logger.debug "sitemap_setup: action_name => #{options[:action_name]} source => #{options[:source]} model => #{options[:model]}"
+
+      attributes = self.sitemap_attributes(options[:action_name])
+
+      DuckMap.logger.debug "sitemap_setup: attributes => #{attributes}"
+
+      if attributes.kind_of?(Hash) && attributes[:handler].kind_of?(Hash) && !attributes[:handler][:action_name].blank?
+        config = {handler: attributes[:handler]}.merge(options)
+        rows = self.send(attributes[:handler][:action_name], config)
+      end
+
+      return rows
+    end
+
+    ##################################################################################
+    # Returns the current value of the instance variable {#sitemap_meta_data}.
+    def sitemap_meta_data
+      unless defined?(@sitemap_meta_data)
+        @sitemap_meta_data = {}
+        self.sitemap_setup({action_name: action_name,
+                            controller_name: controller_name,
+                            route: nil,
+                            source: :meta_data})
+      end
+      return @sitemap_meta_data
+    end
+
+    def sitemap_meta_data=(value)
+      @sitemap_meta_data = value
+    end
+
+    ##################################################################################
+    def find_first_model_object
+      model_object = self.find_model_object
+
+      if model_object.kind_of?(Array) && model_object.first.kind_of?(ActiveRecord::Base)
+        model_object = model_object.first
+      end
+
+      return model_object
+    end
+
+    ##################################################################################
+    def find_model_object
+      model_object = nil
+      candidate = nil
+      skip_vars = ["@_config",
+                    "@view_renderer",
+                    "@_routes",
+                    "@_assigns",
+                    "@_request",
+                    "@view_flow",
+                    "@output_buffer",
+                    "@virtual_path"]
+
+      list = self.instance_variables.map.find_all {|x| !skip_vars.include?(x.to_s)}
+
+      list.each do |obj_sym|
+        obj = self.instance_variable_get(obj_sym)
+        if obj
+          if obj.kind_of?(ActiveRecord::Base)
+            model_object = obj
+            break
+          elsif obj.kind_of?(Array) &&
+                obj.first.kind_of?(ActiveRecord::Base) &&
+                candidate.blank?
+            candidate = obj
+          end
+        end
+      end
+
+      if model_object.blank? && !candidate.blank?
+        model_object = candidate
+      end
+
+      return model_object
+    end
+
+    ##################################################################################
+    # Returns the date / time value from config/locale/sitemap.yml associated with the current controller / action.
+    # The static date/times are actual timestamps extracted from the date of the view on disk and from a .git repository if used.
+    # Be sure to run the generator or rake task: duck_map:sync to populate the locale file at: config/locale/sitemap.yml
+    # @return [DateTime] The timestamp associated with the controller / action.
+    def sitemap_static_lastmod(my_controller_name = nil, my_action_name = nil)
+      value = nil
+
+      unless my_controller_name.blank? || my_action_name.blank?
+
+        unless my_controller_name.blank?
+          my_controller_name = my_controller_name.underscore
+          my_controller_name = my_controller_name.gsub("/", ".")
+        end
+
+        begin
+
+          value = I18n.t("#{my_controller_name.downcase}.#{my_action_name.downcase}", default: "", locale: :sitemap)
+
+        rescue Exception => e
+          DuckMap.logger.exception(e)
+        end
+
+        value = value.blank? ? nil : LastMod.to_date(value)
+
+      end
+
+      return value
+    end
+
+  end
+
+end

data/lib/duck_map/engine.rb

@@ -0,0 +1,92 @@
+require 'journey'
+
+module DuckMap
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+
+    autoload :ActionViewHelpers, 'duck_map/view_helpers'
+    autoload :ArrayHelper, 'duck_map/array_helper'
+    autoload :Attributes, 'duck_map/attributes'
+    autoload :ClassHelpers, 'duck_map/class_helpers'
+    autoload :Config, 'duck_map/config'
+    autoload :ConfigHelpers, 'duck_map/config'
+    autoload :ControllerHelpers, 'duck_map/controller_helpers'
+    autoload :Expressions, 'duck_map/expressions'
+    autoload :FilterStack, 'duck_map/filter_stack'
+    autoload :Handlers, 'duck_map/handlers/base'
+    autoload :InheritableClassAttributes, 'duck_map/attributes'
+    autoload :LastMod, 'duck_map/last_mod'
+    autoload :List, 'duck_map/list'
+    autoload :Logger, 'duck_map/logger'
+    autoload :Mapper, 'duck_map/mapper'
+    autoload :Model, 'duck_map/model'
+    autoload :Route, 'duck_map/route'
+    autoload :RouteFilter, 'duck_map/route_filter'
+    autoload :RouteSet, 'duck_map/route_set'
+    autoload :SitemapControllerHelpers, 'duck_map/controller_helpers'
+    autoload :SitemapHelpers, 'duck_map/view_helpers'
+    autoload :SitemapObject, 'duck_map/sitemap_object'
+    autoload :Static, 'duck_map/static'
+    autoload :Sync, 'duck_map/sync'
+    autoload :Version, 'duck_map/version'
+
+  end
+
+  class DuckMapEngine < Rails::Engine
+
+#     # this is so I can develop the gem
+#     # run dev.com, make changes to files in lib/duck_captcha, refresh browser.
+#     unless Rails.env.to_sym.eql?(:production)
+#       auto_path_spec = File.expand_path(File.dirname(__FILE__))
+#       config.autoload_paths << auto_path_spec.slice(0, auto_path_spec.rindex("/"))
+#     end
+
+    initializer "duck_map" do
+      Time::DATE_FORMATS.merge!(meta: "%a, %d %b %Y %H:%M:%S %Z",
+                                sitemap: "%Y-%m-%dT%H:%M:%S+00:00",
+                                sitemap_locale: "%m/%d/%Y %H:%M:%S",
+                                seo: "%a, %d %b %Y %H:%M:%S %Z")
+    end
+
+    Journey::Route.send :include, Route
+
+    ActionDispatch::Routing::RouteSet.send :include, RouteSet
+    ActionDispatch::Routing::RouteSet.send :include, RouteFilter
+
+    ActionDispatch::Routing::Mapper.send :include, ConfigHelpers
+    ActionDispatch::Routing::Mapper.send :include, Mapper
+    ActionDispatch::Routing::Mapper.send :include, MapperMethods
+
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Base.send :include, InheritableClassAttributes
+      ActiveRecord::Base.send :include, Attributes
+      ActiveRecord::Base.send :include, SitemapObject
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.send :include, InheritableClassAttributes
+      ActionController::Base.send :include, Attributes
+      ActionController::Base.send :include, ControllerHelpers
+      ActionController::Base.send :include, Handlers::Base
+      ActionController::Base.send :include, Handlers::Index
+      ActionController::Base.send :include, Handlers::Show
+      ActionController::Base.send :include, Model
+      ActionController::Base.send :include, SitemapObject
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      ActionView::Base.send :include, ActionViewHelpers
+    end
+
+  end
+
+  def self.logger
+    return Logger.logger
+  end
+
+  def self.console(msg)
+    logger.console msg
+  end
+
+end

data/lib/duck_map/filter_stack.rb

@@ -0,0 +1,200 @@
+# DONE
+require 'active_support/concern'
+
+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: []}
+
+    ##################################################################################
+    def initialize
+      super
+      self.reset
+    end
+
+    ##################################################################################
+    # A Hash containing all of the values for exlude sitemap_filters.
+    # @return [Hash]
+    def stack
+      return @stack ||= []
+    end
+
+    ##################################################################################
+    # Sets the entire Hash for exclude sitemap_filters.
+    # @return [Nil]
+    def stack=(value)
+      @stack = value
+    end
+
+    ##################################################################################
+    # Resets the stack.
+    # @return [NilClass]
+    def reset
+      self.stack = [copy_filter(DEFAULT_FILTER)]
+    end
+
+    ##################################################################################
+    # Copies a filter
+    # @return [Hash]
+    def copy_filter(filter)
+      buffer = {}
+      filter.each do |part|
+        buffer[part[0]] = part[1].dup
+      end
+      return buffer
+    end
+
+    ##################################################################################
+    # Pushes a copy of the current filter onto the end of the stack.
+    # @return [Hash]
+    def push
+      self.stack.push(copy_filter(self.current_filter))
+    end
+
+    ##################################################################################
+    # Pops the last item from the stack.  However, the list can never be empty, so, it pops
+    # the last item ONLY if the stack has more than ONE item.
+    # @return [Hash]
+    def pop
+      return self.stack.length > 1 ? self.stack.pop : self.current_filter
+    end
+
+    ##################################################################################
+    # Returns the current filter.  The current filter is ALWAYS the last item in the stack.
+    # @return [Hash]
+    def current_filter
+      return self.stack.last
+    end
+
+    ##################################################################################
+    # Sets the entire Hash for the {#current_filter}.
+    # @return [NilClass]
+    def current_filter=(value)
+      self.stack.pop
+      self.stack.push(value)
+      return nil
+    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:
+    #
+    # The filter types are:
+    # - :actions
+    # - :verbs
+    # - :names
+    # - controllers
+    #
+    # Each key has an associated Array of Strings or Symbols.  The default filter is:
+    #
+    #     {actions: [:index, :show], verbs: [:get], names: [], controllers: []}
+    #
+    # The default is to include all routes that have an :action of :index or :show or include routes that have
+    # a verb of :get.  Basically, including urls that a search engine would crawl.
+    # The Array of values added to the filter can be mixed. However, the convention is to use Symbols for
+    # :actions and :verbs and use Strings for :names and :controllers.  Values are automagically converted to Symbols
+    # if the key is :actions or :verbs.
+    #
+    #     include_filter(:actions, :edit)              # => {actions: [:index, :show, :edit], verbs: [:get], names: [], controllers: []}
+    #     include_filter(:actions, [:edit, :update])   # => {actions: [:index, :show, :edit, :update], verbs: [:get], names: [], controllers: []}
+    #     include_filter(:actions, "edit")             # => {actions: [:index, :show, :edit], verbs: [:get], names: [], controllers: []}
+    #     include_filter(:actions, ["edit", "update"]) # => {actions: [:index, :show, :edit], verbs: [:get], names: [], controllers: []}
+    #     include_filter(:actions, [:edit, "update"])  # => {actions: [:index, :show, :edit], verbs: [:get], names: [], controllers: []}
+    #     include_filter(:verbs, :post)                # => {actions: [:index, :show], verbs: [:get, :post], names: [], controllers: []}
+    #
+    # @overload include_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 include_filter(*args)
+      args.insert(0, :include)
+      return update_filter(*args)
+    end
+
+    ##################################################################################
+    # Adds or removes value(s) to or from the {#current_filter}.  This method is called by {#include_filter} and {#exclude_filter}.
+    # @overload update_filter(action, key, value)
+    #   @param [Symbol, String]        action The action to perform:  :include or :exclude.
+    #   @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 update_filter(*args)
+
+      action = args.shift
+      action = action.kind_of?(Symbol) ? action : action.to_sym
+
+      key = args.shift
+      key = key.kind_of?(Symbol) ? key : key.to_sym
+
+      # list will always be concatenated to the target array
+      list = []
+
+      # build the list array depending on what the user passed to the method
+      args.each do |item|
+        if item.kind_of?(Array) && item.any?
+          list.concat(item)
+        else
+          list.push(item)
+        end
+      end
+
+      # convert all of the items in the list to symbols
+      # for :actions or :verbs
+      if key.eql?(:actions) || key.eql?(:verbs)
+        list.each_with_index do |item, index|
+          unless item.kind_of?(Symbol)
+            list[index] = item.to_sym
+          end
+        end
+      end
+
+      if action == :include
+
+        # 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!
+
+      elsif action == :exclude
+
+        self.current_filter[key].reject! {|item| list.include?(item)}
+
+      end
+
+      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
+
+    ##################################################################################
+    # 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
+
+    ##################################################################################
+    # 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
+
+  end
+end

data/lib/duck_map/handlers/base.rb

@@ -0,0 +1,102 @@
+require 'active_support/concern'
+
+module DuckMap
+  module Handlers
+
+    autoload :Index, "duck_map/handlers/index"
+    autoload :Show, "duck_map/handlers/show"
+
+    ##################################################################################
+    # Base module containing common code for all sitemap handler modules.
+    module Base
+      extend ActiveSupport::Concern
+
+      ##################################################################################
+      # Finds the first instance of a model object on the current controller object.
+      # sitemap_first_model will respect the current setting of :first_model.  If :first_model
+      # is true, then, it will continue the search and return the first instance of a model object
+      # on the current controller object.  Otherwise, it will return nil.
+      #
+      # @param [Hash] handler   The handler Hash of a sitemap configuration.
+      # @return [ActiveRecord::Base]
+      def sitemap_first_model(handler = {})
+        value = nil
+
+        begin
+
+          # determine if we are suppose to look for the first model on the current controller.
+          if handler.kind_of?(Hash) && handler[:first_model]
+
+            first_model_object = self.find_first_model_object
+
+            unless first_model_object.blank?
+              value = first_model_object
+            end
+
+          end
+
+        rescue Exception => e
+          # expect this exception to occur EVERYTIME...
+        end
+
+        return value
+      end
+
+      ##################################################################################
+      # Returns a copy of the current values held by {DuckMap::Config.attributes}
+      # @return [Hash]
+      def sitemap_defaults(options = {})
+        return DuckMap::Config.copy_attributes
+      end
+
+      ##################################################################################
+      # Applies the current url limit to a result set.  This is really a helper method used
+      # by all of the handler methods that return a Array of Hashes numbering greater than one.
+      # Handler methods that would normally return one row need not use this helper method.
+      # Use it if you implement a custom handler method.
+      # @param [Array] rows         An Array of Hashes representing the contents of a sitemap.
+      # @param [Hash] options       The :handler section of a sitemap configuration.
+      # @option options [Symbol]    :url_limit    An integer limiting the number of rows to return.
+      # @return [Array]
+      def sitemap_url_limit(rows, options = {})
+
+        unless options[:url_limit].blank?
+          if rows.length > options[:url_limit]
+            rows.slice!(options[:url_limit], rows.length)
+          end
+        end
+
+        return rows
+      end
+
+      ##################################################################################
+      # @return [Hash]
+      def sitemap_url_options(options = {})
+        values = {}
+
+        unless options[:url_format].blank?
+          values[:format] = options[:url_format]
+        end
+
+        return values.merge(sitemap_host_options(options))
+      end
+
+      ##################################################################################
+      # @return [Hash]
+      def sitemap_host_options(options = {})
+        values = {}
+
+        unless options[:canonical_host].blank?
+          values[:host] = options[:canonical_host]
+        end
+        unless options[:canonical_port].blank?
+          values[:port] = options[:canonical_port]
+        end
+
+        return values
+      end
+
+    end
+
+  end
+end