flux_on_rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e9c16b33be38701e19bfde520bf1ef5421791a5
+  data.tar.gz: 04857336ca59b89e15c6fbe006d2a9e58a61b061
+SHA512:
+  metadata.gz: 654895bb308f17dc12d6a1e6167aedfbe1ad5dec01ef4e9df7b43c1e7d22074c17d622d0ac25c0fb2f4aedf8206c6fe15317b5d8cedfb2c4dab70bab559628ee
+  data.tar.gz: ac009cf993b6442682708fb929e82baa8edc23335d0249ea0ff71d90470c93ee618be13038e2b5323a2d44e9a304a9c61e431d9eff634dcb732986749448c629

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ed Shadi
+
+MIT License
+
+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,45 @@
+# FluxOnRails
+Generate basic React and Flux structure:
+- **react.js file:** from Facebook
+- **dispatcher.js file:** from Facebook
+- **app/assets/components directory:** this is where you'll do all of your React component work with jsx
+- **app/assets/javascripts/components directory:** transformed React components jsx => js
+- **app/assets/javascripts/actions directory:** flux actions
+- **app/assets/javascripts/dispatchers directory:** flux dispatchers
+- **app/assets/javascripts/stores directory:** flux stores
+- **app/assets/javascripts/constants directory:** flux constants
+- **vendor/assets/javascripts/form-builder directory:** React plugin for building forms a la Rails. For documentation and useage: vendor/assets/javascripts/form-builder/README.md
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'flux_on_rails', group: :development
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flux_on_rails
+
+## Usage
+
+```ruby
+# Generate sturcture and assets
+rails g flux_on_rails:install
+
+# Watch and transform the jsx components (keep that runing)
+rake react:build
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/flux_on_rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/flux_on_rails.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flux_on_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flux_on_rails"
+  spec.version       = FluxOnRails::VERSION
+  spec.authors       = ["Ed Shadi"]
+  spec.email         = ["edshadi@gmail.com"]
+  spec.summary       = %q{Flux and React generators and setup for Rails}
+  spec.description   = %q{Flux and React generators for Rails}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/flux_on_rails.rb

@@ -0,0 +1,5 @@
+require "flux_on_rails/version"
+
+module FluxOnRails
+  # Your code goes here...
+end

data/lib/flux_on_rails/version.rb

@@ -0,0 +1,3 @@
+module FluxOnRails
+  VERSION = "1.0.0"
+end

data/lib/generators/flux_on_rails/install_generator.rb

@@ -0,0 +1,51 @@
+require 'rails/generators/base'
+module FluxOnRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+      desc "Adds ReactJS and base folder structure"
+
+      def js_manifest
+        @js_manifest ||= find_or_create_js_manifest
+      end
+      def generate_assets
+        add_react
+        add_react_form_builder
+        add_flux_dispatcher
+        add_flux_dirs
+        add_tasks
+      end
+
+      private
+      def find_or_create_js_manifest
+        manifest = 'app/assets/javascripts/application.js'
+        copy_file("application.js", manifest) unless File.exist?(manifest)
+        manifest
+      end
+      def add_react_form_builder
+        insert_into_file js_manifest, "//= require form-for\n", :after => "react\n"
+        directory 'react-form-for-object', 'vendor/assets/javascripts/react-form-for-object'
+        copy_file 'form-for.js', 'vendor/assets/javascripts/form-for.js'
+      end
+      def add_react
+        insert_into_file js_manifest, "//= require react\n", :after => "jquery_ujs\n"
+        copy_file 'react.js', 'vendor/assets/javascripts/react.js'
+      end
+      def add_flux_dispatcher
+        insert_into_file js_manifest, "//= require dispatcher\n", :after => "react\n"
+        copy_file 'dispatcher.js', 'vendor/assets/javascripts/dispatcher.js'
+      end
+      def add_flux_dirs
+        directory 'components', 'app/assets/components'
+        directory 'components', 'app/assets/javascripts/react'
+        directory 'stores', 'app/assets/javascripts/stores'
+        directory 'actions', 'app/assets/javascripts/actions'
+        directory 'constants', 'app/assets/javascripts/constants'
+        directory 'dispatchers', 'app/assets/javascripts/dispatchers'
+      end
+      def add_tasks
+        copy_file 'tasks/react_tasks.rake', 'lib/tasks/react_tasks.rake'
+      end
+    end
+  end
+end

data/lib/generators/flux_on_rails/templates/actions/example-actions.js

@@ -0,0 +1,22 @@
+//= require dispatchers/app-dispatcher
+//= require constants/app-constants
+var ExampleActions = {
+  createExample: function(data) {
+    AppDispatcher.handleViewAction({
+      type: AppConstants.CREATE_EXAMPLE,
+      data: data
+    })
+  },
+  updateExample: function(data) {
+    AppDispatcher.handleViewAction({
+      type: AppConstants.UPDATE_EXAMPLE,
+      data: data
+    })
+  },
+  destroyExample: function(id) {
+    AppDispatcher.handleViewAction({
+      type: AppConstants.DESTROY_EXAMPLE,
+      id: id
+    })
+  }
+}

data/lib/generators/flux_on_rails/templates/application.js

@@ -0,0 +1,3 @@
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/lib/generators/flux_on_rails/templates/constants/app-constants.js

@@ -0,0 +1,5 @@
+var AppConstants = {
+  CREATE_EXAMPLE: 'CREATE_EXAMPLE',
+  UPDATE_EXAMPLE: 'UPDATE_EXAMPLE',
+  DESTROY_EXAMPLE: 'DESTROY_EXAMPLE'
+}

data/lib/generators/flux_on_rails/templates/dispatcher.js

@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule Dispatcher
+ * @typechecks
+ */
+ /**
+ * Dispatcher is used to broadcast payloads to registered callbacks. This is
+ * different from generic pub-sub systems in two ways:
+ *
+ *   1) Callbacks are not subscribed to particular events. Every payload is
+ *      dispatched to every registered callback.
+ *   2) Callbacks can be deferred in whole or part until other callbacks have
+ *      been executed.
+ *
+ * For example, consider this hypothetical flight destination form, which
+ * selects a default city when a country is selected:
+ *
+ *   var flightDispatcher = new Dispatcher();
+ *
+ *   // Keeps track of which country is selected
+ *   var CountryStore = {country: null};
+ *
+ *   // Keeps track of which city is selected
+ *   var CityStore = {city: null};
+ *
+ *   // Keeps track of the base flight price of the selected city
+ *   var FlightPriceStore = {price: null}
+ *
+ * When a user changes the selected city, we dispatch the payload:
+ *
+ *   flightDispatcher.dispatch({
+ *     actionType: 'city-update',
+ *     selectedCity: 'paris'
+ *   });
+ *
+ * This payload is digested by `CityStore`:
+ *
+ *   flightDispatcher.register(function(payload)) {
+ *     if (payload.actionType === 'city-update') {
+ *       CityStore.city = payload.selectedCity;
+ *     }
+ *   });
+ *
+ * When the user selects a country, we dispatch the payload:
+ *
+ *   flightDispatcher.dispatch({
+ *     actionType: 'country-update',
+ *     selectedCountry: 'australia'
+ *   });
+ *
+ * This payload is digested by both stores:
+ *
+ *    CountryStore.dispatchToken = flightDispatcher.register(function(payload) {
+ *     if (payload.actionType === 'country-update') {
+ *       CountryStore.country = payload.selectedCountry;
+ *     }
+ *   });
+ *
+ * When the callback to update `CountryStore` is registered, we save a reference
+ * to the returned token. Using this token with `waitFor()`, we can guarantee
+ * that `CountryStore` is updated before the callback that updates `CityStore`
+ * needs to query its data.
+ *
+ *   CityStore.dispatchToken = flightDispatcher.register(function(payload) {
+ *     if (payload.actionType === 'country-update') {
+ *       // `CountryStore.country` may not be updated.
+ *       flightDispatcher.waitFor([CountryStore.dispatchToken]);
+ *       // `CountryStore.country` is now guaranteed to be updated.
+ *
+ *       // Select the default city for the new country
+ *       CityStore.city = getDefaultCityForCountry(CountryStore.country);
+ *     }
+ *   });
+ *
+ * The usage of `waitFor()` can be chained, for example:
+ *
+ *   FlightPriceStore.dispatchToken =
+ *     flightDispatcher.register(function(payload)) {
+ *       switch (payload.actionType) {
+ *         case 'country-update':
+ *           flightDispatcher.waitFor([CityStore.dispatchToken]);
+ *           FlightPriceStore.price =
+ *             getFlightPriceStore(CountryStore.country, CityStore.city);
+ *           break;
+ *
+ *         case 'city-update':
+ *           FlightPriceStore.price =
+ *             FlightPriceStore(CountryStore.country, CityStore.city);
+ *           break;
+ *     }
+ *   });
+ *
+ * The `country-update` payload will be guaranteed to invoke the stores'
+ * registered callbacks in order: `CountryStore`, `CityStore`, then
+ * `FlightPriceStore`.
+ */
+var Dispatcher = (function() {
+  var _lastID = 1;
+  var _prefix = 'ID_';
+  /**
+   * Use invariant() to assert state which your program assumes to be true.
+   *
+   * Provide sprintf-style format (only %s is supported) and arguments
+   * to provide information about what broke and what you were
+   * expecting.
+   *
+   * The invariant message will be stripped in production, but the invariant
+   * will remain to ensure logic does not differ in production.
+   */
+  var invariant = function(condition, format, a, b, c, d, e, f) {
+    if (false) {
+      if (format === undefined) {
+        throw new Error('invariant requires an error message argument');
+      }
+    }
+
+    if (!condition) {
+      var error;
+      if (format === undefined) {
+        error = new Error(
+          'Minified exception occurred; use the non-minified dev environment ' +
+          'for the full error message and additional helpful warnings.'
+        );
+      } else {
+        var args = [a, b, c, d, e, f];
+        var argIndex = 0;
+        error = new Error(
+          'Invariant Violation: ' +
+          format.replace(/%s/g, function() { return args[argIndex++]; })
+        );
+      }
+
+      error.framesToPop = 1; // we don't care about invariant's own frame
+      throw error;
+    }
+  };
+  var _Dispatcher = function() {
+    "use strict";
+    this.$Dispatcher_callbacks = {};
+    this.$Dispatcher_isPending = {};
+    this.$Dispatcher_isHandled = {};
+    this.$Dispatcher_isDispatching = false;
+    this.$Dispatcher_pendingPayload = null;
+  }
+  /**
+   * Registers a callback to be invoked with every dispatched payload. Returns
+   * a token that can be used with `waitFor()`.
+   *
+   * @param {function} callback
+   * @return {string}
+   */
+  _Dispatcher.prototype.register=function(callback) {"use strict";
+    var id = _prefix + _lastID++;
+    this.$Dispatcher_callbacks[id] = callback;
+    return id;
+  };
+
+  /**
+   * Removes a callback based on its token.
+   *
+   * @param {string} id
+   */
+  _Dispatcher.prototype.unregister=function(id) {"use strict";
+    invariant(
+      this.$Dispatcher_callbacks[id],
+      'Dispatcher.unregister(...): `%s` does not map to a registered callback.',
+      id
+    );
+    delete this.$Dispatcher_callbacks[id];
+  };
+
+  /**
+   * Waits for the callbacks specified to be invoked before continuing execution
+   * of the current callback. This method should only be used by a callback in
+   * response to a dispatched payload.
+   *
+   * @param {array<string>} ids
+   */
+  _Dispatcher.prototype.waitFor=function(ids) {"use strict";
+    invariant(
+      this.$Dispatcher_isDispatching,
+      'Dispatcher.waitFor(...): Must be invoked while dispatching.'
+    );
+    for (var ii = 0; ii < ids.length; ii++) {
+      var id = ids[ii];
+      if (this.$Dispatcher_isPending[id]) {
+        invariant(
+          this.$Dispatcher_isHandled[id],
+          'Dispatcher.waitFor(...): Circular dependency detected while ' +
+          'waiting for `%s`.',
+          id
+        );
+        continue;
+      }
+      invariant(
+        this.$Dispatcher_callbacks[id],
+        'Dispatcher.waitFor(...): `%s` does not map to a registered callback.',
+        id
+      );
+      this.$Dispatcher_invokeCallback(id);
+    }
+  };
+
+  /**
+   * Dispatches a payload to all registered callbacks.
+   *
+   * @param {object} payload
+   */
+  _Dispatcher.prototype.dispatch=function(payload) {"use strict";
+    invariant(
+      !this.$Dispatcher_isDispatching,
+      'Dispatch.dispatch(...): Cannot dispatch in the middle of a dispatch.'
+    );
+    this.$Dispatcher_startDispatching(payload);
+    try {
+      for (var id in this.$Dispatcher_callbacks) {
+        if (this.$Dispatcher_isPending[id]) {
+          continue;
+        }
+        this.$Dispatcher_invokeCallback(id);
+      }
+    } finally {
+      this.$Dispatcher_stopDispatching();
+    }
+  };
+
+  /**
+   * Is this Dispatcher currently dispatching.
+   *
+   * @return {boolean}
+   */
+  _Dispatcher.prototype.isDispatching=function() {"use strict";
+    return this.$Dispatcher_isDispatching;
+  };
+
+  /**
+   * Call the calback stored with the given id. Also do some internal
+   * bookkeeping.
+   *
+   * @param {string} id
+   * @internal
+   */
+  _Dispatcher.prototype.$Dispatcher_invokeCallback=function(id) {"use strict";
+    this.$Dispatcher_isPending[id] = true;
+    this.$Dispatcher_callbacks[id](this.$Dispatcher_pendingPayload);
+    this.$Dispatcher_isHandled[id] = true;
+  };
+
+  /**
+   * Set up bookkeeping needed when dispatching.
+   *
+   * @param {object} payload
+   * @internal
+   */
+  _Dispatcher.prototype.$Dispatcher_startDispatching=function(payload) {"use strict";
+    for (var id in this.$Dispatcher_callbacks) {
+      this.$Dispatcher_isPending[id] = false;
+      this.$Dispatcher_isHandled[id] = false;
+    }
+    this.$Dispatcher_pendingPayload = payload;
+    this.$Dispatcher_isDispatching = true;
+  };
+
+  /**
+   * Clear bookkeeping used for dispatching.
+   *
+   * @internal
+   */
+  _Dispatcher.prototype.$Dispatcher_stopDispatching=function() {"use strict";
+    this.$Dispatcher_pendingPayload = null;
+    this.$Dispatcher_isDispatching = false;
+  };
+  return _Dispatcher;
+}())