ovto 0.5.0 → 0.6.0.rc1

data/lib/ovto/middleware.rb

@@ -0,0 +1,121 @@
+module Ovto
+  VALID_NAME_REXP = /\A[a-zA-Z0-9_]+\z/
+  # Create an ancestor of middleware class
+  # Example:
+  #     class MiddlewareExample < Ovto::Middleware("middleware_example")
+  def self.Middleware(name)
+    unless VALID_NAME_REXP =~ name
+      raise "invalid middleware name: #{name}"
+    end
+    return Class.new(Ovto::Middleware::Base){
+      const_set(:OVTO_MIDDLEWARE_NAME, name)
+      const_set(:State, Ovto::State)
+      const_set(:Actions, Class.new(Ovto::Middleware::Actions))
+      const_get(:Actions).const_set(:OVTO_MIDDLEWARE_NAME, name)
+      const_set(:Component, Class.new(Ovto::Middleware::Component))
+      const_get(:Component).const_set(:OVTO_MIDDLEWARE_NAME, name)
+    }
+  end
+
+  module Middleware
+    # (internal) Create a subclass of Ovto::State that handles
+    # states of `middlewares`
+    # Called from App#initialize
+    def self.create_middleware_states_class(middlewares)
+      return Class.new(Ovto::State){
+        middlewares.each do |m|
+          item m.name, default_proc: ->{
+            mw_state_class = m.const_get('State')
+            mw_state_class.item :_middlewares, default_proc: -> {
+              Ovto::Middleware.create_middleware_states_class(m.middlewares).new
+            }
+            mw_state_class.new
+          }
+        end
+      }
+    end
+
+    # Get the state of the middleware specified with `middleware_path`
+    def self.dig_middleware_state(app_state, middleware_path)
+      return middleware_path.inject(app_state){|state, middleware_name|
+        state._middlewares.__send__(middleware_name)
+      }
+    end
+  end
+
+  # Base class of a middleware class
+  # Note: this is not the direct superclass of a middleware.
+  # `SomeMiddleware < (anonymous class) < Middleware::Base`
+  class Middleware::Base
+    # Nested middlewares
+    def self.middlewares
+      @middlewares ||= []
+    end
+
+    # Install a nested middleware
+    def self.use(middleware_class)
+      self.middlewares.push(middleware_class)
+    end
+
+    # Middleware name (set by Ovto.Middleware)
+    def self.name
+      const_get(:OVTO_MIDDLEWARE_NAME)
+    end
+
+    def self._run_setup(wired_action_set)
+      mw = new(wired_action_set[WiredActionSet::THE_MIDDLEWARE_ITSELF])
+      mw.setup
+      self.middlewares.each do |m|
+        m._run_setup(wired_action_set[m.name])
+      end
+    end
+
+    def initialize(wired_actions)
+      @wired_actions = wired_actions
+    end
+
+    # Override this if needed
+    def setup
+    end
+
+    def actions
+      @wired_actions
+    end
+  end
+
+  class Middleware::Actions < Ovto::Actions
+    def initialize(middleware_path)
+      @middleware_path = middleware_path
+    end
+    attr_reader :middleware_path
+
+    # The name of the middleware this Actions belongs to
+    def middleware_name
+      self.class::OVTO_MIDDLEWARE_NAME
+    end
+
+    def state
+      app_state = super
+      return Ovto::Middleware.dig_middleware_state(app_state, @middleware_path)
+    end
+  end
+
+  # Base class of middleware component
+  # Basically the same as Ovto::Component but `actions` is wired to
+  # middleware actions.
+  class Middleware::Component < Ovto::Component
+    def self.middleware_name
+      self::OVTO_MIDDLEWARE_NAME
+    end
+
+    # The name of the middleware this component belongs to
+    def middleware_name
+      self.class::OVTO_MIDDLEWARE_NAME
+    end
+
+    def state
+      app_state = super
+      return Ovto::Middleware.dig_middleware_state(app_state, @middleware_path)
+    end
+  end
+end

data/lib/ovto/pure_component.rb

@@ -2,7 +2,7 @@ module Ovto
   class PureComponent < Component
     class StateIsNotAvailable < StandardError; end
 
-    def initialize(wired_actions)
+    def initialize(*args)
       super
       @prev_props = nil
       @cache = nil

data/lib/ovto/state.rb

@@ -3,7 +3,7 @@ module Ovto
     # Mandatory value is omitted in the argument of State.new
     class MissingValue < StandardError; end
     # Unknown key is given
-    class UnknownKey < StandardError; end
+    class UnknownStateKey < StandardError; end
 
     # (internal) initialize subclass
     def self.inherited(subclass)
@@ -28,15 +28,23 @@ module Ovto
     def initialize(hash = {})
       unknown_keys = hash.keys - self.class.item_specs.map(&:first)
       if unknown_keys.any?
-        raise UnknownKey, "unknown key(s): #{unknown_keys.inspect}"
+        raise UnknownStateKey, "unknown key(s): #{unknown_keys.inspect}"
       end
 
       @values = self.class.item_specs.map{|name, options|
-        if !hash.key?(name) && !options.key?(:default)
+        if !hash.key?(name) && !options.key?(:default) && !options.key?(:default_proc)
           raise MissingValue, ":#{name} is mandatory for #{self.class.name}.new"
         end
         # Note that `hash[key]` may be false or nil
-        value = hash.key?(name) ? hash[name] : options[:default]
+        value = if hash.key?(name) 
+                  hash[name] 
+                elsif options.key?(:default)
+                  options[:default]
+                elsif options.key?(:default_proc)
+                  options[:default_proc].call
+                else
+                  raise "must not happen"
+                end
         [name, value]
       }.to_h
     end
@@ -46,7 +54,7 @@ module Ovto
     def merge(hash)
       unknown_keys = hash.keys - self.class.item_specs.map(&:first)
       if unknown_keys.any?
-        raise UnknownKey, "unknown key(s): #{unknown_keys.inspect}"
+        raise UnknownStateKey, "unknown key(s): #{unknown_keys.inspect}"
       end
       self.class.new(@values.merge(hash))
     end

data/lib/ovto/version.rb

@@ -1,3 +1,3 @@
 module Ovto
-  VERSION = '0.5.0'
+  VERSION = '0.6.0.rc1'
 end

data/lib/ovto/wired_action_set.rb

@@ -0,0 +1,40 @@
+require 'set'
+
+module Ovto
+  # Set of WiredActions (One for the app, zero or more for middlewares)
+  class WiredActionSet
+    # Special key for @hash
+    I_AM_APP_NOT_A_MIDDLEWARE = ''
+    THE_MIDDLEWARE_ITSELF = ''
+
+    # For testing
+    def self.dummy()
+      new(nil, nil, [], [], nil)
+    end
+
+    def initialize(app, actions, middleware_path, middlewares, runtime)
+      @app = app
+      @hash = {}
+      @hash[THE_MIDDLEWARE_ITSELF] = WiredActions.new(actions, app, runtime, self)
+      middlewares.each do |m|
+        mw_path = middleware_path + [m.name]
+        mw_actions = m.const_get('Actions').new(mw_path)
+        mw_wired_action_set = WiredActionSet.new(app, mw_actions, mw_path, m.middlewares, runtime)
+        @hash[m.name] = mw_wired_action_set
+        mw_actions.wired_actions = mw_wired_action_set[THE_MIDDLEWARE_ITSELF]
+      end
+      @middleware_names = middlewares.map(&:name).to_set
+    end
+    attr_reader :app, :middleware_names
+
+    # Return the WiredActions of the app
+    def app_wired_actions
+      @hash[I_AM_APP_NOT_A_MIDDLEWARE]
+    end
+
+    # Return the WiredActions of a middleware
+    def [](name)
+      @hash.fetch(name)
+    end
+  end
+end

data/lib/ovto/wired_actions.rb

@@ -3,18 +3,30 @@ require 'promise'
 
 module Ovto
   class WiredActions
-    def initialize(actions, app, runtime)
-      @actions, @app, @runtime = actions, app, runtime
+    # Create a WiredActions
+    #
+    # - actions: Ovto::Actions
+    # - app: Ovto::App
+    # - runtime: Ovto::Runtime (to call scheduleRender after state change)
+    # - parent: WiredActionSet
+    def initialize(actions, app, runtime, parent)
+      @actions, @app, @runtime, @parent = actions, app, runtime, parent
     end
 
     def method_missing(name, args_hash={})
-      Ovto.log_error {
-        invoke_action(name, args_hash)
-      }
+      raise NoMethodError, "undefined method `#{name}' on #{self}" unless respond_to?(name)
+      if @actions.respond_to?(name)
+        Ovto.log_error {
+          Ovto.debug_trace_log("invoke action \"#{name}\" on #{@actions.class}")
+          invoke_action(name, args_hash)
+        }
+      else
+        @parent[name][WiredActionSet::THE_MIDDLEWARE_ITSELF]  # WiredActions of a middleware named `name`
+      end
     end
 
     def respond_to?(name)
-      @actions.respond_to?(name)
+      @actions.respond_to?(name) || @parent.middleware_names.include?(name)
     end
 
     # internal
@@ -26,8 +38,7 @@ module Ovto
 
     # Call action and schedule rendering
     def invoke_action(name, args_hash)
-      kwargs = {state: @app.state}.merge(args_hash)
-      state_diff = @actions.__send__(name, **kwargs)
+      state_diff = Ovto.send_args_with_state(@actions, name, args_hash, current_state)
       return if state_diff.nil? ||
                 state_diff.is_a?(Promise) || `!!state_diff.then` ||
                 # eg.
@@ -42,12 +53,39 @@ module Ovto
       unless state_diff.is_a?(Hash)
         raise "action `#{name}' must return hash but got #{state_diff.inspect}"
       end
-      new_state = @app.state.merge(state_diff)
-      if new_state != @app.state
+      new_state = current_state.merge(state_diff)
+      if new_state != current_state
         @runtime.scheduleRender
-        @app._set_state(new_state)
+        update_state(new_state)
       end
       return new_state
     end
+
+    def middleware_name
+      @actions.middleware_name
+    end
+
+    def current_state
+      @actions.state
+    end
+
+    def update_state(new_item)
+      new_app_state = _new_app_state(@actions.middleware_path, @app.state, new_item)
+      @app._set_state(new_app_state)
+    end
+
+    def _new_app_state(middleware_path, old_state, new_item)
+      if middleware_path.empty?
+        return new_item
+      else
+        first, *rest = *middleware_path
+        orig_state = old_state._middlewares.__send__(first)
+        return old_state.merge(
+          _middlewares: old_state._middlewares.merge(
+            first => _new_app_state(rest, orig_state, new_item)
+          )
+        )
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ovto
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0.rc1
 platform: ruby
 authors:
 - Yutaka HARA
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-22 00:00:00.000000000 Z
+date: 2020-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -117,7 +117,7 @@ files:
 - docs/api/js/full_list.js
 - docs/api/js/jquery.js
 - docs/api/method_list.html
-- docs/api/pure_component.md
+- docs/api/pure_component.html
 - docs/api/state.html
 - docs/api/top-level-namespace.html
 - docs/gitbook/fonts/fontawesome/FontAwesome.otf
@@ -173,10 +173,12 @@ files:
 - lib/ovto/app.rb
 - lib/ovto/component.rb
 - lib/ovto/fetch.rb
+- lib/ovto/middleware.rb
 - lib/ovto/pure_component.rb
 - lib/ovto/runtime.rb
 - lib/ovto/state.rb
 - lib/ovto/version.rb
+- lib/ovto/wired_action_set.rb
 - lib/ovto/wired_actions.rb
 - ovto.gemspec
 - ovtologo.odg
@@ -198,9 +200,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6.2

data/docs/api/pure_component.md

@@ -1,27 +0,0 @@
-# Ovto::PureComponent
-
-It almost the same as `Ovto::Component`, but it caches the `render` method calling with arguments of the method.
-
-
-## Cache strategy
-
-It compares `render` method arguments and the previous arguments.
-
-```rb
-def render
-  o 'div' do
-    o Pure, foo: state.foo
-    o NotPure bar: state.bar
-  end
-end
-```
-
-In this case, `NotPure` component's render method is called even if `state.foo` is changed.
-Whereas `Pure` component's render method is called only if `state.foo` is changed.
-
-
-## State
-
-`state` method is not available in `PureComponent`, because `PureComponent` does not treat state as the cache key.
-If you'd like to use state in `PureComponent`, pass the state from the parent component.
-