turnout2024 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3b00ca152fc3d0806180d89874a359c21a922a987f1eccd1ea0dba32b628e1a0
+  data.tar.gz: 52ba067e7e5b23006b43af7d9145cefb53c94f1d561d488c2b6415818ad73348
+SHA512:
+  metadata.gz: 1151228b249536564690e506ffde5e29557a3554698883194dc75f23c1f1cfe9df9a6c51194905cc4201359912763224379b47df69d6ee3f2259659712029081
+  data.tar.gz: 7976574ce79f8d1a6671650b799cb37ffba9654b8ef3898c1fd501c2c939b88deb322d9f8064e4cbbc237f6c8a61e8219e4f3df5233b9e6889ee19dab82c608b

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 by Biola University
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,200 @@
+Turnout2024 [![Code Climate](https://codeclimate.com/github/pglombardo/turnout2024.svg)](https://codeclimate.com/github/pglombardo/turnout2024) [![Gem Version](https://badge.fury.io/rb/turnout2024.svg)](https://badge.fury.io/rb/turnout2024)
+=======
+Turnout2024 is [Rack](http://rack.rubyforge.org/) middleware with a [Ruby on Rails](http://rubyonrails.org) engine that allows you to easily put your app in maintenance mode.
+
+This project is forked from the original [turnout gem](https://github.com/biola/turnout) which unfortunately hasn't been updated in 6+ years.
+
+The gem name has been updated but everything internally is still `Turnout`.  Pull requests are more than welcome!
+
+Features
+========
+* Easy installation
+* Rake commands to turn maintenance mode on and off
+* Easily provide a reason for each downtime without editing the maintenance.html file
+* Allow certain IPs or IP ranges to bypass the maintenance page
+* Allow certain paths to be accessible during maintenance
+* Easily override the default maintenance.html file with your own
+* Simple [YAML](http://yaml.org) based config file for easy activation, deactivation and configuration without the rake commands
+* Support for multiple maintenance page formats. Current [HTML](http://en.wikipedia.org/wiki/HTML) and [JSON](http://en.wikipedia.org/wiki/JSON)
+* Supports Rails, [Sinatra](http://sinatrarb.com) and any other Rack application
+* Supports multiple maintenance file paths so that groups of applications can be put into maintenance mode at once.
+
+Installation
+============
+Rails 3+
+--------
+In your `Gemfile` add:
+
+    gem 'turnout2024'
+
+then run
+
+    bundle install
+    
+_Note that you'll need to restart your Rails server before it will work_
+
+Sinatra
+-------
+
+In your Sinatra app file
+
+```ruby
+require 'rack/turnout'
+
+class App < Sinatra::Base
+  configure do
+    use Rack::Turnout
+```
+
+In your Rakefile
+
+```ruby
+require 'turnout/rake_tasks'
+```
+
+Activation
+==========
+
+    rake maintenance:start
+
+or
+
+    rake maintenance:start reason="Somebody googled Google!"
+
+or
+
+    rake maintenance:start allowed_paths="/login,^/faqs/[0-9]*"
+
+or
+
+    rake maintenance:start allowed_ips="4.8.15.16"
+
+or
+
+    rake maintenance:start reason="Someone told me I should type <code>sudo rm -rf /</code>" allowed_paths="^/help,^/contact_us" allowed_ips="127.0.0.1,192.168.0.0/24"
+
+or if you've configured `named_maintenance_file_paths` with a path named `server`
+
+    rake maintenance:server:start
+
+Notes
+-----
+* The `reason` parameter can contain HTML
+* Multiple `allowed_paths` and `allowed_ips` can be given. Just comma separate them.
+* All `allowed_paths` are treated as regular expressions.
+* If you need to use a comma in an `allowed_paths` regular expression just escape it with a backslash: `\,`.
+* IP ranges can be given to `allowed_ips` using [CIDR notation](http://en.wikipedia.org/wiki/CIDR_notation).
+
+Deactivation
+============
+
+    rake maintenance:end
+
+or if you activated with a named path like `server`
+
+    rake maintenance:server:end
+
+Configuration
+=============
+
+Turnout can be configured in two different ways:
+
+1. __Pass a config hash to the middleware__
+
+    ```ruby
+    use Rack::Turnout,
+      app_root: '/some/path',
+      named_maintenance_file_paths: {app: 'tmp/app.yml', server: '/tmp/server.yml'},
+      maintenance_pages_path: 'app/views/maintenance',
+      default_maintenance_page: Turnout::MaintenancePage::JSON,
+      default_reason: 'Somebody googled Google!',
+      default_allowed_paths: ['^/admin/'],
+      default_response_code: 418,
+      default_retry_after: 3600
+    ```
+
+2. __Using a config block__
+
+    ```ruby
+    Turnout.configure do |config|
+      config.skip_middleware = true
+      config.app_root = '/some/path'
+      config.named_maintenance_file_paths = {app: 'tmp/app.yml', server: '/tmp/server.yml'}
+      config.maintenance_pages_path = 'app/views/maintenance'
+      config.default_maintenance_page = Turnout::MaintenancePage::JSON
+      config.default_reason = 'Somebody googled Google!'
+      config.default_allowed_paths = ['^/admin/']
+      config.default_response_code = 418
+      config.default_retry_after = 3600
+    end
+    ```
+
+__NOTICE:__ Any custom configuration should be loaded not only in the app but in the rake task. This should happen automatically in Rails as the `environment` task is run if it exists. But you may want to create your own `environment` task in non-Rails apps.
+
+Default Configuration
+---------------------
+
+```ruby
+Turnout.configure do |config|
+  config.app_root = '.'
+  config.named_maintenance_file_paths = {default: config.app_root.join('tmp', 'maintenance.yml').to_s}
+  config.maintenance_pages_path = config.app_root.join('public').to_s
+  config.default_maintenance_page = Turnout::MaintenancePage::HTML
+  config.default_reason = "The site is temporarily down for maintenance.\nPlease check back soon."
+  config.default_allowed_paths = []
+  config.default_response_code = 503
+  config.default_retry_after = 7200
+end
+```
+
+Customization
+=============
+
+[Default maintenance pages](https://github.com/biola/turnout/blob/master/public/) are provided, but you can create your own `public/maintenance.[html|json|html.erb]` files instead. If you provide a `reason` to the rake task, Turnout will parse the maintenance page file and attempt to replace a [Liquid](http://liquidmarkup.org/)-style `{{ reason }}` tag with the provided reason. So be sure to include a `{{ reason }}` tag in your `maintenance.html` file. In the case of a `.html.erb` file, `reason` will be a local variable.
+
+__WARNING:__
+The source code of any custom maintenance files you created in the `/public` directory will be able to be viewed by visiting that URL directly (i.e. `http://example.com/maintenance.html.erb`). This shouldn't be an issue with HTML and JSON files but with ERB files, it could be. If you're going to use a custom `.erb.html` file, we recommend you change the `maintenance_pages_path` setting to something other than the `/public` directory.
+
+Tips
+====
+
+Denied Paths
+--------------
+There is no `denied_paths` feature because turnout denies everything by default.
+However you can achieve the same sort of functionality by using
+[negative lookaheads](http://www.regular-expressions.info/lookaround.html) with the `allowed_paths` setting, like so:
+
+    rake maintenance:start allowed_paths="^(?!/your/under/maintenance/path)"
+
+Multi-App Maintenance
+------------------------
+A central `named_maintenance_file_path` can be configured in all your apps such as `/tmp/turnout.yml` so that all apps on a server can be put into mainteance mode at once. You could even configure service based paths such as `/tmp/mongodb_maintenance.yml` so that all apps using MongoDB could be put into maintenance mode.
+
+Detecting Maintenance Mode
+-------------------------------
+
+If you'd like to detect if maintenance mode is on in your app (for those users or pages that aren't blocked) just call `!Turnout::MaintenanceFile.find.nil?`.
+
+Behind the Scenes
+=================
+On every request the Rack app will check to see if `tmp/maintenance.yml` exists. If the file exists the maintenance page will be shown (unless allowed IPs are given and the requester is in the allowed range).
+
+So if you want to get the maintenance page up or down in a hurry `touch tmp/maintenance.yml` and `rm tmp/maintenance.yml` will work.
+
+Turnout will attempt to parse the `maintenance.yml` file looking for `reason`, `allowed_ip` and other settings. The file is checked on every request so you can change these values manually or just rerun the `rake maintenance:start` command.
+
+Example maintenance.yml File
+----------------------------
+
+```yaml
+---
+reason: Someone told me I should type <code>sudo rm -rf /</code>
+allowed_paths:
+- ^/help
+- ^/contact_us
+allowed_ips:
+- 127.0.0.1
+- 192.168.0.0/24
+response_code: 503
+retry_after: 3600
+```

data/lib/rack/turnout.rb

@@ -0,0 +1,28 @@
+require 'rack'
+require 'turnout'
+
+class Rack::Turnout
+  def initialize(app, config={})
+    @app = app
+
+    Turnout.config.update config
+
+    if config[:app_root].nil? && app.respond_to?(:app_root)
+      Turnout.config.app_root = app.app_root
+    end
+  end
+
+  def call(env)
+    request = Turnout::Request.new(env)
+    settings = Turnout::MaintenanceFile.find
+
+    if settings && !request.allowed?(settings)
+      page_class = Turnout::MaintenancePage.best_for(env)
+      page = page_class.new(settings.reason, env: env)
+
+      page.rack_response(settings.response_code, settings.retry_after)
+    else
+      @app.call(env)
+    end
+  end
+end

data/lib/tasks/maintenance.rake

@@ -0,0 +1,48 @@
+require 'turnout'
+
+namespace :maintenance do
+  desc 'Enable the maintenance mode page ("reason", "allowed_paths", "allowed_ips" and "response_code" can be passed as environment variables)'
+  rule /\Amaintenance:(.*:|)start\Z/ do |task|
+    invoke_environment
+
+    maint_file = maintenance_file_for(task)
+    maint_file.import_env_vars(ENV)
+    maint_file.write
+
+    puts "Created #{maint_file.path}"
+    puts "Run `rake #{task.name.gsub(/\:start/, ':end')}` to stop maintenance mode"
+  end
+
+  desc 'Disable the maintenance mode page'
+  rule /\Amaintenance:(.*:|)end\Z/ do |task|
+    invoke_environment
+
+    maint_file = maintenance_file_for(task)
+
+    if maint_file.delete
+      puts "Deleted #{maint_file.path}"
+    else
+      fail 'Could not find a maintenance file to delete'
+    end
+  end
+
+  def invoke_environment
+    if Rake::Task.task_defined? 'environment'
+      Rake::Task['environment'].invoke
+    end
+  end
+
+  def maintenance_file_for(task)
+    path_name = (task.name.split(':') - ['maintenance', 'start', 'end']).join(':')
+
+    maint_file = if path_name == ''
+      Turnout::MaintenanceFile.default
+    else
+      Turnout::MaintenanceFile.named(path_name)
+    end
+
+    fail %{Unknown path name: "#{path_name}"} if maint_file.nil?
+
+    maint_file
+  end
+end

data/lib/turnout/configuration.rb

@@ -0,0 +1,60 @@
+require_relative './ordered_options'
+module Turnout
+  class Configuration
+    SETTINGS = [
+      :app_root,
+      :named_maintenance_file_paths,
+      :maintenance_pages_path,
+      :default_maintenance_page,
+      :default_reason,
+      :default_allowed_ips,
+      :skip_middleware,
+      :default_allowed_paths,
+      :default_response_code,
+      :default_retry_after,
+      :i18n
+    ].freeze
+
+    SETTINGS.each do |setting|
+      attr_accessor setting
+    end
+
+    def initialize
+      @skip_middleware = false
+      @app_root = '.'
+      @named_maintenance_file_paths = {default: app_root.join('tmp', 'maintenance.yml').to_s}
+      @maintenance_pages_path = app_root.join('public').to_s
+      @default_maintenance_page = Turnout::MaintenancePage::HTML
+      @default_reason = "The site is temporarily down for maintenance.\nPlease check back soon."
+      @default_allowed_paths = []
+      @default_allowed_ips = []
+      @default_response_code = 503
+      @default_retry_after = 7200 # 2 hours by default
+      @i18n = Turnout::OrderedOptions.new
+      @i18n.railties_load_path = []
+      @i18n.load_path = []
+      @i18n.fallbacks = Turnout::OrderedOptions.new
+      @i18n.enabled = false
+      @i18n.use_language_header = false
+    end
+
+    def app_root
+      Pathname.new(@app_root.to_s)
+    end
+
+    def named_maintenance_file_paths=(named_paths)
+      # Force keys to symbols
+      @named_maintenance_file_paths = Hash[named_paths.map { |k, v| [k.to_sym, v] }]
+    end
+
+    def update(settings_hash)
+      settings_hash.each do |setting, value|
+        unless SETTINGS.include? setting.to_sym
+          raise ArgumentError, "invalid setting: #{setting}"
+        end
+
+        self.public_send "#{setting}=", value
+      end
+    end
+  end
+end

data/lib/turnout/engine.rb

@@ -0,0 +1,16 @@
+require 'turnout'
+require 'rack/turnout'
+require 'rails'
+
+# For Rails 3
+if defined? Rails::Engine
+  module Turnout
+    class Engine < Rails::Engine
+      initializer 'turnout.add_to_middleware_stack' do |app|
+        unless Turnout.config.skip_middleware
+          app.config.middleware.use(Rack::Turnout)
+        end
+      end
+    end
+  end
+end

data/lib/turnout/i18n/accept_language_parser.rb

@@ -0,0 +1,109 @@
+module Turnout
+  class AcceptLanguageParser
+    attr_accessor :header
+
+    def initialize(header)
+      @header = header
+    end
+
+    # Returns a sorted array based on user preference in HTTP_ACCEPT_LANGUAGE.
+    # Browsers send this HTTP header, so don't think this is holy.
+    #
+    # Example:
+    #
+    #   request.user_preferred_languages
+    #   # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
+    #
+    def user_preferred_languages
+      return [] if header.to_s.strip.empty?
+      @user_preferred_languages ||= begin
+        header.to_s.gsub(/\s+/, '').split(',').map do |language|
+          locale, quality = language.split(';q=')
+          raise ArgumentError, 'Not correctly formatted' unless locale =~ /^[a-z\-0-9]+|\*$/i
+
+          locale  = locale.downcase.gsub(/-[a-z0-9]+$/i, &:upcase) # Uppercase territory
+          locale  = nil if locale == '*' # Ignore wildcards
+
+          quality = quality ? quality.to_f : 1.0
+
+          [locale, quality]
+        end.sort do |(_, left), (_, right)|
+          right <=> left
+        end.map(&:first).compact
+      rescue ArgumentError # Just rescue anything if the browser messed up badly.
+        []
+      end
+    end
+
+    # Sets the user languages preference, overriding the browser
+    #
+    def user_preferred_languages=(languages)
+      @user_preferred_languages = languages
+    end
+
+    # Finds the locale specifically requested by the browser.
+    #
+    # Example:
+    #
+    #   request.preferred_language_from I18n.available_locales
+    #   # => 'nl'
+    #
+    def preferred_language_from(array)
+      (user_preferred_languages & array.map(&:to_s)).first
+    end
+
+    # Returns the first of the user_preferred_languages that is compatible
+    # with the available locales. Ignores region.
+    #
+    # Example:
+    #
+    #   request.compatible_language_from I18n.available_locales
+    #
+    def compatible_language_from(available_languages)
+      user_preferred_languages.map do |preferred| #en-US
+        preferred = preferred.downcase
+        preferred_language = preferred.split('-', 2).first
+
+        available_languages.find do |available| # en
+          available = available.to_s.downcase
+          preferred == available || preferred_language == available.split('-', 2).first
+        end
+      end.compact.first
+    end
+
+    # Returns a supplied list of available locals without any extra application info
+    # that may be attached to the locale for storage in the application.
+    #
+    # Example:
+    # [ja_JP-x1, en-US-x4, en_UK-x5, fr-FR-x3] => [ja-JP, en-US, en-UK, fr-FR]
+    #
+    def sanitize_available_locales(available_languages)
+      available_languages.map do |available|
+        available.to_s.split(/[_-]/).reject { |part| part.start_with?("x") }.join("-")
+      end
+    end
+
+    # Returns the first of the user preferred languages that is
+    # also found in available languages.  Finds best fit by matching on
+    # primary language first and secondarily on region.  If no matching region is
+    # found, return the first language in the group matching that primary language.
+    #
+    # Example:
+    #
+    #   request.language_region_compatible(available_languages)
+    #
+    def language_region_compatible_from(available_languages)
+      available_languages = sanitize_available_locales(available_languages)
+      user_preferred_languages.map do |preferred| #en-US
+        preferred = preferred.downcase
+        preferred_language = preferred.split('-', 2).first
+
+        lang_group = available_languages.select do |available| # en
+          preferred_language == available.downcase.split('-', 2).first
+        end
+
+        lang_group.find { |lang| lang.downcase == preferred } || lang_group.first #en-US, en-UK
+      end.compact.first
+    end
+  end
+end

data/lib/turnout/i18n/internationalization.rb

@@ -0,0 +1,141 @@
+require 'i18n'
+require 'i18n/backend/fallbacks'
+require_relative './accept_language_parser'
+require_relative '../ordered_options'
+
+module Turnout
+  class Internationalization
+    class << self
+      attr_reader :env
+      attr_writer :env
+
+      def initialize_i18n(env)
+        @env = env
+        setup_i18n_config
+      end
+
+      def i18n_config
+        @i18n_config = Turnout.config.i18n
+        @i18n_config =  @i18n_config.is_a?(Turnout::OrderedOptions) ? @i18n_config : Turnout::InheritableOptions.new(@i18n_config)
+      end
+
+      def turnout_page
+        @turnout_page ||= Turnout.config.default_maintenance_page
+      end
+
+      def http_accept_language
+        language = (env.nil? || env.empty?) ? nil : env["HTTP_ACCEPT_LANGUAGE"]
+        @http_accept_language ||= Turnout::AcceptLanguageParser.new(language)
+      end
+
+      def setup_additional_helpers
+        i18n_additional_helpers = i18n_config.delete(:additional_helpers)
+        i18n_additional_helpers = i18n_additional_helpers.is_a?(Array) ? i18n_additional_helpers : []
+
+        i18n_additional_helpers.each do |helper|
+          turnout_page.send(:include, helper) if helper.is_a?(Module)
+        end
+      end
+
+      def expanded(path)
+        result = []
+        if File.directory?(path)
+          result.concat(Dir.glob(File.join(path, '**', '**')).map { |file| file }.sort)
+        else
+          result << path
+        end
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent(path)
+        expanded(path).select { |f| File.exist?(f) }
+      end
+
+      # Setup i18n configuration.
+      def setup_i18n_config
+        return unless i18n_config.enabled
+        setup_additional_helpers
+        fallbacks = i18n_config.delete(:fallbacks)
+
+
+        # Avoid issues with setting the default_locale by disabling available locales
+        # check while configuring.
+        enforce_available_locales = i18n_config.delete(:enforce_available_locales)
+        enforce_available_locales = I18n.enforce_available_locales if enforce_available_locales.nil?
+        I18n.enforce_available_locales = false
+
+        i18n_config.except(:enabled, :use_language_header).each do |setting, value|
+          case setting
+          when :railties_load_path
+            I18n.load_path.unshift(*value.map { |file| existent(file) }.flatten)
+          when :load_path
+            I18n.load_path += value
+          else
+            I18n.send("#{setting}=", value)
+          end
+        end
+
+
+        init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
+        I18n.backend.load_translations
+
+        # Restore available locales check so it will take place from now on.
+        I18n.enforce_available_locales = enforce_available_locales
+
+        begin
+          if i18n_config.use_language_header
+            I18n.locale = http_accept_language.compatible_language_from(I18n.available_locales) || I18n.default_locale
+          else
+            I18n.locale = I18n.default_locale
+          end
+        rescue
+          #nothing
+        end
+
+      end
+
+      def array_wrap(object)
+        if object.nil?
+          []
+        elsif object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
+      end
+
+      def include_fallbacks_module
+        I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
+      end
+
+      def init_fallbacks(fallbacks)
+        include_fallbacks_module
+
+        args = case fallbacks
+        when Turnout::OrderedOptions
+          [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
+        when Hash, Array
+          array_wrap(fallbacks)
+        else # TrueClass
+          []
+        end
+
+        I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
+      end
+
+      def validate_fallbacks(fallbacks)
+        case fallbacks
+        when Turnout::OrderedOptions
+          !fallbacks.empty?
+        when TrueClass, Array, Hash
+          true
+        else
+          raise "Unexpected fallback type #{fallbacks.inspect}"
+        end
+      end
+
+    end
+  end
+end