session_timeout_prompter 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6be9fd633cab048831eaf8e2a706ef4dc8f87620
+  data.tar.gz: 11c086142b91fb883a39d4fdd3b7a81a26ea3a1b
+SHA512:
+  metadata.gz: 72d21ca10cd794f5d5b9001692a28e96a4e251cb7d54ecba662f67d51d915aa22574f02b9447f22006dbbeff907a0c0e13e86c5ce8735e614d77ee9e4bbacb8e
+  data.tar.gz: 16d1882386159825f8c1e41465ef3b45ab8c9c3ffe6804ccea53e56d8531d70cf3d9dc596e78a24859ce14ac5803c7f1e0fb6b12d6ca006924821d4d6c85ccef

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/dummy/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.DS_Store
+
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in session_timeout_prompter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ant Nettleship
+
+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,124 @@
+# Session Timeout Prompter
+
+A Rails Engine to prompt the user when their session is about to timeout and allow them to extend it.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'session_timeout_prompter'
+```
+
+Mount the engine in your routes:
+
+```ruby
+mount SessionTimeoutPrompter::Engine at: "/session_timeout_prompter"`
+```
+
+Require the js:
+
+```
+//= session_timeout_prompter
+```
+
+Require the css:
+
+```
+*= require session_timeout_prompter
+```
+
+**Note:** Currently depends on jQuery for ajax / event handling.
+
+## Usage
+
+Add the following after the body tag in your layout or on any page you wish to display the timeout prompt:
+
+```ruby
+= session_timeout_prompter(session_timeout_in_seconds: User.timeout_in.to_i, timeout_warning_in_seconds: 305, scope: :user)
+```
+(The example values assume you are using Devise timeoutable and are using a scope/model called User. The scope is purely so you can use multiple in the same application if necessary.)
+
+
+### Configurables
+
+#### "Log in again" path
+By default, clicking the "Log in again" button will go to your application's root path. Due to the inherent inaccuracy of timing in Javascript it is advisable to  make sure they're actually logged out to avoid confusion. To do this, simple override the controller action in your application:
+
+```ruby
+# app/controllers/session_timeout_prompter/sessions_controller.rb
+module SessionTimeoutPrompter
+  class SessionsController < ActionController::Base
+
+    def new
+      sign_out current_user
+      redirect_to new_user_session_path
+    end
+
+  end
+end
+```
+
+#### Keeping the session alive
+You can bind your own events to ping the server as follows:
+
+```javascript
+$(function(){
+  if(sessionTimeoutPrompter) {
+
+    // Ping server on scroll
+    $(window).on('scroll', function() {
+      serverPinger.pingServerWithThrottling();
+    });
+
+    // Ping server when typing or clicking
+    $(document).on('keydown click', function() {
+      serverPinger.pingServerWithThrottling();
+    });
+
+    // Ping server when scrolling inside a modal window
+    // (the ajax-modal-show event in this example is from ajax_modal in the epiJs gem)
+    $(document).on('ajax-modal-show', function() {
+      $('#modalWindow').scroll( function() {
+        serverPinger.pingServerWithThrottling();
+      });
+    });
+
+    // Ping server when a key is pressed in CKEditor
+    CKEDITOR.on('instanceCreated', function(e) {
+      e.editor.on('change', function() {
+        serverPinger.pingServerWithThrottling();
+      });
+    });
+
+  }
+});
+```
+
+#### I18n
+All of the text is rendered via Rails' standard I18n library. See `config/locales/en.yml`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+### ES6
+
+The Javascript is written in ES6 and transpiled with Babel. The ES6 should be modified in `src/javascripts` and then transpiled to `app/assets/javascripts/session_timeout_prompter.js`. Currently we don't make use of modules (we'd need webpack or similar), but this would probably be an improvement going forward to control scope.
+
+There is a handy script `./build` that will do the transpilation and run the tests. Run with --help for options.
+
+### Testing
+
+Uses RSpec and Jasmine for automated testing. To run the Jasmine tests for the Javascript run `rake jasmine` and go to `localhost:8888` in your browser. The suite will run every time the page is reloaded.
+
+### Deployment
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/session_timeout_prompter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+require 'jasmine'
+load 'jasmine/tasks/jasmine.rake'

data/app/assets/javascripts/session_timeout_prompter.js

@@ -0,0 +1,283 @@
+'use strict';
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var Bootstrap3PromptRenderer = (function () {
+
+  // timeoutWarningModal:    the jquery object for the Bootstrap3 modal to display
+  //                         when the session is about to time out
+  // timedOutModal:          the jquery object for the Bootstrap3 modal to display
+  //                         when the session has timed out
+  // remainingTextContainer: the jquery object for the display of the time remaining
+
+  function Bootstrap3PromptRenderer(timeoutWarningModal, timedOutModal, remainingTextContainer) {
+    _classCallCheck(this, Bootstrap3PromptRenderer);
+
+    this.timeoutWarningModal = timeoutWarningModal;
+    this.timedOutModal = timedOutModal;
+    this.remainingTextContainer = remainingTextContainer;
+    this.currentlyShowingWarningPrompt = false;
+  }
+
+  _createClass(Bootstrap3PromptRenderer, [{
+    key: 'renderTimedOut',
+    value: function renderTimedOut() {
+      this.timeoutWarningModal.modal('hide');
+      this.timedOutModal.modal('show');
+    }
+  }, {
+    key: 'renderTimeoutWarning',
+    value: function renderTimeoutWarning(timeLeftInSeconds) {
+      this.updateRemainingTimeText(timeLeftInSeconds);
+      if (!this.currentlyShowingWarningPrompt) {
+        this.currentlyShowingWarningPrompt = true;
+        this.timeoutWarningModal.modal('show');
+      }
+    }
+  }, {
+    key: 'hideAll',
+    value: function hideAll() {
+      this.timeoutWarningModal.modal('hide');
+      this.timedOutModal.modal('hide');
+    }
+  }, {
+    key: 'updateRemainingTimeText',
+    value: function updateRemainingTimeText(timeLeftInSeconds) {
+      var wholeMinutesRemaining = Math.floor(timeLeftInSeconds / 60);
+      var additionalSecondsRemaining = Math.floor(timeLeftInSeconds - wholeMinutesRemaining * 60);
+      this.remainingTextContainer.text(wholeMinutesRemaining + 'm ' + additionalSecondsRemaining + 's');
+    }
+  }]);
+
+  return Bootstrap3PromptRenderer;
+})();
+"use strict";
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var ServerPinger = (function () {
+  function ServerPinger(serverPingPath) {
+    _classCallCheck(this, ServerPinger);
+
+    this.serverPingPath = serverPingPath;
+    this.lastPingedAt = undefined;
+  }
+
+  _createClass(ServerPinger, [{
+    key: "pingServerNow",
+    value: function pingServerNow() {
+      var _this = this;
+
+      var callback = function callback() {
+        _this.setLastPingedAt();
+      };
+      jQuery.post(this.serverPingPath, callback);
+    }
+  }, {
+    key: "pingServerWithThrottling",
+    value: function pingServerWithThrottling() {
+      var seconds_to_throttle = arguments.length <= 0 || arguments[0] === undefined ? 10 : arguments[0];
+
+      if (!this.lastPingedAt || this.currentTimestamp() - this.lastPingedAt > seconds_to_throttle) {
+        this.pingServerNow();
+      }
+    }
+
+    // Private
+  }, {
+    key: "setLastPingedAt",
+    value: function setLastPingedAt() {
+      this.lastPingedAt = this.currentTimestamp();
+    }
+  }, {
+    key: "currentTimestamp",
+    value: function currentTimestamp() {
+      return Math.floor(new Date().getTime() / 1000);
+    }
+  }]);
+
+  return ServerPinger;
+})();
+'use strict';
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+var SessionTimeoutPrompter = (function () {
+  function SessionTimeoutPrompter(configData) {
+    _classCallCheck(this, SessionTimeoutPrompter);
+
+    var serverPingPath = configData.serverPingPath;
+    var timeoutWarningInSeconds = configData.timeoutWarningInSeconds;
+    var sessionTimeoutInSeconds = configData.sessionTimeoutInSeconds;
+    var sessionKey = configData.sessionKey;
+
+    var timeoutWarningModal = jQuery('#session-timeout-prompter-timeout-warning-modal');
+    var timedOutModal = jQuery('#session-timeout-prompter-session-timed-out-modal');
+    var remainingTimeContainer = jQuery('#session-timeout-prompter-warning-timeout-in');
+
+    var promptRenderer = new Bootstrap3PromptRenderer(timeoutWarningModal, timedOutModal, remainingTimeContainer);
+
+    this.timeoutTimer = new TimeoutTimer(timeoutWarningInSeconds, sessionTimeoutInSeconds, sessionKey, promptRenderer);
+    this.serverPinger = new ServerPinger(serverPingPath);
+    this.remainLoggedInButton = jQuery('#session-timeout-prompter-remain-logged-in-btn');
+  }
+
+  _createClass(SessionTimeoutPrompter, [{
+    key: 'start',
+    value: function start() {
+      this.bindDefaultEvents();
+      this.timeoutTimer.start();
+    }
+
+    // Private
+
+  }, {
+    key: 'bindDefaultEvents',
+    value: function bindDefaultEvents() {
+      var _this = this;
+
+      // Restart the timer: This is triggered by any jquery ajax request completing,
+      // including pinging the server via our other events.
+      jQuery(document).ajaxComplete(function () {
+        _this.timeoutTimer.restart();
+      });
+
+      // When the user clicks the button to say they want to remain logged in we
+      // stop the timer to wait until it is restarted via via the ajaxComplete()
+      // event triggered by the ping
+      this.remainLoggedInButton.on('click', function () {
+        _this.serverPinger.pingServerNow();
+        _this.timeoutTimer.stop();
+      });
+
+      // Listen to the storage event fired in TimeoutTimer to synchronise browser tabs
+      // if a user extends their session in one tab but has another open for example.
+      jQuery(window).on('storage', function (e) {
+        var event = e.originalEvent;
+        _this.timeoutTimer.localStorageUpdated(event.key, event.newValue);
+      });
+    }
+  }]);
+
+  return SessionTimeoutPrompter;
+})();
+'use strict';
+
+var sessionTimeoutPrompter = undefined;
+jQuery(function () {
+
+  var timeoutPrompterContainer = jQuery('#session-timeout-prompter-container');
+
+  // If the container cannot be found then assume we don't need timeout prompting on this page.
+  if (timeoutPrompterContainer.length) {
+    var configData = timeoutPrompterContainer.data();
+    sessionTimeoutPrompter = new SessionTimeoutPrompter(configData);
+    sessionTimeoutPrompter.start();
+  }
+});
+"use strict";
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var TimeoutTimer = (function () {
+
+  // timeoutWarningInSeconds: Warning that their session is about to timeout
+  //                          when there are this many minutes left.
+  // sessionTimeoutInSeconds: Tell them their session has timed out when this
+  //                          many minutes have elapsed.
+  // sessionKey:              Unique key for this session - used in local storage
+  //                          to make sure multiple browser tabs are synched.
+
+  function TimeoutTimer(timeoutWarningInSeconds, sessionTimeoutInSeconds, sessionKey, promptRenderer) {
+    _classCallCheck(this, TimeoutTimer);
+
+    this.sessionTimeoutInSeconds = sessionTimeoutInSeconds;
+    this.timeoutWarningInSeconds = timeoutWarningInSeconds;
+    this.sessionKey = sessionKey;
+    this.promptRenderer = promptRenderer;
+    this.tickInterval = undefined;
+    this.timeoutAt = undefined;
+    this.recalculateTimeoutAt();
+  }
+
+  _createClass(TimeoutTimer, [{
+    key: "start",
+    value: function start() {
+      var _this = this;
+
+      this.tick();
+      this.tickInterval = setInterval(function () {
+        _this.tick();
+      }, 1000);
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      this.promptRenderer.hideAll();
+      clearInterval(this.tickInterval);
+    }
+  }, {
+    key: "restart",
+    value: function restart() {
+      this.stop();
+      this.recalculateTimeoutAt();
+      this.start();
+    }
+  }, {
+    key: "localStorageUpdated",
+    value: function localStorageUpdated(key, newTimeoutAt) {
+      if (key === this.sessionKey) {
+        this.stop();
+        this.timeoutAt = newTimeoutAt;
+        this.start();
+      }
+    }
+
+    // Private
+  }, {
+    key: "tick",
+    value: function tick() {
+      var timeLeftInSeconds = this.timeoutAt - this.currentTimestamp();
+      if (timeLeftInSeconds <= 0) {
+        this.showTimedOutPrompt();
+      } else if (timeLeftInSeconds <= this.timeoutWarningInSeconds) {
+        this.showTimeoutWarningPrompt(timeLeftInSeconds);
+      }
+    }
+  }, {
+    key: "showTimedOutPrompt",
+    value: function showTimedOutPrompt() {
+      this.stop();
+      this.promptRenderer.renderTimedOut();
+    }
+  }, {
+    key: "showTimeoutWarningPrompt",
+    value: function showTimeoutWarningPrompt(timeLeftInSeconds) {
+      this.promptRenderer.renderTimeoutWarning(timeLeftInSeconds);
+    }
+
+    // We need to use the system time rather than the setTimeout function as it
+    // is inherently innacurate.
+  }, {
+    key: "recalculateTimeoutAt",
+    value: function recalculateTimeoutAt() {
+      this.timeoutAt = this.currentTimestamp() + this.sessionTimeoutInSeconds;
+      localStorage.setItem(this.sessionKey, this.timeoutAt);
+    }
+  }, {
+    key: "currentTimestamp",
+    value: function currentTimestamp() {
+      return Math.floor(new Date().getTime() / 1000);
+    }
+  }]);
+
+  return TimeoutTimer;
+})();

data/app/assets/stylesheets/session_timeout_prompter.css

@@ -0,0 +1,7 @@
+.session-timeout-prompter-modal {
+  z-index: 1100
+}
+
+.session-timeout-prompter-modal .modal-body p:last-child {
+  margin-bottom: 0
+}

data/app/controllers/session_timeout_prompter/server_pings_controller.rb

@@ -0,0 +1,10 @@
+module SessionTimeoutPrompter
+  class ServerPingsController < ActionController::Base
+
+    # Serves only to reset the user's session timeout on the server side
+    def create
+      head :ok
+    end
+
+  end
+end

data/app/controllers/session_timeout_prompter/sessions_controller.rb

@@ -0,0 +1,13 @@
+module SessionTimeoutPrompter
+  class SessionsController < ActionController::Base
+
+    # We arrive here when clicking "Log in again"
+    # Note: Due to inherent inaccuracies in javascript timing it is a good idea to
+    # override this in your app and destroy the user session to make sure they are
+    # actually logged out as this may cause confusion.
+    def new
+      redirect_to main_app.root_path
+    end
+
+  end
+end

data/app/helpers/session_timeout_prompter/prompt_helper.rb

@@ -0,0 +1,40 @@
+module SessionTimeoutPrompter
+  module PromptHelper
+
+    # session_timeout_in_seconds: The session timeout length set for your app
+    #                             (most often from User.timeout_in.to_i if using Devise)
+    #
+    # timeout_warning_in_seconds: Show a warning this many seconds before the session times out.
+    #
+    # scope:       e.g. :user - most often the name of the Devise scope/model
+    #
+    # session_key: Unique key for this app and scope - used to enable multi-tab support
+    def init_session_timeout_prompter(session_timeout_in_seconds:, timeout_warning_in_seconds:, scope:)
+      render(
+        partial: "session_timeout_prompter/modal_dialogs",
+        locals: {
+          container_data_attributes: {
+            server_ping_path:   session_timeout_prompter.server_pings_path,
+            session_timeout_in_seconds: session_timeout_in_seconds,
+            timeout_warning_in_seconds: timeout_warning_in_seconds,
+            session_key:      "#{::Rails.application.class.parent_name.downcase}-#{scope}"
+          }
+        }
+      )
+    end
+
+    def session_timeout_prompter_translate(key)
+      I18n.t("session_timeout_prompter.#{key}")
+    end
+
+    # Don't create a dependency on FontAwesome
+    def session_timeout_prompter_icon(name, text:)
+      if defined?(fa_icon)
+        fa_icon name, text: text
+      else
+        text
+      end
+    end
+
+  end
+end

data/app/views/session_timeout_prompter/_modal_dialogs.html.erb

@@ -0,0 +1,39 @@
+<%= content_tag :div, id: "session-timeout-prompter-container", data: container_data_attributes do %>
+  <div class="session-timeout-prompter-modal modal fade" id="session-timeout-prompter-timeout-warning-modal" data-backdrop="static">
+    <div class="modal-dialog modal-sm">
+      <div class="modal-content">
+        <div class="modal-body text-center">
+          <p>
+            <%= session_timeout_prompter_translate :your_session_will_expire_in %>
+            <br/>
+            <span class="lead" id="session-timeout-prompter-warning-timeout-in">3m 0s</span>
+          </p>
+          <p>
+            <%= session_timeout_prompter_translate :do_you_wish_to_remain_logged_in %>
+          </p>
+        </div>
+        <div class="modal-footer">
+          <button class="btn btn-primary btn-block" id="session-timeout-prompter-remain-logged-in-btn" title="<%= session_timeout_prompter_translate(:remain_logged_in_btn_title) %>">
+            <%= session_timeout_prompter_icon 'check', text: session_timeout_prompter_translate(:remain_logged_in_btn_text) %>
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+  <div class="session-timeout-prompter-modal modal fade" id="session-timeout-prompter-session-timed-out-modal" data-backdrop="static">
+    <div class="modal-dialog modal-sm">
+      <div class="modal-content">
+        <div class="modal-body text-center">
+          <p>
+            <%= session_timeout_prompter_translate :session_timed_out %>
+          </p>
+        </div>
+        <div class="modal-footer">
+          <%= link_to session_timeout_prompter.new_session_path, title: session_timeout_prompter_translate(:log_in_again_btn_title), class: 'btn btn-primary btn-block' do %>
+            <%= session_timeout_prompter_translate :log_in_again_btn_text %>
+          <% end %>
+        </div>
+      </div>
+    </div>
+  </div>
+<% end %>

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "session_timeout_prompter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/build

@@ -0,0 +1,61 @@
+#! /usr/bin/env ruby
+require 'babel/transpiler'
+require 'rake'
+require 'optparse'
+
+# A simple script to transpile our source ES6 in src/javascripts to standard ES5
+# javascript in app/assets/javascripts/session_timeout_prompter.js
+
+TARGET_JS_PATH = "#{File.dirname(__FILE__)}/app/assets/javascripts/session_timeout_prompter.js"
+SRC_DIRECTORY  = "#{File.dirname(__FILE__)}/src/javascripts"
+
+options = {}
+option_parser = OptionParser.new do |opts|
+
+  opts.banner = "Usage: build [options]"
+  opts.on("-j", "--jasmine", "Run Jasmine tests only") do |v|
+    options[:jasmine_only] = v
+  end
+
+  opts.on("-r", "--rspec", "Run RSpec tests only") do |v|
+    options[:rspec_only] = v
+  end
+
+  opts.on("-h", "--help", "Show help") do |v|
+    options[:help] = v
+  end
+
+end
+option_parser.parse!
+
+if options[:help]
+  puts option_parser.help()
+else
+
+  es6_files_to_transpile = Dir.glob("#{SRC_DIRECTORY}/**/*.es6")
+
+  File.open TARGET_JS_PATH, 'w' do |output_file|
+
+    es6_files_to_transpile.each do |es6_file_path|
+      puts "Transpiling #{es6_file_path}..."
+      transpiled_es6 = Babel::Transpiler.transform File.read(es6_file_path)
+      output_file.puts transpiled_es6['code']
+    end
+
+  end
+
+  app = Rake.application
+  app.init
+  app.load_rakefile
+
+  unless options[:rspec_only]
+    puts "Running Jasmine..."
+    app['jasmine:ci'].invoke
+  end
+
+  unless options[:jasmine_only]
+    puts "Running RSpec..."
+    app['spec'].invoke
+  end
+
+end

data/config/locales/en.yml

@@ -0,0 +1,9 @@
+en:
+  session_timeout_prompter:
+    your_session_will_expire_in:     "Your session will expire and you will be automatically logged out in"
+    do_you_wish_to_remain_logged_in: "Do you wish to remain logged in?"
+    remain_logged_in_btn_title:      "Yes keep me logged in - I am still using the system"
+    remain_logged_in_btn_text:       "Yes"
+    session_timed_out:               "Your session has expired."
+    log_in_again_btn_title:          "Log in again"
+    log_in_again_btn_text:           "Log in again"

data/config/routes.rb

@@ -0,0 +1,8 @@
+SessionTimeoutPrompter::Engine.routes.draw do
+
+  #get :session_timeout_prompter_log_in_again
+
+  resources :server_pings, only: [:create]
+  resources :sessions,     only: [:new]
+
+end

data/lib/session_timeout_prompter.rb

@@ -0,0 +1,14 @@
+require "session_timeout_prompter/version"
+
+module SessionTimeoutPrompter
+  class Engine < Rails::Engine
+    isolate_namespace SessionTimeoutPrompter
+
+    initializer "session_timeout_prompter.include_prompt_helper" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        helper SessionTimeoutPrompter::PromptHelper
+      end
+    end
+
+  end
+end

data/lib/session_timeout_prompter/version.rb

@@ -0,0 +1,3 @@
+module SessionTimeoutPrompter
+  VERSION = "0.1.1"
+end

data/session_timeout_prompter.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "session_timeout_prompter/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "session_timeout_prompter"
+  spec.version       = SessionTimeoutPrompter::VERSION
+  spec.authors       = ["Ant Nettleship"]
+  spec.email         = ["anthony.nettleship@epigenesys.org.uk"]
+
+  spec.summary       = "A Rails Engine to prompt the user when their session is about to timeout and allow them to extend it."
+  spec.homepage      = "https://github.com/epigenesys/session-timeout-prompter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|src)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rails', '>= 4.0'
+  spec.add_dependency 'railties', '>= 4.0'
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", ">= 3.0"
+  spec.add_development_dependency "rspec-rails", ">= 3.0"
+  spec.add_development_dependency "rails", ">= 4.0"
+  spec.add_development_dependency 'jquery-rails', '>= 4.0'
+  spec.add_development_dependency 'bootstrap-sass', '~> 3.3.6'
+  spec.add_development_dependency 'sass-rails', '>= 3.2'
+  spec.add_development_dependency "capybara", ">= 2.4"
+  spec.add_development_dependency 'poltergeist'
+  spec.add_development_dependency 'launchy'
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency "jasmine"
+  spec.add_development_dependency "babel-transpiler"
+end

metadata

@@ -0,0 +1,304 @@
+--- !ruby/object:Gem::Specification
+name: session_timeout_prompter
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ant Nettleship
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bootstrap-sass
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.6
+- !ruby/object:Gem::Dependency
+  name: sass-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: poltergeist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jasmine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: babel-transpiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- anthony.nettleship@epigenesys.org.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/session_timeout_prompter.js
+- app/assets/stylesheets/session_timeout_prompter.css
+- app/controllers/session_timeout_prompter/server_pings_controller.rb
+- app/controllers/session_timeout_prompter/sessions_controller.rb
+- app/helpers/session_timeout_prompter/prompt_helper.rb
+- app/views/session_timeout_prompter/_modal_dialogs.html.erb
+- bin/console
+- bin/setup
+- build
+- config/locales/en.yml
+- config/routes.rb
+- lib/session_timeout_prompter.rb
+- lib/session_timeout_prompter/version.rb
+- session_timeout_prompter.gemspec
+homepage: https://github.com/epigenesys/session-timeout-prompter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A Rails Engine to prompt the user when their session is about to timeout
+  and allow them to extend it.
+test_files: []