breakfast 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68ce62fc8d2a9b3a03545936ed1841513872812d
+  data.tar.gz: 841d82099e64bc247ff815ae145845e6f203afca
+SHA512:
+  metadata.gz: 1194e1f38671dab58baebae778721cb0235db9a751a08d2bfc0b87c3414a52df39aa1eeea565b88ab0678dce150c4e8173f90b875bbad9baed9da9a23c778bc1
+  data.tar.gz: dfdac97c7f8107e3d0d6884210edc8d164a49321da3c0078970848bacb9d8980d26050c950500053a02cf79e846dde2127641eeafeb02c4f73be963128a84815

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+node_package/node_modules/*
+node_package/lib/*

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in breakfast.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Patrick Koperwas
+
+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,41 @@
+# Breakfast
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/breakfast`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'breakfast'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install breakfast
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 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]/breakfast.
+
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "breakfast"
+
+# 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

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/breakfast.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "breakfast/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "breakfast"
+  spec.version       = Breakfast::VERSION
+  spec.authors       = ["Patrick Koperwas"]
+  spec.email         = ["patrick@devlocker.io"]
+
+  spec.summary       = %q{Integrates Brunch into Rails}
+  spec.description   = %q{Replace the asset pipeline with Brunch. Get CSS, JS and HTML live-reloading out of the box. Full ES6 support with require. No need to launch extra servers.}
+  spec.homepage      = "https://github.com/devlocker/breakfast"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "rails", "5.0.0.rc2"
+  spec.add_dependency "actioncable"
+  spec.add_dependency "listen"
+end

data/lib/breakfast.rb

@@ -0,0 +1,8 @@
+require "breakfast/version"
+require "breakfast/live_reload_channel"
+require "breakfast/view_helper"
+
+module Breakfast
+end
+
+require "breakfast/railtie" if defined?(Rails)

data/lib/breakfast/live_reload_channel.rb

@@ -0,0 +1,9 @@
+require "rails"
+
+module Breakfast
+  class LiveReloadChannel < ::ActionCable::Channel::Base
+    def subscribed
+      stream_from "breakfast_live_reload"
+    end
+  end
+end

data/lib/breakfast/railtie.rb

@@ -0,0 +1,46 @@
+require "rails"
+
+module BrunchRails
+  class Railtie < ::Rails::Railtie
+    config.breakfast = ActiveSupport::OrderedOptions.new
+
+    config.before_configuration do |app|
+      config.breakfast.live_reload = true
+
+      config.breakfast.output_folders = [Rails.root.join("public")]
+      config.breakfast.view_folders = [Rails.root.join("app", "views")]
+
+      config.breakfast.websocket_hostname = "localhost"
+      config.breakfast.websocket_port = 3000
+    end
+
+    initializer "breakfast.setup_view_helpers" do |app|
+      ActiveSupport.on_load(:action_view) do
+        include ::Breakfast::ViewHelper
+      end
+    end
+
+    config.after_initialize do |app|
+      if Rails.env.development? && defined?(Rails::Server)
+        Process.spawn("brunch watch")
+      end
+
+      listen_to_paths = Array.wrap(config.breakfast.output_folders) +
+        Array.wrap(config.breakfast.view_folders)
+
+      listener = ::Listen.to(*listen_to_paths) do |modified, added, removed|
+        files = modified + added + removed
+        extensions = ["css", "js", "html"].freeze
+
+        extensions.each do |extension|
+          if files.any? { |file| file.match(/\.#{extension}/) }
+            ActionCable.server.broadcast "breakfast_live_reload",
+              { extension: extension }
+          end
+        end
+      end
+
+      listener.start
+    end
+  end
+end

data/lib/breakfast/version.rb

@@ -0,0 +1,3 @@
+module Breakfast
+  VERSION = "0.0.2"
+end

data/lib/breakfast/view_helper.rb

@@ -0,0 +1,13 @@
+module Breakfast
+  module ViewHelper
+    def breakfast_autoreload_tag
+      content_tag :script do
+        <<-SCRIPT.html_safe
+          window.Breakfast = window.Breakfast || {};
+          window.Breakfast.liveReload = #{Rails.configuration.breakfast.live_reload};
+          require("breakfast-rails").init();
+        SCRIPT
+      end
+    end
+  end
+end

data/lib/generators/breakfast/install_generator.rb

@@ -0,0 +1,78 @@
+require "rails/generators"
+
+module Breakfast
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install
+        if prerequisites_installed?
+          create_brunch_config
+          create_package_json
+          create_directory_structure
+          create_initialize_file
+          run_npm_install
+          add_node_modules_to_gitignore
+
+          puts <<-SUCCESS.strip_heredoc
+
+            ---> BREAKFAST INSTALLED SUCCESSFULLY
+            ---> See https://github.com/devlocker/breakfast for documentation and examples.
+
+          SUCCESS
+        else
+          puts <<-ERROR.strip_heredoc
+
+            ---> ERROR - MISSING NODE & NPM
+
+            ---> Node & npm are required to run Breakfast.
+            ---> Please install them before attempting to continue.
+            ---> https://nodejs.org
+            ---> https://npmjs.org
+
+          ERROR
+        end
+      end
+
+      private
+
+      def prerequisites_installed?
+        `which node`.present? && `which npm`.present?
+      end
+
+      def create_brunch_config
+        copy_file "brunch-config.js", "brunch-config.js"
+      end
+
+      def create_package_json
+        copy_file "package.json", "package.json"
+      end
+
+      def create_directory_structure
+        empty_directory "assets/css"
+        empty_directory "assets/images"
+        empty_directory "assets/js"
+        empty_directory "assets/vendor"
+      end
+
+      def create_initialize_file
+        copy_file "initialize.js", "assets/js/initialize.js"
+      end
+
+      def run_npm_install
+        run "npm install"
+      end
+
+      def add_node_modules_to_gitignore
+        ignore = <<-IGNORE.strip_heredoc
+          # Added by Breakfast Gem
+          npm-debug.log
+          node_modules/*
+          public/assets/*
+        IGNORE
+
+        append_to_file(".gitignore", ignore)
+      end
+    end
+  end
+end

data/lib/generators/breakfast/templates/brunch-config.js

@@ -0,0 +1,35 @@
+module.exports = {
+  files: {
+    javascripts: {
+      joinTo: {
+        'app.js': /^assets\/js\//,
+        'vendor.js': /^(?!assets\/js)/
+      }
+    },
+    stylesheets: {
+      joinTo: 'app.css'
+    }
+  },
+
+  plugins: {
+    babel: {
+      presets: ['es2015']
+    },
+  },
+
+  paths: {
+    watched: [
+      "assets/",
+    ],
+
+    public: "public/assets"
+  },
+
+  conventions: {
+     assets: /^(assets\/images)/
+  },
+
+  npm: {
+    enabled: true
+  }
+};

data/lib/generators/breakfast/templates/initialize.js

@@ -0,0 +1,4 @@
+const App = {
+}
+
+module.exports = App;

data/lib/generators/breakfast/templates/package.json

@@ -0,0 +1,14 @@
+{
+  "repository": {},
+  "dependencies": {
+    "babel-brunch": "~6.0.0",
+    "breakfast-rails": "0.0.1",
+    "brunch": "~2.1.3",
+    "clean-css-brunch": "~1.8.0",
+    "css-brunch": "~1.7.0",
+    "javascript-brunch": "~1.8.0",
+    "sass-brunch": "~2.6.3",
+    "uglify-js-brunch": "~1.7.0"
+  },
+  "devDependencies": {}
+}

data/node_package/.npmignore

@@ -0,0 +1 @@
+src/

data/node_package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "breakfast-rails",
+  "version": "0.0.3",
+  "description": "Assets for the Breakfast Gem",
+  "main": "breakfast-rails.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "compile": "babel --presets es2015 -d lib/ src/",
+    "prepublish": "npm run compile"
+  },
+  "author": "Patrick Koperwas",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "babel-cli": "^6.10.1",
+    "babel-preset-es2015": "^6.9.0"
+  }
+}

data/node_package/src/action-cable.js

@@ -0,0 +1,572 @@
+// Copied from Rails source. Rails RC1.
+var ActionCable = {
+  INTERNAL: {
+    "message_types": {
+      "welcome": "welcome",
+      "ping": "ping",
+      "confirmation": "confirm_subscription",
+      "rejection": "reject_subscription"
+    },
+    "default_mount_path": "/cable",
+    "protocols": ["actioncable-v1-json", "actioncable-unsupported"]
+  },
+  WebSocket: window.WebSocket,
+  logger: window.console,
+  createConsumer: function(url) {
+    var ref;
+    if (url == null) {
+      url = (ref = this.getConfig("url")) != null ? ref : this.INTERNAL.default_mount_path;
+    }
+    return new ActionCable.Consumer(this.createWebSocketURL(url));
+  },
+  getConfig: function(name) {
+    var element;
+    element = document.head.querySelector("meta[name='action-cable-" + name + "']");
+    return element != null ? element.getAttribute("content") : void 0;
+  },
+  createWebSocketURL: function(url) {
+    var a;
+    if (url && !/^wss?:/i.test(url)) {
+      a = document.createElement("a");
+      a.href = url;
+      a.href = a.href;
+      a.protocol = a.protocol.replace("http", "ws");
+      return a.href;
+    } else {
+      return url;
+    }
+  },
+  startDebugging: function() {
+    return this.debugging = true;
+  },
+  stopDebugging: function() {
+    return this.debugging = null;
+  },
+  log: function() {
+    var messages, ref;
+    messages = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+    if (this.debugging) {
+      messages.push(Date.now());
+      return (ref = this.logger).log.apply(ref, ["[ActionCable]"].concat(slice.call(messages)));
+    }
+  }
+};
+
+var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+ActionCable.ConnectionMonitor = (function() {
+  var clamp, now, secondsSince;
+
+  ConnectionMonitor.pollInterval = {
+    min: 3,
+    max: 30
+  };
+
+  ConnectionMonitor.staleThreshold = 6;
+
+  function ConnectionMonitor(connection) {
+    this.connection = connection;
+    this.visibilityDidChange = bind(this.visibilityDidChange, this);
+    this.reconnectAttempts = 0;
+  }
+
+  ConnectionMonitor.prototype.start = function() {
+    if (!this.isRunning()) {
+      this.startedAt = now();
+      delete this.stoppedAt;
+      this.startPolling();
+      document.addEventListener("visibilitychange", this.visibilityDidChange);
+      return ActionCable.log("ConnectionMonitor started. pollInterval = " + (this.getPollInterval()) + " ms");
+    }
+  };
+
+  ConnectionMonitor.prototype.stop = function() {
+    if (this.isRunning()) {
+      this.stoppedAt = now();
+      this.stopPolling();
+      document.removeEventListener("visibilitychange", this.visibilityDidChange);
+      return ActionCable.log("ConnectionMonitor stopped");
+    }
+  };
+
+  ConnectionMonitor.prototype.isRunning = function() {
+    return (this.startedAt != null) && (this.stoppedAt == null);
+  };
+
+  ConnectionMonitor.prototype.recordPing = function() {
+    return this.pingedAt = now();
+  };
+
+  ConnectionMonitor.prototype.recordConnect = function() {
+    this.reconnectAttempts = 0;
+    this.recordPing();
+    delete this.disconnectedAt;
+    return ActionCable.log("ConnectionMonitor recorded connect");
+  };
+
+  ConnectionMonitor.prototype.recordDisconnect = function() {
+    this.disconnectedAt = now();
+    return ActionCable.log("ConnectionMonitor recorded disconnect");
+  };
+
+  ConnectionMonitor.prototype.startPolling = function() {
+    this.stopPolling();
+    return this.poll();
+  };
+
+  ConnectionMonitor.prototype.stopPolling = function() {
+    return clearTimeout(this.pollTimeout);
+  };
+
+  ConnectionMonitor.prototype.poll = function() {
+    return this.pollTimeout = setTimeout((function(_this) {
+      return function() {
+        _this.reconnectIfStale();
+        return _this.poll();
+      };
+    })(this), this.getPollInterval());
+  };
+
+  ConnectionMonitor.prototype.getPollInterval = function() {
+    var interval, max, min, ref;
+    ref = this.constructor.pollInterval, min = ref.min, max = ref.max;
+    interval = 5 * Math.log(this.reconnectAttempts + 1);
+    return Math.round(clamp(interval, min, max) * 1000);
+  };
+
+  ConnectionMonitor.prototype.reconnectIfStale = function() {
+    if (this.connectionIsStale()) {
+      ActionCable.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", pollInterval = " + (this.getPollInterval()) + " ms, time disconnected = " + (secondsSince(this.disconnectedAt)) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+      this.reconnectAttempts++;
+      if (this.disconnectedRecently()) {
+        return ActionCable.log("ConnectionMonitor skipping reopening recent disconnect");
+      } else {
+        ActionCable.log("ConnectionMonitor reopening");
+        return this.connection.reopen();
+      }
+    }
+  };
+
+  ConnectionMonitor.prototype.connectionIsStale = function() {
+    var ref;
+    return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
+  };
+
+  ConnectionMonitor.prototype.disconnectedRecently = function() {
+    return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+  };
+
+  ConnectionMonitor.prototype.visibilityDidChange = function() {
+    if (document.visibilityState === "visible") {
+      return setTimeout((function(_this) {
+        return function() {
+          if (_this.connectionIsStale() || !_this.connection.isOpen()) {
+            ActionCable.log("ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = " + document.visibilityState);
+            return _this.connection.reopen();
+          }
+        };
+      })(this), 200);
+    }
+  };
+
+  now = function() {
+    return new Date().getTime();
+  };
+
+  secondsSince = function(time) {
+    return (now() - time) / 1000;
+  };
+
+  clamp = function(number, min, max) {
+    return Math.max(min, Math.min(max, number));
+  };
+
+  return ConnectionMonitor;
+
+})();
+
+var i, message_types, protocols, ref, supportedProtocols, unsupportedProtocol,
+  slice = [].slice,
+  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+  indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+ref = ActionCable.INTERNAL, message_types = ref.message_types, protocols = ref.protocols;
+
+supportedProtocols = 2 <= protocols.length ? slice.call(protocols, 0, i = protocols.length - 1) : (i = 0, []), unsupportedProtocol = protocols[i++];
+
+ActionCable.Connection = (function() {
+  Connection.reopenDelay = 500;
+
+  function Connection(consumer) {
+    this.consumer = consumer;
+    this.open = bind(this.open, this);
+    this.subscriptions = this.consumer.subscriptions;
+    this.monitor = new ActionCable.ConnectionMonitor(this);
+    this.disconnected = true;
+  }
+
+  Connection.prototype.send = function(data) {
+    if (this.isOpen()) {
+      this.webSocket.send(JSON.stringify(data));
+      return true;
+    } else {
+      return false;
+    }
+  };
+
+  Connection.prototype.open = function() {
+    if (this.isActive()) {
+      ActionCable.log("Attempted to open WebSocket, but existing socket is " + (this.getState()));
+      throw new Error("Existing connection must be closed before opening");
+    } else {
+      ActionCable.log("Opening WebSocket, current state is " + (this.getState()) + ", subprotocols: " + protocols);
+      if (this.webSocket != null) {
+        this.uninstallEventHandlers();
+      }
+      this.webSocket = new ActionCable.WebSocket(this.consumer.url, protocols);
+      this.installEventHandlers();
+      this.monitor.start();
+      return true;
+    }
+  };
+
+  Connection.prototype.close = function(arg) {
+    var allowReconnect, ref1;
+    allowReconnect = (arg != null ? arg : {
+      allowReconnect: true
+    }).allowReconnect;
+    if (!allowReconnect) {
+      this.monitor.stop();
+    }
+    if (this.isActive()) {
+      return (ref1 = this.webSocket) != null ? ref1.close() : void 0;
+    }
+  };
+
+  Connection.prototype.reopen = function() {
+    var error, error1;
+    ActionCable.log("Reopening WebSocket, current state is " + (this.getState()));
+    if (this.isActive()) {
+      try {
+        return this.close();
+      } catch (error1) {
+        error = error1;
+        return ActionCable.log("Failed to reopen WebSocket", error);
+      } finally {
+        ActionCable.log("Reopening WebSocket in " + this.constructor.reopenDelay + "ms");
+        setTimeout(this.open, this.constructor.reopenDelay);
+      }
+    } else {
+      return this.open();
+    }
+  };
+
+  Connection.prototype.getProtocol = function() {
+    var ref1;
+    return (ref1 = this.webSocket) != null ? ref1.protocol : void 0;
+  };
+
+  Connection.prototype.isOpen = function() {
+    return this.isState("open");
+  };
+
+  Connection.prototype.isActive = function() {
+    return this.isState("open", "connecting");
+  };
+
+  Connection.prototype.isProtocolSupported = function() {
+    var ref1;
+    return ref1 = this.getProtocol(), indexOf.call(supportedProtocols, ref1) >= 0;
+  };
+
+  Connection.prototype.isState = function() {
+    var ref1, states;
+    states = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+    return ref1 = this.getState(), indexOf.call(states, ref1) >= 0;
+  };
+
+  Connection.prototype.getState = function() {
+    var ref1, state, value;
+    for (state in WebSocket) {
+      value = WebSocket[state];
+      if (value === ((ref1 = this.webSocket) != null ? ref1.readyState : void 0)) {
+        return state.toLowerCase();
+      }
+    }
+    return null;
+  };
+
+  Connection.prototype.installEventHandlers = function() {
+    var eventName, handler;
+    for (eventName in this.events) {
+      handler = this.events[eventName].bind(this);
+      this.webSocket["on" + eventName] = handler;
+    }
+  };
+
+  Connection.prototype.uninstallEventHandlers = function() {
+    var eventName;
+    for (eventName in this.events) {
+      this.webSocket["on" + eventName] = function() {};
+    }
+  };
+
+  Connection.prototype.events = {
+    message: function(event) {
+      var identifier, message, ref1, type;
+      if (!this.isProtocolSupported()) {
+        return;
+      }
+      ref1 = JSON.parse(event.data), identifier = ref1.identifier, message = ref1.message, type = ref1.type;
+      switch (type) {
+        case message_types.welcome:
+          this.monitor.recordConnect();
+          return this.subscriptions.reload();
+        case message_types.ping:
+          return this.monitor.recordPing();
+        case message_types.confirmation:
+          return this.subscriptions.notify(identifier, "connected");
+        case message_types.rejection:
+          return this.subscriptions.reject(identifier);
+        default:
+          return this.subscriptions.notify(identifier, "received", message);
+      }
+    },
+    open: function() {
+      ActionCable.log("WebSocket onopen event, using '" + (this.getProtocol()) + "' subprotocol");
+      this.disconnected = false;
+      if (!this.isProtocolSupported()) {
+        ActionCable.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+        return this.close({
+          allowReconnect: false
+        });
+      }
+    },
+    close: function(event) {
+      ActionCable.log("WebSocket onclose event");
+      if (this.disconnected) {
+        return;
+      }
+      this.disconnected = true;
+      this.monitor.recordDisconnect();
+      return this.subscriptions.notifyAll("disconnected", {
+        willAttemptReconnect: this.monitor.isRunning()
+      });
+    },
+    error: function() {
+      return ActionCable.log("WebSocket onerror event");
+    }
+  };
+
+  return Connection;
+
+})();
+
+var slice = [].slice;
+
+ActionCable.Subscriptions = (function() {
+  function Subscriptions(consumer) {
+    this.consumer = consumer;
+    this.subscriptions = [];
+  }
+
+  Subscriptions.prototype.create = function(channelName, mixin) {
+    var channel, params, subscription;
+    channel = channelName;
+    params = typeof channel === "object" ? channel : {
+      channel: channel
+    };
+    subscription = new ActionCable.Subscription(this.consumer, params, mixin);
+    return this.add(subscription);
+  };
+
+  Subscriptions.prototype.add = function(subscription) {
+    this.subscriptions.push(subscription);
+    this.consumer.ensureActiveConnection();
+    this.notify(subscription, "initialized");
+    this.sendCommand(subscription, "subscribe");
+    return subscription;
+  };
+
+  Subscriptions.prototype.remove = function(subscription) {
+    this.forget(subscription);
+    if (!this.findAll(subscription.identifier).length) {
+      this.sendCommand(subscription, "unsubscribe");
+    }
+    return subscription;
+  };
+
+  Subscriptions.prototype.reject = function(identifier) {
+    var i, len, ref, results, subscription;
+    ref = this.findAll(identifier);
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      subscription = ref[i];
+      this.forget(subscription);
+      this.notify(subscription, "rejected");
+      results.push(subscription);
+    }
+    return results;
+  };
+
+  Subscriptions.prototype.forget = function(subscription) {
+    var s;
+    this.subscriptions = (function() {
+      var i, len, ref, results;
+      ref = this.subscriptions;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        s = ref[i];
+        if (s !== subscription) {
+          results.push(s);
+        }
+      }
+      return results;
+    }).call(this);
+    return subscription;
+  };
+
+  Subscriptions.prototype.findAll = function(identifier) {
+    var i, len, ref, results, s;
+    ref = this.subscriptions;
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      s = ref[i];
+      if (s.identifier === identifier) {
+        results.push(s);
+      }
+    }
+    return results;
+  };
+
+  Subscriptions.prototype.reload = function() {
+    var i, len, ref, results, subscription;
+    ref = this.subscriptions;
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      subscription = ref[i];
+      results.push(this.sendCommand(subscription, "subscribe"));
+    }
+    return results;
+  };
+
+  Subscriptions.prototype.notifyAll = function() {
+    var args, callbackName, i, len, ref, results, subscription;
+    callbackName = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+    ref = this.subscriptions;
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      subscription = ref[i];
+      results.push(this.notify.apply(this, [subscription, callbackName].concat(slice.call(args))));
+    }
+    return results;
+  };
+
+  Subscriptions.prototype.notify = function() {
+    var args, callbackName, i, len, results, subscription, subscriptions;
+    subscription = arguments[0], callbackName = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+    if (typeof subscription === "string") {
+      subscriptions = this.findAll(subscription);
+    } else {
+      subscriptions = [subscription];
+    }
+    results = [];
+    for (i = 0, len = subscriptions.length; i < len; i++) {
+      subscription = subscriptions[i];
+      results.push(typeof subscription[callbackName] === "function" ? subscription[callbackName].apply(subscription, args) : void 0);
+    }
+    return results;
+  };
+
+  Subscriptions.prototype.sendCommand = function(subscription, command) {
+    var identifier;
+    identifier = subscription.identifier;
+    return this.consumer.send({
+      command: command,
+      identifier: identifier
+    });
+  };
+
+  return Subscriptions;
+
+})();
+
+ActionCable.Subscription = (function() {
+  var extend;
+
+  function Subscription(consumer, params, mixin) {
+    this.consumer = consumer;
+    if (params == null) {
+      params = {};
+    }
+    this.identifier = JSON.stringify(params);
+    extend(this, mixin);
+  }
+
+  Subscription.prototype.perform = function(action, data) {
+    if (data == null) {
+      data = {};
+    }
+    data.action = action;
+    return this.send(data);
+  };
+
+  Subscription.prototype.send = function(data) {
+    return this.consumer.send({
+      command: "message",
+      identifier: this.identifier,
+      data: JSON.stringify(data)
+    });
+  };
+
+  Subscription.prototype.unsubscribe = function() {
+    return this.consumer.subscriptions.remove(this);
+  };
+
+  extend = function(object, properties) {
+    var key, value;
+    if (properties != null) {
+      for (key in properties) {
+        value = properties[key];
+        object[key] = value;
+      }
+    }
+    return object;
+  };
+
+  return Subscription;
+
+})();
+
+ActionCable.Consumer = (function() {
+  function Consumer(url) {
+    this.url = url;
+    this.subscriptions = new ActionCable.Subscriptions(this);
+    this.connection = new ActionCable.Connection(this);
+  }
+
+  Consumer.prototype.send = function(data) {
+    return this.connection.send(data);
+  };
+
+  Consumer.prototype.connect = function() {
+    return this.connection.open();
+  };
+
+  Consumer.prototype.disconnect = function() {
+    return this.connection.close({
+      allowReconnect: false
+    });
+  };
+
+  Consumer.prototype.ensureActiveConnection = function() {
+    if (!this.connection.isActive()) {
+      return this.connection.open();
+    }
+  };
+
+  return Consumer;
+
+})();
+
+module.exports = ActionCable

data/node_package/src/breakfast-rails.js

@@ -0,0 +1,11 @@
+let LiveReloader = require("./live-reload")
+
+let BreakfastRails = {
+  init() {
+    let liveReloader = new LiveReloader
+    liveReloader.init()
+  }
+}
+
+// The plugin has to be the module’s default export
+module.exports = BreakfastRails;

data/node_package/src/live-reload.js

@@ -0,0 +1,54 @@
+const ActionCable = require('./action-cable');
+
+class LiveReloader {
+  buildFreshUrl(url) {
+    let date = Math.round(Date.now() / 1000).toString();
+    url = url.replace(/(\&|\\?)version=\d*/, '');
+
+    return(`${url}${(url.indexOf('?') >= 0 ? '&' : '?')}version=${date}`);
+  }
+
+  cssReload() {
+    var reloadableLinkElements = window.top.document.querySelectorAll(
+      'link[rel=stylesheet]:not([data-no-reload]):not([data-pending-removal])'
+    );
+
+    [].slice
+      .call(reloadableLinkElements)
+      .filter(link => link.href)
+      .forEach(link => link.href = this.buildFreshUrl(link.href))
+
+    // Repaint
+    setTimeout(function(){ document.body.offsetHeight; }, 25);
+  }
+
+  pageReload() {
+    window.top.location.reload();
+  }
+
+  init(host = "localhost", port = 3000) {
+    const reloaders = {
+      js: this.pageReload.bind(this),
+      css: this.cssReload.bind(this),
+      html: this.pageReload.bind(this)
+    }
+
+    document.addEventListener('DOMContentLoaded', () => {
+      let Breakfast = window.Breakfast || {};
+
+      if(Breakfast.liveReload) {
+        let reloadChannel = 'Breakfast::LiveReloadChannel'
+
+        Breakfast.cable = ActionCable.createConsumer(`ws://${host}:${port}/cable`);
+        Breakfast.channel = Breakfast.cable.subscriptions.create(reloadChannel, {
+          received: (data) => {
+            let reloader = reloaders[data.extension]
+            reloader();
+          }
+        })
+      }
+    });
+  }
+}
+
+module.exports = LiveReloader;

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: breakfast
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Patrick Koperwas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.0.0.rc2
+- !ruby/object:Gem::Dependency
+  name: actioncable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Replace the asset pipeline with Brunch. Get CSS, JS and HTML live-reloading
+  out of the box. Full ES6 support with require. No need to launch extra servers.
+email:
+- patrick@devlocker.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- breakfast.gemspec
+- lib/breakfast.rb
+- lib/breakfast/live_reload_channel.rb
+- lib/breakfast/railtie.rb
+- lib/breakfast/version.rb
+- lib/breakfast/view_helper.rb
+- lib/generators/breakfast/install_generator.rb
+- lib/generators/breakfast/templates/brunch-config.js
+- lib/generators/breakfast/templates/initialize.js
+- lib/generators/breakfast/templates/package.json
+- node_package/.npmignore
+- node_package/package.json
+- node_package/src/action-cable.js
+- node_package/src/breakfast-rails.js
+- node_package/src/live-reload.js
+homepage: https://github.com/devlocker/breakfast
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Integrates Brunch into Rails
+test_files: []