isomorfeus-redux 4.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f0fa508494a00cb6c953ec0660d5a25fcdfeeadfe860b521cc60568da02357d
+  data.tar.gz: 7b318ed593527284d0e946067c278dceed3a4eaa0e8fbc0941b111c1f49d688a
+SHA512:
+  metadata.gz: fb7e38b768252ae140861adb4fe56afdec8b6e74704a710efec364eeaa168a849e07b66dad85b59bb4af5fbaa80d685064d27ecaedbe6abfb5b68fb027ba9d15
+  data.tar.gz: 93e6ee7ae5bb629f0d480b71e87c96c49299102f37b41875e670911da5987619707ae1077d4e57abc4e508cbaa2d77fd2bc4f9b26f10d4c155fe09fab7d5879c

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/README.md

@@ -0,0 +1,94 @@
+# isomorfeus-redux
+
+Redux for Opal Ruby.
+
+## Versioning
+isomorfeus-redux version follows the Redux version which features and API it implements.
+Isomorfeus-redux 4.0.x implements features and the API of Redux 4.0 and should be used with Redux4.0
+
+## Installation
+To install redux with the matching version:
+```
+yarn add redux@4.0.0
+```
+then add to the Gemfile:
+```ruby
+gem 'isomorfeus-redux'
+```
+then `bundle install`
+and to your client code add:
+```ruby
+require 'isomorfeus-redux'
+```
+## Usage
+Because isomorfeus-redux follows closely the Redux principles/implementation/API and Documentation, most things of the official Redux documentation
+apply, but in the Ruby way, see:
+- https://redux.js.org
+
+Redux and accompanying libraries must be imported and available in the global namespace in the application javascript entry file,
+with webpack this can be ensured by assigning them to the global namespace:
+```javascript
+import * as Redux from 'redux';
+global.Redux = Redux;
+```
+
+Following features are presented with its differences to the Javascript Redux implementation.
+Of course, in Ruby the naming is underscored, eg. `Redux.createStore` in javascript becomes `Redux.create_store` in Ruby.
+
+### Creating a Store
+A store can be created using:
+```ruby
+store = Redux::Store.new(reducer, preloaded_state, enhancer)
+```
+or:
+```ruby
+store = Redux.create_store(reducer, preloaded_state, enhancer)
+```
+- **reducer** is a javascript function. Isomorfeus provides a helper to create a reducer, see below.
+- **preloaded_state** can be a Ruby Hash or a native javascript object.
+- **enhancer** is a javascript function.
+
+### Creating a Reducer
+Its possible to use native javascript functions for creating a store. To use ruby conveniently for reducers a helper is provided:
+```ruby
+reducer = Redux.create_reducer do |prev_state, action|
+  # do something here 
+  {}.merge(prev_state) 
+end
+```
+This helper wraps the ruby code block in a javascript function that takes care of converting Opal Hashes to javascript
+objects and the other way around. The resulting reducer is simply javascript function, suitable for creating a store.
+
+### Adding a reducer to the global store
+The reducer must be a Javascript function and can be created with Redux.create_reducer as above:
+```ruby
+Redux::Store.add_reducer(your_store_key_name: reducer)
+```
+
+### Global Store
+The store is available from anywhere within Opal Ruby context as:
+```ruby
+Isomorfeus.store
+```
+To get the native store from within Javascript context:
+```javascript
+Opal.Isomorfeus.store.native
+```
+### Other Rubyfications
+- `dispatch` accepts a Ruby Hash
+- `get_state` returns a Ruby Hash
+- `subscribe` accepts a ruby block as listener:
+```ruby
+Isomorfeus.store.subscribe do
+  # something useful here
+end
+```
+### Setup
+This is done automatically within Isomorfeus. If isomorfeus-redux is used in isolation, these methods can be used:
+```ruby
+Redux::Store.add_middleware(middleware) # middleware must be Javascript function
+Redux::Store.init! # initializes the global store
+```
+
+### Development Tools
+The Redux Development Tools allow for detailed debugging of store/state changes: https://github.com/zalmoxisus/redux-devtools-extension

data/isomorfeus-redux.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require_relative 'lib/redux/version.rb'
+
+Gem::Specification.new do |s|
+  s.name          = 'isomorfeus-redux'
+  s.version       = Redux::VERSION
+
+  s.authors       = ['Jan Biedermann']
+  s.email         = ['jan@kursator.com']
+  s.homepage      = 'http://isomorfeus.com'
+  s.summary       = 'Redux for Opal Ruby.'
+  s.license       = 'MIT'
+  s.description   = 'Use a global store and write reducers for it in Opal Ruby.'
+
+  s.files         = `git ls-files`.split("\n").reject { |f| f.match(%r{^(gemfiles|s)/}) }
+  # s.test_files    = `git ls-files -- {test,s,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_dependency 'opal', '>= 0.11.0', '< 0.12.0'
+end

data/lib/isomorfeus-redux.rb

@@ -0,0 +1,22 @@
+if RUBY_ENGINE == 'opal'
+  require 'native'
+  require 'promise'
+  require 'redux/version'
+  require 'redux'
+  require 'redux/store'
+  # store initialization happens in Isomorfeus.init, see isomorfeus-react/lib/isomorfeus/config.rb
+else
+  require 'opal'
+  require 'isomorfeus/promise'
+  require 'redux/version'
+
+  Opal.append_path(__dir__.untaint)
+
+  if Dir.exist?(File.join('app', 'isomorfeus'))
+    # Opal.append_path(File.expand_path(File.join('app', 'isomorfeus', 'components')))
+    Opal.append_path(File.expand_path(File.join('app', 'isomorfeus'))) unless Opal.paths.include?(File.expand_path(File.join('app', 'isomorfeus')))
+  elsif Dir.exist?('isomorfeus')
+    # Opal.append_path(File.expand_path(File.join('isomorfeus', 'components')))
+    Opal.append_path(File.expand_path('isomorfeus')) unless Opal.paths.include?(File.expand_path('isomorfeus'))
+  end
+end

data/lib/isomorfeus/promise.rb

@@ -0,0 +1,350 @@
+# taken from https://github.com/ruby-hyperloop/isomorfeus-operation/blob/edge/lib/isomorfeus-operation/promise.rb
+# TODO: This is used only server side and may be used by others too and should be a separate gem maybe
+
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :error, :prev, :next
+
+  def initialize(action = {})
+    @action = action
+
+    @realized  = false
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = false
+
+    @prev = nil
+    @next = []
+  end
+
+  def value
+    if Promise === @value
+      @value.value
+    else
+      @value
+    end
+  end
+
+  def act?
+    @action.has_key?(:success) || @action.has_key?(:always)
+  end
+
+  def action
+    @action.keys
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    !!@realized
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def pending?
+    !realized?
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next << promise
+
+    if exception?
+      promise.reject(@delayed[0])
+    elsif resolved?
+      promise.resolve(@delayed ? @delayed[0] : value)
+    elsif rejected?
+      if !@action.has_key?(:failure) || Promise === (@delayed ? @delayed[0] : @error)
+        promise.reject(@delayed ? @delayed[0] : error)
+      elsif promise.action.include?(:always)
+        promise.reject(@delayed ? @delayed[0] : error)
+      end
+    end
+
+    self
+  end
+
+  def resolve(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:success] || @action[:always]
+        value = block.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    @realized = :resolve
+    @value    = value
+
+    if @next.any?
+      @next.each { |p| p.resolve(value) }
+    else
+      @delayed = [value]
+    end
+  end
+
+  def reject(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:failure] || @action[:always]
+        value = block.call(value)
+      end
+
+      if @action.has_key?(:always)
+        resolve!(value)
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    @realized = :reject
+    @error    = value
+
+    if @next.any?
+      @next.each { |p| p.reject(value) }
+    else
+      @delayed = [value]
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    self ^ Promise.new(success: block)
+  end
+
+  def then!(&block)
+    there_can_be_only_one!
+    self.then(&block)
+  end
+
+  alias do then
+  alias do! then!
+
+  def fail(&block)
+    self ^ Promise.new(failure: block)
+  end
+
+  def fail!(&block)
+    there_can_be_only_one!
+    fail(&block)
+  end
+
+  alias rescue fail
+  alias catch fail
+  alias rescue! fail!
+  alias catch! fail!
+
+  def always(&block)
+    self ^ Promise.new(always: block)
+  end
+
+  def always!(&block)
+    there_can_be_only_one!
+    always(&block)
+  end
+
+  alias finally always
+  alias ensure always
+  alias finally! always!
+  alias ensure! always!
+
+  def trace(depth = nil, &block)
+    self ^ Trace.new(depth, block)
+  end
+
+  def trace!(*args, &block)
+    there_can_be_only_one!
+    trace(*args, &block)
+  end
+
+  def there_can_be_only_one!
+    if @next.any?
+      raise ArgumentError, 'a promise has already been chained'
+    end
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next.any?
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      current = []
+
+      if promise.act? || promise.prev.nil?
+        current.push(promise.value)
+      end
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(depth, block)
+      @depth = depth
+
+      super success: proc {
+        trace = Trace.it(self).reverse
+        trace.pop
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next.any?
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end

data/lib/redux.rb

@@ -0,0 +1,45 @@
+module Redux
+
+  def self.create_store(reducer, preloaded_state = nil, enhancer = nil)
+    Redux::Store.new(reducer, preloaded_state, enhancer)
+  end
+
+  def self.combine_reducers(reducers)
+    %x{
+      var real_reducers;
+      if (typeof reducers.$class === "function") {
+        real_reducers = reducers.$to_n();
+      } else {
+        real_reducers = reducers;
+      }
+      return Redux.combineReducers(real_reducers);
+    }
+  end
+
+  def self.apply_middleware(*middlewares)
+    if middlewares.size == 1
+      `Redux.applyMiddleware.apply(null, middlewares[0])`
+    else
+      `Redux.applyMiddleware.apply(null, middlewares)`
+    end
+  end
+
+  def self.bind_action_creators(*args)
+    dispatch = args.pop()
+    `Redux.bindActionCreators(args, dispatch)`
+  end
+
+  def self.compose(*functions)
+    `Redux.compose(functions)`
+  end
+
+  def self.create_reducer(&block)
+    %x{
+      return (function(previous_state, action) {
+        var new_state = block.$call(Opal.Hash.$new(previous_state), Opal.Hash.$new(action));
+        if (typeof new_state.$class === "function") { new_state = new_state.$to_n(); }
+        return new_state;
+      });
+    }
+  end
+end

data/lib/redux/store.rb

@@ -0,0 +1,133 @@
+module Redux
+  class Store
+    include Native::Wrapper
+
+    def self.add_middleware(middleware)
+      if Isomorfeus.store
+        `console.warning("Adding middleware after Store initialization may have side effects! Saving state and initializing new store with restored state!")`
+        middlewares << middleware
+        preloaded_state = Isomorfeus.store.get_state
+        init!
+      else
+        middlewares << middleware
+      end
+    end
+
+    def self.add_reducer(reducer)
+      if Isomorfeus.store
+        # if the store has been initalized already, add the reducer to the instance
+        Isomorfeus.store.add_reducer(reducer)
+      else
+        # otherwise just add it to the reducers, so that they will be used when initializing the store
+        preloaded_state[reducer.keys.first] = {} unless preloaded_state.has_key?(reducer.keys.first)
+        reducers.merge!(reducer)
+      end
+    end
+
+    def self.add_reducers(new_reducers)
+      if Isomorfeus.store
+        # if the store has been initalized already, add the reducer to the instance
+        Isomorfeus.store.add_reducers(new_reducers)
+      else
+        # otherwise just add it to the reducers, so that they will be used when initializing the store
+        new_reducers.each do |key, value|
+          add_reducer(key => value)
+        end
+      end
+    end
+
+    # called from Isomorfeus.init
+    def self.init!
+      next_reducer = Redux.combine_reducers(@reducers)
+      if middlewares.any?
+        enhancer = Redux.apply_middleware(middlewares)
+        Redux::Store.new(next_reducer, preloaded_state, enhancer)
+      else
+        Redux::Store.new(next_reducer, preloaded_state)
+      end
+    end
+
+    def self.middlewares
+      @middlewares ||= []
+    end
+
+    def self.preloaded_state_merge!(ruby_hash)
+      preloaded_state.merge!(ruby_hash)
+    end
+
+    def self.preloaded_state
+      @preloaded_state ||= {}
+    end
+
+    def self.preloaded_state=(ruby_hash)
+      @preloaded_state = ruby_hash
+    end
+
+    def self.reducers
+      @reducers ||= {}
+    end
+
+    def initialize(reducer, preloaded_state = `null`, enhancer = `null`)
+      %x{
+        var real_preloaded_state;
+        if (typeof preloaded_state.$class === "function" && preloaded_state.$class() == "Hash") {
+          if (preloaded_state.$size() == 0) {
+            real_preloaded_state = null;
+          } else {
+            real_preloaded_state = preloaded_state.$to_n();
+          }
+        } else if (preloaded_state == nil) {
+          real_preloaded_state = null;
+        } else {
+          real_preloaded_state = preloaded_state;
+        }
+        if (enhancer && real_preloaded_state) {
+          this.native = Redux.createStore(reducer, real_preloaded_state, enhancer);
+        } else if (real_preloaded_state) {
+          this.native = Redux.createStore(reducer, real_preloaded_state);
+        } else if (enhancer) {
+          this.native = Redux.createStore(reducer, enhancer);
+        } else {
+          this.native = Redux.createStore(reducer);
+        }
+      }
+    end
+
+    def add_reducer(reducer)
+      self.class.reducers << reducer
+      next_reducer = Redux.combine_reducers(*self.class.reducers)
+      self.replace_reducer = next_reducer
+    end
+
+    def add_reducers(new_reducers)
+
+      self.class.reducers.merge!(new_reducers)
+
+      next_reducer = Redux.combine_reducers(self.class.reducers)
+      replace_reducer(next_reducer)
+    end
+
+    def dispatch(action)
+      %x{
+        if (typeof action.$class === "function" && action.$class() == "Hash") {
+          this.native.dispatch(action.$to_n());
+        } else {
+          this.native.dispatch(action);
+        }
+      }
+    end
+
+    def get_state
+      Hash.new(`this.native.getState()`)
+    end
+
+    def replace_reducer(next_reducer)
+      `this.native.replaceReducer(next_reducer)`
+    end
+
+    # returns function needed to unsubscribe the listener
+    def subscribe(&listener)
+      `this.native.subscribe(function() { return listener$.call(); })`
+    end
+  end
+end

data/lib/redux/version.rb

@@ -0,0 +1,3 @@
+module Redux
+  VERSION = '4.0.0'
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: isomorfeus-redux
+version: !ruby/object:Gem::Version
+  version: 4.0.0
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: Use a global store and write reducers for it in Opal Ruby.
+email:
+- jan@kursator.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- isomorfeus-redux.gemspec
+- lib/isomorfeus-redux.rb
+- lib/isomorfeus/promise.rb
+- lib/redux.rb
+- lib/redux/store.rb
+- lib/redux/version.rb
+homepage: http://isomorfeus.com
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Redux for Opal Ruby.
+test_files: []