isomorfeus-redux 4.2.0 → 22.9.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 682f48e71ab65fc379f01b587c50b7e57702ac8f384ffc9601e5eddb168a52a6
-  data.tar.gz: 042dd944df15bb97ae485b3387fdc097d7b0579655e033a3eeaced2a62c9d0cc
+  metadata.gz: cb2a80f69bf9d2fd8072da217b8688c44371ee042cdd5606b0121993f9853fe0
+  data.tar.gz: 9eada94e693fcb7c773186d477826791ae9ec6dd8a8d005338e529ea4a795a48
 SHA512:
-  metadata.gz: fa11f3a04fa2e05153855e6721d3ea6d26e59afd49d589e58237d47740ddf1ef8f0949e9bdaba0e4c24eeba875be99e73baab458f673da0819fab67d3534d4e7
-  data.tar.gz: 5edea2b02691953d1868fa3d2333068e98a286f6b6edc522521fa896722b352693c77c35639392ba365161fc143a44ed4df27d764bf94ad16d39c811e64c84ee
+  metadata.gz: 3e253576a134048de72a7dbf89c564d9d9c62be911c076fdf6a07c4386bbffff889a886aea99f2d9d98f8cfcfb4c88b434f9cf5f580132c8e627f3a82f624ecb
+  data.tar.gz: 97e17080904cf7491f04d8776b0257e1b6aa6969be6b23d24c003b275c308aecb9535f342c865bed41e827a2da06b10226c1909b5ab99f3cdb58b8967f23a6b8

data/README.md

@@ -0,0 +1,176 @@
+<h1 align="center">
+<img src="https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-redux/Logo.png?raw=true" align="center" width="234" height="112"/><br/>
+Isomorfeus Redux<br/>
+</h1>
+
+Redux implemented in Ruby (kinda) for the Isomorfeus Framework Project.
+
+### Community and Support
+At the [Isomorfeus Framework Project](https://isomorfeus.com)
+
+## Versioning
+As of version 22.8 isomorfeus-redux implements its own redux like behavior in ruby without depending on the javascript redux package anymore.
+
+## Installation
+Simply add it to the Gemfile:
+```ruby
+gem 'isomorfeus-redux'
+```
+then `bundle install`
+and to your client code add:
+```ruby
+require 'isomorfeus-redux'
+```
+
+## Usage within Isomorfeus
+
+Lucid Components have store access integrated, see the isomorfeus-preact documentation.
+
+The following stores are available:
+- AppState - reactive state managed by redux
+- LocalStore - convenient access to the Browsers localStorage, changes from within ruby can be subscribed to
+- SessionStore - convenient access to the Browsers sessionStorage, changes from within ruby can be subscribed to
+
+### AppState
+All keys must be Strings or Symbols! All values must be serializable, simple types preferred!
+
+Example Usage:
+```ruby
+# setting a value:
+AppState.set_state(some_key: 10)
+
+# getting a value:
+val = AppStore[:some_key]
+val = AppStore.get(:some_key)
+
+# or use dig
+val = AppStore.dig(:some_key, :some_other_key)
+
+# subscribing to changes
+unsub = AppStore.subscribe do
+  @val = AppStore.some_key
+end
+
+# unsubscribe if notification of changes is no longer wanted
+AppStore.unsubscribe(unsub)
+```
+
+### LocalStore
+All keys and values must be Strings or Symbols!
+
+```ruby
+# setting a value:
+LocalStore[:some_key] = 10
+LocalStore.set(:some_key, 10)
+
+# getting a value:
+val = LocalStore[:some_key]
+val = LocalStore.get(:some_key)
+
+# deleting a value
+LocalStore.delete(:some_key)
+
+# clearing the store
+LocalStore.clear
+
+# subscribing to changes
+unsub = LocalStore.subscribe do
+  @val = LocalStore.some_key
+end
+
+# unsubscribe if notification of changes is no longer wanted
+LocalStore.unsubscribe(unsub)
+```
+
+### SessionStore
+All keys and values must be Strings or Symbols!
+
+```ruby
+# setting a value:
+SessionStore[:some_key] = 10
+SessionStore.set(:some_key, 10)
+
+# getting a value:
+val = SessionStore[:some_key]
+val = SessionStore.get(:some_key)
+
+# deleting a value
+SessionStore.delete(:some_key)
+
+# clearing the store
+SessionStore.clear
+
+# subscribing to changes
+unsub = SessionStore.subscribe do
+  @val = SessionStore.some_key
+end
+
+# unsubscribe if notification of changes is no longer wanted
+LocalStore.unsubscribe(unsub)
+```
+
+## Advanced Usage
+
+### Creating a Store
+A store can be created using:
+```ruby
+reducer_hash = { your_store_key_name: reducer }
+preloaded_state = { your_store_key_name: { key: "Value" }}
+store = Redux::Store.new(reducer_hash, preloaded_state, middleware)
+```
+- **reducer** is a ruby proc.
+- **reducer_hash** Multiple keys with procs may be given in the Hash.
+- **preloaded_state** optional, can be a Ruby Hash. If provided, Hash keys must be equal to the keys of the reducer hash
+- **middleware** optional, a ruby proc or array of ruby procs.
+
+### Creating a Reducer
+A reducer is simply a ruby proc:
+```ruby
+reducer = proc do |prev_state, action|
+  # do something here
+  {}.merge(prev_state)
+end
+```
+
+### Adding a reducer to the global store
+```ruby
+Redux::Store.add_reducers(your_store_key_name: reducer)
+```
+### Middleware
+
+A middleware must be ruby proc with the following signature:
+```ruby
+middleware = proc do |action, next_middleware|
+  # do something useful and when finished and if desired, call the next middleware
+  next_middleware.call(action)
+  # not calling the next middleware will prevent the store update
+end
+```
+
+### Global Store
+The store is available from anywhere within Opal Ruby context as:
+```ruby
+Isomorfeus.store
+```
+
+### Other Rubyfications
+- `dispatch` accepts a Ruby Hash
+- `get_state` returns a Ruby Hash
+- `subscribe` accepts a Ruby proc or block as listener:
+```ruby
+Isomorfeus.store.subscribe do
+  # something useful here
+end
+```
+
+### Setup
+If isomorfeus-redux is used in isolation, these methods can be used:
+```ruby
+Redux::Store.add_middleware(middleware) # middleware must be ruby proc
+Redux::Store.init! # initializes the global store
+```
+
+### Specs and Benchmarks
+- clone repo
+- `bundle install`
+- `rake`

data/lib/app_state.rb

@@ -0,0 +1,25 @@
+class AppState
+  class << self
+    def [](key)
+      Isomorfeus.store.get_state.dig(:application_state, key)
+    end
+    alias get []
+
+    def dig(key, *other_keys)
+      Isomorfeus.store.get_state.dig(:application_state, key, *other_keys)
+    end
+
+    def set_state(update)
+      action = { type: 'APPLICATION_STATE', state: update }
+      Isomorfeus.store.deferred_dispatch(action)
+    end
+
+    def subscribe(&block)
+      Isomorfeus.store.subscribe(&block)
+    end
+
+    def unsubscribe(unsubscriber)
+      Isomorfeus.store.unsubscribe(unsubscriber)
+    end
+  end
+end

data/lib/isomorfeus/browser_store_api.rb

@@ -1,21 +1,5 @@
 module Isomorfeus
   module BrowserStoreApi
-    def promise_get(key)
-      Promise.new.resolve(get(key))
-    end
-
-    def promise_set(key, value)
-      Promise.new.resolve(set(key, value))
-    end
-
-    def promise_delete(key)
-      Promise.new.resolve(delete(key))
-    end
-
-    def promise_clear
-      Promise.new.resolve(clear)
-    end
-
     def subscribe(&block)
       key = SecureRandom.uuid
       subscribers[key] = block

data/lib/isomorfeus/redux/config.rb

@@ -1,19 +1,102 @@
 module Isomorfeus
-  class << self
-    attr_reader :store_initialized
-    attr_reader :store
-
-    def init_store
-      return if store_initialized
-      @store_initialized = true
-      force_init_store!
+  if RUBY_ENGINE == 'opal'
+    class << self
+      attr_reader :store_initialized
+      attr_reader :store
+
+      def client_init_after_store_class_names
+        @client_init_after_store_class_names ||= []
+      end
+
+      def add_client_init_after_store_class_name(init_class_name)
+        client_init_after_store_class_names << init_class_name
+      end
+
+      def execute_init_classes
+        client_init_class_names.each do |constant|
+          constant.constantize.send(:init)
+        end
+      end
+
+      def execute_init_after_store_classes
+        client_init_after_store_class_names.each do |constant_name|
+          constant_name.constantize.send(:init)
+        end
+      end
+
+      def init_store
+        return if store_initialized
+        @store_initialized = true
+        force_init_store!
+      end
+
+      def force_init_store!
+        # at least one reducer must have been added at this stage
+        # this happened in isomorfeus-react.rb, where the component reducers were added
+        @store = ::Redux::Store.init!
+        `Opal.Isomorfeus.store = #@store`
+      end
+
+      def something_loading!
+        @something_loading = true
+      end
+
+      def something_loading?
+        res = @something_loading
+        @something_loading = false
+        res
+      end
+
+      def reset_something_loading
+        @something_loading = false
+      end
     end
+  else # RUBY_ENGINE
+    class << self
+      attr_accessor :server_init_class_names
 
-    def force_init_store!
-      # at least one reducer must have been added at this stage
-      # this happened in isomorfeus-react.rb, where the component reducers were added
-      @store = Redux::Store.init!
-      `Opal.Isomorfeus.store = #@store`
+      def execute_init_classes
+        server_init_class_names.each do |constant|
+          constant.constantize.send(:init)
+        end
+      end
+
+      def store_initialized
+        Thread.current[:@_isomorfeus_store_initialized]
+      end
+
+      def store
+        Thread.current[:@_isomorfeus_store]
+      end
+
+      def init_store
+        return if store_initialized
+        Thread.current[:@_isomorfeus_store_initialized] = true
+        force_init_store!
+      end
+
+      def force_init_store!
+        # at least one reducer must have been added at this stage
+        # this happened in isomorfeus-preact.rb, where the component reducers were added
+        Thread.current[:@_isomorfeus_store] = ::Redux::Store.init!
+      end
+
+
+      def something_loading!
+        Thread.current[:isomorfeus_something_loading] = true
+      end
+
+      def something_loading?
+        res = Thread.current[:isomorfeus_something_loading]
+        Thread.current[:isomorfeus_something_loading] = false
+        res
+      end
+
+      def reset_something_loading
+        Thread.current[:isomorfeus_something_loading] = false
+      end
     end
-  end
+
+    server_init_class_names = []
+  end # RUBY_ENGINE
 end

data/lib/isomorfeus/redux/handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Redux
+    class Handler < LucidHandler
+      # responsible for handling LucidObject and LucidQuery
+
+      def process_request(response_agent)
+        # promise_send_path('Isomorfeus::Redux::Handler', [actions...])
+        response_agent.outer_result = { state: {} } unless response_agent.outer_result
+        Isomorfeus.init_store
+        isto = Isomorfeus.store
+        response_agent.request.each do |action|
+          action.transform_keys!(&:to_sym)
+          isto.clear!
+          if current_user.respond_to?(:reload)
+            cu = current_user
+            Thread.current[:isomorfeus_user] = LocalSystem.new
+            begin
+              cu.reload
+            ensure
+              Thread.current[:isomorfeus_user] = cu
+            end
+          end
+          isto.dispatch(action)
+          response_agent.outer_result[:state].deep_merge!(isto.get_state)
+        end
+        response_agent.agent_result = { success: 'ok' }
+      rescue Exception => e
+        STDERR.puts "Isomorfeus::Redux::Handler exception #{e.message}\n#{e.backtrace&.join("\n")}" if Isomorfeus.development?
+        response_agent.error = { error: "Isomorfeus::Redux::Handler: #{e.message}\n#{e.backtrace&.join("\n") if !Isomorfeus.production?}" }
+      end
+    end
+  end
+end

data/lib/isomorfeus/redux/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module Redux
+    VERSION = '22.9.0.rc1'
+  end
+end

data/lib/isomorfeus/redux_imports.rb

@@ -0,0 +1,14 @@
+module Isomorfeus
+  module ReduxImports
+    def self.add
+      # make sure static app stylesheets are imported first, if provided
+      imports_path = File.join(Isomorfeus.app_root, 'imports')
+      if Dir.exist?(imports_path)
+        %w[sass scss css].each do |ending|
+          styles_file = File.join(imports_path, 'stylesheets.' + ending)
+          Isomorfeus.add_web_js_import(styles_file) if File.exist?(styles_file)
+        end
+      end
+    end
+  end
+end

data/lib/{redux/reducers.rb → isomorfeus/redux_reducers.rb}

@@ -1,21 +1,22 @@
-module Redux
-  module Reducers
-    def self.add_application_reducers_to_store
+module Isomorfeus
+  module ReduxReducers
+    def self.add_application_reducers
       unless @_application_reducers_added
         @_application_reducers_added = true
-        app_reducer = Redux.create_reducer do |prev_state, action|
+
+        app_reducer = proc do |prev_state, action|
           case action[:type]
           when 'APPLICATION_STATE'
             if action.key?(:set_state)
               action[:set_state]
             else
-              new_state = {}.merge!(prev_state) # make a copy of state
+              new_state = prev_state.dup # make a copy of state
               if action.key?(:collected)
                 action[:collected].each do |act|
-                  new_state.merge!(act[:name] => act[:value])
+                  new_state.merge!(act[:state])
                 end
               else
-                new_state.merge!(action[:name] => action[:value])
+                new_state.merge!(action[:state])
               end
               new_state
             end
@@ -24,21 +25,21 @@ module Redux
           end
         end
 
-        class_reducer = Redux.create_reducer do |prev_state, action|
+        class_reducer = proc do |prev_state, action|
           case action[:type]
           when 'CLASS_STATE'
             if action.key?(:set_state)
               action[:set_state]
             else
-              new_state = {}.merge!(prev_state) # make a copy of state
+              new_state = prev_state.dup # make a copy of state
               if action.key?(:collected)
                 action[:collected].each do |act|
                   new_state[act[:class]] = {} unless new_state.key?(act[:class])
-                  new_state[act[:class]].merge!(act[:name] => act[:value])
+                  new_state[act[:class]].merge!(act[:state])
                 end
               else
                 new_state[action[:class]] = {} unless new_state.key?(action[:class])
-                new_state[action[:class]].merge!(action[:name] => action[:value])
+                new_state[action[:class]].merge!(action[:state])
               end
               new_state
             end
@@ -46,8 +47,9 @@ module Redux
             prev_state.nil? ? {} : prev_state
           end
         end
-        Redux::Store.preloaded_state_merge!(application_state: {}, class_state: {})
-        Redux::Store.add_reducers(application_state: app_reducer, class_state: class_reducer)
+
+        ::Redux::Store.preloaded_state_merge!(application_state: {}, class_state: {})
+        ::Redux::Store.add_reducers(application_state: app_reducer, class_state: class_reducer)
       end
     end
   end

data/lib/isomorfeus-redux.rb

@@ -1,35 +1,23 @@
 require 'opal'
-require 'isomorfeus/execution_environment'
-require 'isomorfeus/core_ext/kernel'
+require 'isomorfeus-transport'
+require 'isomorfeus/redux/config'
+require 'redux/store'
+require 'isomorfeus/redux_reducers'
+require 'isomorfeus/browser_store_api'
+require 'local_store'
+require 'session_store'
+require 'app_state'
 
-if RUBY_ENGINE == 'opal'
-  require 'native'
-  require 'promise'
-  require 'securerandom'
-  require 'isomorfeus/core_ext/hash/deep_merge'
-  require 'redux'
-  require 'redux/store'
-  require 'redux/reducers'
-  require 'isomorfeus/redux/config'
-  require 'isomorfeus/browser_store_api'
-  require 'local_store'
-  require 'session_store'
-  require 'app_store'
+Isomorfeus::ReduxReducers.add_application_reducers
 
-  Redux::Reducers::add_application_reducers_to_store
-  Isomorfeus.init_store
-else
-  opal_path = Gem::Specification.find_by_name('opal').full_gem_path
-  promise_path = File.join(opal_path, 'stdlib', 'promise.rb')
-  require promise_path
-  require 'redux/version'
-  
-  Opal.append_path(__dir__.untaint)
-
-  require 'isomorfeus-speednode'
-  Isomorfeus.node_paths << File.expand_path(File.join(File.dirname(__FILE__), '..', 'node_modules'))
-  
+if RUBY_ENGINE != 'opal'
+  require 'isomorfeus/redux/version'
   require 'isomorfeus-asset-manager'
-  require 'isomorfeus/redux/imports'
-  Isomorfeus::Redux::Imports.add
+  require 'isomorfeus/redux_imports'
+  Isomorfeus::ReduxImports.add
+
+  require 'isomorfeus/redux/handler'
+
+  require 'iso_opal'
+  Opal.append_path(__dir__.untaint)  unless IsoOpal.paths.include?(__dir__.untaint)
 end

data/lib/local_store.rb

@@ -2,40 +2,37 @@ class LocalStore
   extend Isomorfeus::BrowserStoreApi
 
   class << self
-    def method_missing(key, *args, &block)
-      if Isomorfeus.on_browser?
-        if `args.length > 0`
-          key = `key.endsWith('=')` ? key.chop : key
-          value = args[0]
-          `Opal.global.localStorage.setItem(key, value)`
-          notify_subscribers
-          value
-        else
-          # check store for value
-          value = `Opal.global.localStorage.getItem(key)`
-          return value if value
-        end
+    if RUBY_ENGINE == 'opal'
+      def [](key)
+        value = `Opal.global.localStorage.getItem(key)`
+        return nil if `value == null`
+        value
       end
-      # otherwise return nil
-      return nil
-    end
-
-    alias [] method_missing
-    alias []= method_missing
 
-    alias get method_missing
-    alias set method_missing
+      def []=(key, value)
+        `Opal.global.localStorage.setItem(key, value)`
+        notify_subscribers
+        value
+      end
 
-    def delete(key)
-      `Opal.global.localStorage.removeItem(key)`
-      notify_subscribers
-      nil
-    end
+      def delete(key)
+        `Opal.global.localStorage.removeItem(key)`
+        notify_subscribers
+        nil
+      end
 
-    def clear
-      `Opal.global.localStorage.clear()`
-      notify_subscribers
-      nil
+      def clear
+        `Opal.global.localStorage.clear()`
+        notify_subscribers
+        nil
+      end
+    else
+      def [](key); end
+      def []=(key, value); end
+      def delete(key); end
+      def clear; end
     end
+    alias get []
+    alias set []=
   end
 end