Ruby DSL wrapper of React Router V4. Requires ReactRouter and ReactRouterDOM.

+ Hyperloop.js includes Hyperloop's client side Components, Operations and Stores.

+ Hyperloop-compiler.js includes Opal Compiler for compiling Ruby Hyperloop code in your browser.

+ Hyper-router includes a client-side build of the Hyper-router gem

If you do not want a backend then you can use Hyperloop-compiler.js to compile code in your browser. Your ruby code will be compiled by the browser into JavaScript and executed. Any compilation or runtime errors will be briefly reported to the console.

+ Hyperloop Gem for Rails integration (including Isomprphic Models & Operations)

+ Opal Sprockets for Rack backend for a simple build process

+ Minimal Rake task to compile with Opal

+ Node.js using Webpack to compile Opal code

See all the installation options on http://ruby-hyperloop.io/

The simplest way to install is with NPM.

TODO: requires and how they work....

puts "About to build hyper-router.js"

File.binwrite 'hyper-router.js', Opal::Builder.build('hyper-router').to_s

puts "done"

puts "About to build hyper-router.min.js"

js_file = "hyper-router.js"

js_min_file = "./dist/hyper-router.min.js"

File.open(js_min_file, "w").write(Uglifier.new.compile(File.read(js_file)))

puts "done"

var self = Opal.top, $scope = Opal, nil = Opal.nil, $breaker = Opal.breaker, $slice = Opal.slice, $module = Opal.module, $klass = Opal.klass, $hash2 = Opal.hash2;

Opal.add_stubs(['$require', '$[]=', '$[]', '$states', '$new', '$after', '$structure_check', '$each', '$set_state2', '$key?', '$current_observers', '$update_react_js_state', '$==']);

self.$require("react/top_level_render");

return (function($base) {

var $React, self = $React = $module($base, 'React');

var def = self.$$proto, $scope = self.$$scope;

(function($base, $super) {

function $State(){};

var self = $State = $klass($base, $super, 'State', $State);

var def = self.$$proto, $scope = self.$$scope, TMP_10;

return (Opal.defs(self, '$set_state', TMP_10 = function $$set_state(object, name, value, delay) {

var $a, $b, $c, TMP_1, $d, TMP_2, TMP_8, $e, TMP_9, self = this, updates = nil;

if (self.bulk_update_flag == null) self.bulk_update_flag = nil;

if (self.delayed_updates == null) self.delayed_updates = nil;

if (self.delayed_updater == null) self.delayed_updater = nil;

if (self.rendering_level == null) self.rendering_level = nil;

if (delay == null) {

delay = $scope.get('ALWAYS_UPDATE_STATE_AFTER_RENDER');

}

self.$states()['$[]'](object)['$[]='](name, value);

if ((($a = ((($b = delay) !== false && $b !== nil && $b != null) ? $b : self.bulk_update_flag)) !== nil && $a != null && (!$a.$$is_boolean || $a == true))) {

((($a = self.delayed_updates) !== false && $a !== nil && $a != null) ? $a : self.delayed_updates = ($b = ($c = $scope.get('Hash')).$new, $b.$$p = (TMP_1 = function(h, k){var self = TMP_1.$$s || this;

if (h == null) h = nil;if (k == null) k = nil;

return h['$[]='](k, $hash2([], {}))}, TMP_1.$$s = self, TMP_1.$$arity = 2, TMP_1), $b).call($c));

self.delayed_updates['$[]'](object)['$[]='](name, [value, $scope.get('Set').$new()]);

((($a = self.delayed_updater) !== false && $a !== nil && $a != null) ? $a : self.delayed_updater = ($b = ($d = self).$after, $b.$$p = (TMP_2 = function(){var self = TMP_2.$$s || this, $e, $f, TMP_3, $g, TMP_4, $h, TMP_5, $i, TMP_7, delayed_updates = nil, updates = nil;

if (self.delayed_updates == null) self.delayed_updates = nil;

self.$structure_check("delayed set state");

delayed_updates = self.delayed_updates;

self.delayed_updates = ($e = ($f = $scope.get('Hash')).$new, $e.$$p = (TMP_3 = function(h, k){var self = TMP_3.$$s || this;

if (h == null) h = nil;if (k == null) k = nil;

return h['$[]='](k, $hash2([], {}))}, TMP_3.$$s = self, TMP_3.$$arity = 2, TMP_3), $e).call($f);

self.delayed_updater = nil;

updates = ($e = ($g = $scope.get('Hash')).$new, $e.$$p = (TMP_4 = function(hash, key){var self = TMP_4.$$s || this;

if (hash == null) hash = nil;if (key == null) key = nil;

return hash['$[]='](key, $scope.get('Array').$new())}, TMP_4.$$s = self, TMP_4.$$arity = 2, TMP_4), $e).call($g);

($e = ($h = delayed_updates).$each, $e.$$p = (TMP_5 = function(object, name_hash){var self = TMP_5.$$s || this, $i, $j, TMP_6;

if (object == null) object = nil;if (name_hash == null) name_hash = nil;

return ($i = ($j = name_hash).$each, $i.$$p = (TMP_6 = function(name, value_and_set){var self = TMP_6.$$s || this;

if (name == null) name = nil;if (value_and_set == null) value_and_set = nil;

return self.$set_state2(object, name, value_and_set['$[]'](0), updates, value_and_set['$[]'](1))}, TMP_6.$$s = self, TMP_6.$$arity = 2, TMP_6), $i).call($j)}, TMP_5.$$s = self, TMP_5.$$arity = 2, TMP_5), $e).call($h);

($e = ($i = updates).$each, $e.$$p = (TMP_7 = function(observer, args){var self = TMP_7.$$s || this, $j;

if (observer == null) observer = nil;if (args == null) args = nil;

if ((($j = self.$current_observers()['$key?'](observer)) !== nil && $j != null && (!$j.$$is_boolean || $j == true))) {

return ($j = observer).$update_react_js_state.apply($j, Opal.to_a(args))

} else {

return nil

}}, TMP_7.$$s = self, TMP_7.$$arity = 2, TMP_7), $e).call($i);

return updates = nil;}, TMP_2.$$s = self, TMP_2.$$arity = 0, TMP_2), $b).call($d, 0.001));

} else if (self.rendering_level['$=='](0)) {

updates = ($a = ($b = $scope.get('Hash')).$new, $a.$$p = (TMP_8 = function(hash, key){var self = TMP_8.$$s || this;

if (hash == null) hash = nil;if (key == null) key = nil;

return hash['$[]='](key, $scope.get('Array').$new())}, TMP_8.$$s = self, TMP_8.$$arity = 2, TMP_8), $a).call($b);

self.$set_state2(object, name, value, updates);

($a = ($e = updates).$each, $a.$$p = (TMP_9 = function(observer, args){var self = TMP_9.$$s || this, $f;

if (observer == null) observer = nil;if (args == null) args = nil;

return ($f = observer).$update_react_js_state.apply($f, Opal.to_a(args))}, TMP_9.$$s = self, TMP_9.$$arity = 2, TMP_9), $a).call($e);};

return value;

}, TMP_10.$$arity = -4), nil) && 'set_state'

})($scope.base, null)

})($scope.base);

module React

class State

def self.set_state(object, name, value, delay=ALWAYS_UPDATE_STATE_AFTER_RENDER)

states[object][name] = value

if delay || @bulk_update_flag

@delayed_updates ||= Hash.new { |h, k| h[k] = {} }

@delayed_updates[object][name] = [value, Set.new]

@delayed_updater ||= after(0.001) do

structure_check('delayed set state')

delayed_updates = @delayed_updates

@delayed_updates = Hash.new { |h, k| h[k] = {} }

@delayed_updater = nil

updates = Hash.new { |hash, key| hash[key] = Array.new }

delayed_updates.each do |object, name_hash|

name_hash.each do |name, value_and_set|

set_state2(object, name, value_and_set[0], updates, value_and_set[1])

end

end

updates.each { |observer, args|

observer.update_react_js_state(*args) if current_observers.key?(observer)

}

updates = nil

end

elsif @rendering_level == 0

updates = Hash.new { |hash, key| hash[key] = Array.new }

set_state2(object, name, value, updates)

updates.each { |observer, args| observer.update_react_js_state(*args) }

end

value

end

end

{

"name": "hyperloop-js",

"version": "1.0.0",

"description": "Ruby Hyperloop client-side components",

"main": "./dist/hyperloop.js",

"scripts": {

"test": "echo \"Error: no test specified\" && exit 1"

},

"repository": {

"type": "git",

"url": "git+https://github.com/ruby-hyperloop/hyperloop-js.git"

},

"keywords": [

"ruby",

"compiler",

"opal"

],

"author": "Ruby Hyperloop team",

"license": "MIT",

"bugs": {

"url": "https://github.com/ruby-hyperloop/hyperloop-js/issues"

},

"homepage": "http://ruby-hyperloop.io/"

}