duck_map 0.8.0

data/lib/duck_map/static.rb

@@ -0,0 +1,146 @@
+module DuckMap
+
+  class SitemapStaticRequest < ActionDispatch::Request
+  end
+
+  class SitemapStaticResponse < ActionDispatch::Response
+  end
+
+  class ActionViewTestObject < ActionView::Base
+    include DuckMap::ActionViewHelpers
+    include DuckMap::SitemapControllerHelpers
+    include DuckMap::Model
+    include DuckMap::SitemapHelpers
+
+  end
+
+  ##################################################################################
+  class Static
+
+    ##################################################################################
+    def build(options = {})
+      key = options[:key].blank? ? :all : options[:key].to_s.downcase.to_sym
+
+      begin
+
+        attributes = DuckMap::Config.attributes
+
+        compressed = attributes[:compression].blank? ? :compressed : attributes[:compression]
+
+        # command line override config
+        compressed = options[:compression].blank? ? compressed : options[:compression]
+
+        compressed = compressed.blank? ? :compressed : compressed.to_s.downcase.to_sym
+        compressed = compressed.eql?(:compressed) ? true : false
+
+        static_host = attributes[:static_host].blank? ? attributes[:canonical_host] : attributes[:static_host]
+
+        # command line override config
+        static_host = options[:static_host].blank? ? static_host : options[:static_host]
+
+        static_port = attributes[:static_port].blank? ? attributes[:canonical_port] : attributes[:static_port]
+
+        # command line override config
+        static_port = options[:static_port].blank? ? static_port : options[:static_port]
+
+        static_target = attributes[:static_target].blank? ? File.join(Rails.root, "public") : attributes[:static_target]
+
+        # command line override config
+        static_target = options[:static_target].blank? ? static_target : options[:static_target]
+
+        if !static_host.blank?
+
+          request_options = {
+                              "rack.input" => StringIO.new,
+                              "rack.errors" => StringIO.new,
+                              "rack.multithread" => true,
+                              "rack.multiprocess" => true,
+                              "rack.run_once" => false,
+                              "CONTENT_TYPE" => "application/xml",
+                              "HTTP_HOST" => static_host,
+                              "SERVER_PORT" => static_port}
+
+          DuckMap.console "Searching for route: #{key}"
+
+          routes = []
+          if key.eql?(:all)
+
+            routes = Rails.application.routes.sitemap_routes_only
+
+          else
+
+            route = Rails.application.routes.find_route_via_name("#{key}_sitemap")
+            if route.blank?
+              DuckMap.console "Unable to find route: #{key}"
+            else
+              routes.push(route)
+            end
+
+          end
+
+          routes.each do |route|
+
+            DuckMap.console "Processing route: #{route.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 = clazz.new
+
+              controller.request = SitemapStaticRequest.new(request_options)
+              controller.response = SitemapStaticResponse.new
+
+              # man, I am getting lazy...
+              request_path = route.path.spec.to_s.gsub(":format", "xml")
+
+              controller.sitemap_build(request_path)
+
+              view = ActionViewTestObject.new(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "app", "views")))
+
+              view.controller = controller
+
+              view.assign(sitemap_model: controller.sitemap_model)
+
+              parts = request_path.split("/")
+              parts.insert(0, static_target)
+
+              file_spec = File.join(parts)
+
+              File.open(file_spec, "w") do |file|
+
+                file.write view.render(:template => "sitemap/default_template.xml.erb")
+
+              end
+
+              if compressed
+
+                Zlib::GzipWriter.open("#{file_spec}.gz") do |gz|
+                  gz.mtime = File.mtime(file_spec)
+                  gz.orig_name = file_spec
+                  gz.write IO.binread(file_spec)
+                end
+
+                FileUtils.rm_rf file_spec
+
+              end
+
+            end
+
+          end
+
+        else
+          DuckMap.console "Sorry, cannot build sitemap.  You need to set static_host in config/routes.rb or on the command-line..."
+        end
+
+      rescue Exception => e
+        puts "#{e.message}"
+        puts e.backtrace
+      end
+
+    end
+
+  end
+end

data/lib/duck_map/sync.rb

@@ -0,0 +1,192 @@
+module DuckMap
+
+  ##################################################################################
+  # Extracts the timestamp of each action for all of the controllers within the application
+  # and stores it in config/locales/sitemap.yml
+  class Sync
+    
+    ##################################################################################
+    # Extract and store timestamps for all of the actions in the in app.
+    # @param [Hash] options  An options Hash passed to the generator via the command line.
+    # returns [Nil]
+    def build(options = {})
+      DuckMap.logger.info "\r\n\r\n====================================================================="
+      DuckMap.logger.info "#{self.class.name} session begin at: #{Time.now}"
+      DuckMap.logger.info "options: #{options}"
+
+      verbose = options[:verbose].blank? ? false : true
+
+      # always replace ALL of the existing content, so, the list is always current.
+      # actions / views may have been deleted, renamed, etc.
+      content = {sitemap: {}}
+      grand_total = 0
+
+      # controllers full physical path for the current app.
+      base_dir = File.join(Rails.root, "app", "controllers").to_s
+
+      # this is a little bit complex.
+      # - traverse the entire directory structure for controllers.
+      # - for each
+      #   - inline gsub! to remove the base_dir.
+      #   - inline gsub! to remove _controller.
+      #   - then, prevent the application controller from making it into the list as
+      #     there should not be any actions / views for the application controller.
+
+
+      list = Dir["#{File.join(base_dir, "**", "*.rb")}"].each {|f| f.gsub!("#{base_dir}/", "").gsub!("_controller.rb", "")}.map.find_all {|x| x.eql?("application") ? false : true}
+
+      DuckMap.console "Total number of controllers found within the app: #{list.length}"
+      DuckMap.console "Views Controller"
+      DuckMap.console "-------------------------------------------------------------"
+
+      DuckMap.logger.show_console = verbose ? true : false
+
+      list.each do |controller|
+
+        file_spec = File.join("app", "views", controller)
+
+        clazz = "#{controller}_controller".camelize.constantize
+
+        DuckMap.console "===================================================================================="
+        DuckMap.console "controller: #{controller.ljust(30)}  path: #{file_spec}"
+
+        actions = {}
+        methods = clazz.action_methods
+
+        methods.each do |action|
+
+          latest_timestamp = nil
+          winner = nil
+
+          DuckMap.console "    action: #{action}"
+
+          Dir["#{File.join(file_spec, action)}.html.*"].each do |view|
+
+            begin
+              view_timestamp = File.stat(File.join(Rails.root, view)).mtime
+              if view_timestamp.blank?
+                DuckMap.console "          : cannot stat file: #{view}"
+              else
+
+                if latest_timestamp.blank? || view_timestamp > latest_timestamp
+                  latest_timestamp = view_timestamp
+                  winner = "timestamp from file"
+                  DuckMap.console "          : Using    file timestamp? YES #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
+                else
+                  DuckMap.console "          : Using    file timestamp? NO #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
+                end
+
+              end
+            rescue Exception => e
+              DuckMap.logger.debug "#{e}"
+            end
+
+            begin
+              output = %x(git log --format='%ci' -- #{view} | head -n 1)
+              if output.blank?
+                DuckMap.console "          : cannot get date from GIT for file: #{view}"
+              else
+
+                view_timestamp = LastMod.to_date(output)
+                if latest_timestamp.blank? || view_timestamp > latest_timestamp
+                  latest_timestamp = view_timestamp
+                  winner = "timestamp from GIT"
+                  DuckMap.console "          : Using     GIT timestamp? YES #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
+                else
+                  DuckMap.console "          : Using     GIT timestamp? NO #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
+                end
+
+              end
+            rescue Exception => e
+              DuckMap.logger.debug "#{e}"
+            end
+
+            begin
+              view_timestamp = LastMod.to_date(I18n.t("#{controller.gsub("/", ".")}.#{action}", :locale => :sitemap))
+
+              if view_timestamp.blank?
+                DuckMap.console "          : cannot find item in locale sitemap.yml for file: #{view}"
+              else
+
+                view_timestamp = LastMod.to_date(output)
+                if latest_timestamp.blank? || view_timestamp > latest_timestamp
+                  latest_timestamp = view_timestamp
+                  winner = "timestamp from locale sitemap.yml"
+                  DuckMap.console "          : Using  locale timestamp? YES #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
+                else
+                  DuckMap.console "          : Using  locale timestamp? NO #{view}"
+                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
+                end
+
+              end
+
+            rescue Exception => e
+              DuckMap.logger.debug "#{e}"
+            end
+
+            DuckMap.console "          : winner #{winner}"
+
+            begin
+              actions.merge!(action => latest_timestamp.strftime("%m/%d/%Y %H:%M:%S"))
+            rescue Exception => e
+              DuckMap.logger.debug "#{e}"
+            end
+
+          end
+        end
+
+        # add all of the actions found for the current controller to the :sitemap section of the yaml file.
+        if actions.length > 0
+          grand_total += actions.length
+          namespaces = controller.split("/")
+          content[:sitemap] = merge_controller(content[:sitemap], namespaces, 0, actions)
+
+          DuckMap.logger.show_console = true
+          DuckMap.console "#{actions.length.to_s.rjust(5)} #{controller}"
+          DuckMap.logger.show_console = verbose ? true : false
+
+        end
+
+      end
+
+      DuckMap.logger.show_console = true
+      DuckMap.console "\r\nTotal number of views synchronized: #{grand_total}\r\n"
+      DuckMap.logger.info "#{self.class.name} session end at: #{Time.now}"
+      DuckMap.logger.info "---------------------------------------------------------------------"
+
+      # done.
+      write_config(content)
+      DuckMap.console "done."
+
+    end
+    
+    ##################################################################################
+    # Recursive method
+    def merge_controller(content, namespaces, index, values = {})
+
+      if (index == (namespaces.length - 1))
+        content[namespaces[index]] = {} unless content.has_key?(namespaces[index])
+        content[namespaces[index]].merge!(values)
+      else
+        content[namespaces[index]] = {} unless content.has_key?(namespaces[index])
+        content[namespaces[index]] = merge_controller(content[namespaces[index]], namespaces, index + 1, values)
+      end
+      return content
+    end
+
+    ##################################################################################
+    def write_config(values = {})
+      File.open(File.join(Rails.root, "config", "locales", "sitemap.yml"), "w") do |file|
+        file.puts "# Although this file is automatically generated, it is ok to edit."
+        YAML.dump(values, file)
+      end
+    end
+
+  end
+
+end

data/lib/duck_map/version.rb

@@ -0,0 +1,3 @@
+module DuckMap
+  VERSION = "0.8.0"
+end

data/lib/duck_map/view_helpers.rb

@@ -0,0 +1,107 @@
+# DONE
+require 'active_support/concern'
+
+module DuckMap
+
+  ##################################################################################
+  # Contains methods for generating the contants of a sitemap.
+  module SitemapHelpers
+    extend ActiveSupport::Concern
+
+    ##################################################################################
+    # View helper method to generate the content of a sitemap.  Loops through all of the current
+    # Hashes contained in {DuckMap::Model#sitemap_model}.
+    # @param [Block] A block to execute for each row contained in {DuckMap::Model#sitemap_model}.
+    #
+    #
+    # To see it in action, have a look at the file.
+    #
+    # /app/views/sitemap/default_template.xml.erb
+    #
+    # @return [NilClass]
+    def sitemap_content(&block)
+
+      if defined?(self.sitemap_model) && self.sitemap_model.kind_of?(Array)
+
+        self.sitemap_model.each do |row|
+          block.call(row)
+        end
+
+      end
+
+      return nil
+    end
+
+  end
+
+  ##################################################################################
+  # Support for seo related meta tags in page headers.
+  module ActionViewHelpers
+    extend ActiveSupport::Concern
+
+    ##################################################################################
+    # Generates a title tag for use inside HTML header area.
+    # @return [String] HTML safe title tag.
+    def sitemap_meta_title
+      return controller.sitemap_meta_data[:title].blank? ? nil : content_tag(:title, controller.sitemap_meta_data[:title], false)
+    end
+
+    def sitemap_meta_title=(value)
+      controller.sitemap_meta_data[:title] = value
+    end
+
+    ##################################################################################
+    # Generates a keywords meta tag for use inside HTML header area.
+    # @return [String] HTML safe keywords meta tag.
+    def sitemap_meta_keywords
+      return controller.sitemap_meta_data[:keywords].blank? ? nil : tag(:meta, {name: :keywords, content: controller.sitemap_meta_data[:keywords]}, false, false)
+    end
+
+    def sitemap_meta_keywords=(value)
+      controller.sitemap_meta_data[:keywords] = value
+    end
+
+    ##################################################################################
+    # Generates a description meta tag for use inside HTML header area.
+    # @return [String] HTML safe description meta tag.
+    def sitemap_meta_description
+      return controller.sitemap_meta_data[:description].blank? ? nil : tag(:meta, {name: :description, content: controller.sitemap_meta_data[:description]}, false, false)
+    end
+
+    def sitemap_meta_description=(value)
+      controller.sitemap_meta_data[:description] = value
+    end
+
+    ##################################################################################
+    # Generates a Last-Modified meta tag for use inside HTML header area.
+    # @return [String] HTML safe Last-Modified meta tag.
+    def sitemap_meta_lastmod
+      return controller.sitemap_meta_data[:lastmod].blank? ? nil : tag(:meta, {name: "Last-Modified", content: controller.sitemap_meta_data[:lastmod]}, false, false)
+    end
+
+    def sitemap_meta_lastmod=(value)
+      controller.sitemap_meta_data[:lastmod] = value
+    end
+
+    ##################################################################################
+    # Generates a canonical link tag for use inside HTML header area.
+    # @return [String] HTML safe canonical link tag.
+    def sitemap_meta_canonical
+      return controller.sitemap_meta_data[:canonical].blank? ? nil : tag(:link, {rel: :canonical, href: controller.sitemap_meta_data[:canonical]}, false, false)
+    end
+
+    def sitemap_meta_canonical=(value)
+      controller.sitemap_meta_data[:canonical] = value
+    end
+
+    ##################################################################################
+    # Generates a meta tags title, keywords, description and Last-Modified for use inside HTML header area.
+    # @return [String] HTML safe title tag.
+    def sitemap_meta_tag
+      buffer = "#{self.sitemap_meta_title}\r\n    #{self.sitemap_meta_keywords}\r\n    #{self.sitemap_meta_description}\r\n    #{self.sitemap_meta_lastmod}\r\n    #{self.sitemap_meta_canonical}\r\n".html_safe
+      return buffer.html_safe
+    end
+
+  end
+
+end

data/lib/duck_map.rb

@@ -0,0 +1,3 @@
+module DuckMap
+  require "duck_map/engine" if defined?(Rails)
+end

data/lib/generators/duckmap/sitemaps/USAGE

@@ -0,0 +1,23 @@
+Description:
+
+  Lists all of the sitemap route(s) configured via config/routes.rb
+
+  You have the option of including the route(s) contained within a sitemap.  This can be helpful for debugging.
+
+  If you specify a single route name, then, displaying the route(s) contained within the sitemap is implied and
+  
+  overrides the --contents option.
+
+Example:
+
+  # Lists all of the sitemap route(s) configured via config/routes.rb
+
+    rails g duckmap:sitemaps
+
+  # Lists all of the sitemap route(s) configured via config/routes.rb including route(s) contained in each sitemap route.
+
+    rails g duckmap:sitemaps --contents
+
+  # Lists the route(s) contained within sitemap route named mysitemap.
+
+    rails g duckmap:sitemaps mysitemap

data/lib/generators/duckmap/sitemaps/sitemaps_generator.rb

@@ -0,0 +1,36 @@
+require "rails/generators"
+
+module Duckmap
+  module Generators
+
+    class SitemapsGenerator < Rails::Generators::Base
+
+      argument :key,
+                banner: "[sitemap route name]",
+                desc: "[sitemap route name]",
+                default: :all,
+                required: false,
+                optional: true
+
+      class_option :contents, desc: "Include the routes contained in a sitemap"
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), "templates")
+      end
+
+      def build
+
+        config = {key: key}
+
+        unless options[:contents].blank?
+          config[:contents] = options[:contents]
+        end
+
+        DuckMap::List.new.build(config)
+
+      end
+
+    end
+
+  end
+end

data/lib/generators/duckmap/static/USAGE

@@ -0,0 +1,47 @@
+Description:
+
+  Generates a sitemap(s) based on :key.  The default key is: all
+  
+  Key is the route name of a sitemap route defined in config/routes.rb
+  
+  To list all of the available sitemaps including name and contents use: rails g duckmap:sitemaps
+
+  You can override the static_host and static_port settings in config/routes.rb by passing them
+  
+  to the generator on the command line.
+
+  Also, you can specify the target base directory to use when writing files.  The default target is the public
+  
+  directory of your Rails app.
+  
+  #{Rails.root}/public/sitemap.xml
+
+Example:
+
+  # generates all sitemaps configured via config/routes.rb
+
+    rails g duckmap:static
+
+      - or -
+
+    rails g duckmap:static all
+
+  # generates a specific sitemap using the route name.
+
+    rails g duckmap:static mysitemap
+
+  # overrides static_host and static_port defined in config/routes.rb
+
+    rails g duckmap:static mysitemap --static-host=example.com --static-port=8080
+
+  # generates and compresses the output file(s).  Overrides setting in config/routes.rb
+
+    rails g duckmap:static mysitemap --compression=compressed
+
+  # disables compression for the output file(s).  Overrides setting in config/routes.rb
+
+    rails g duckmap:static mysitemap --compression=none
+
+  # generates sitemap files in a specific target directory
+
+    rails g duckmap:static mysitemap --static-target=/tmp/mysitemaps

data/lib/generators/duckmap/static/static_generator.rb

@@ -0,0 +1,51 @@
+require "rails/generators"
+
+module Duckmap
+  module Generators
+
+    class StaticGenerator < Rails::Generators::Base
+
+      argument :key,
+                banner: "[sitemap route name]",
+                desc: "[sitemap route name]",
+                default: :all,
+                required: false,
+                optional: true
+
+      class_option :compression,    desc: "Indicates if the generated file(s) should be compressed"
+      class_option :static_host,    desc: "Static hostname to use when building <url><loc> nodes"
+      class_option :static_port,    desc: "Static port to use when building <url><loc> nodes"
+      class_option :static_target,  desc: "Target base directory to write sitemap files."
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), "templates")
+      end
+
+      def build
+
+        config = {key: key}
+
+        unless options[:compression].blank?
+          config[:compression] = options[:compression]
+        end
+
+        unless options[:static_host].blank?
+          config[:static_host] = options[:static_host]
+        end
+
+        unless options[:static_port].blank?
+          config[:static_port] = options[:static_port]
+        end
+
+        unless options[:static_target].blank?
+          config[:static_target] = options[:static_target]
+        end
+
+        DuckMap::Static.new.build(config)
+
+      end
+
+    end
+
+  end
+end

data/lib/generators/duckmap/sync/USAGE

@@ -0,0 +1,25 @@
+Description:
+
+  Synchronizes date/time stamps of all views for a Rails app.
+
+  There are three sources of timestamps for views.
+
+    - The physical timestamp of the view file on disk.
+
+    - The timestamp of the view found in the local Git repo for the app.
+
+    - The last known timestamp already stored in config/locales/sitemaps.yml
+
+  All three sources are compared and the source that has the latest timestamp wins and that value
+  
+  is stored in config/locales/sitemaps.yml
+
+Example:
+
+  # Performs a synchronization
+
+  rails g duckmap:sync
+
+  # Performs a synchronization and shows all activity
+
+  rails g duckmap:sync --verbose

data/lib/generators/duckmap/sync/sync_generator.rb

@@ -0,0 +1,29 @@
+require "rails/generators"
+
+module Duckmap
+  module Generators
+
+    class SyncGenerator < Rails::Generators::Base
+
+      class_option :verbose, desc: "Show all operations"
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), "templates")
+      end
+
+      def build
+
+        config = {}
+
+        unless options[:verbose].blank?
+          config[:verbose] = options[:verbose]
+        end
+
+        DuckMap::Sync.new.build(config)
+
+      end
+
+    end
+
+  end
+end