hyper-store 0.99.6 → 1.0.alpha1

data/lib/hyper-store/instance_methods.rb

@@ -1,40 +0,0 @@
-module HyperStore
-  module InstanceMethods
-    def init_store
-      self.class.__instance_states.each do |instance_state|
-        # If the scope is shared then we initialize at the class level
-        next if instance_state[1][:scope] == :shared
-
-        # TODO: Figure out exactly how we're going to handle passing in procs and blocks together
-        # But for now...just do the proc first then the block
-
-        # First initialize value from initializer Proc
-        proc_value = initializer_value(instance_state[1][:initializer])
-        mutate.__send__(:"#{instance_state[0]}", proc_value)
-
-        # Then call the block if a block is passed
-        next unless instance_state[1][:block]
-
-        block_value = instance_eval(&instance_state[1][:block])
-        mutate.__send__(:"#{instance_state[0]}", block_value)
-      end
-
-    end
-
-    def state
-      @state ||= self.class.singleton_class.__state_wrapper.instance_state_wrapper.new(self)
-    end
-
-    def mutate
-      @mutate ||= self.class.singleton_class.__state_wrapper.instance_mutator_wrapper.new(self)
-    end
-
-    private
-
-    def initializer_value(initializer)
-      # We gotta check the arity because a Proc passed in directly from initializer has no args,
-      # but if we created one then we might have wanted self
-      initializer.arity > 0 ? initializer.call(self) : initializer.call
-    end
-  end
-end

data/lib/hyper-store/mutator_wrapper.rb

@@ -1,71 +0,0 @@
-module HyperStore
-  class MutatorWrapper < BaseStoreClass # < BasicObject
-
-    class << self
-      def add_method(klass, method_name, opts = {})
-        define_method(:"#{method_name}") do |*args|
-          from = opts[:scope] == :shared ? klass.state.__from__ : __from__
-          current_value = React::State.get_state(from, method_name.to_s)
-
-          if args.count > 0
-            React::State.set_state(from, method_name.to_s, args[0])
-            current_value
-          else
-            React::State.set_state(from, method_name.to_s, current_value)
-            React::Observable.new(current_value) do |update|
-              React::State.set_state(from, method_name.to_s, update)
-            end
-          end
-        end
-
-        initialize_values(klass, method_name, opts) if initialize_values?(opts)
-      end
-
-      def initialize_values?(opts)
-        [:class, :shared].include?(opts[:scope]) && (opts[:initializer] || opts[:block])
-      end
-
-      def initialize_values(klass, name, opts)
-        initializer = initializer_proc(opts[:initializer], klass, name) if opts[:initializer]
-
-        if initializer && opts[:block]
-          klass.receives(Hyperloop::Application::Boot, initializer) do
-            klass.mutate.__send__(:"#{name}", opts[:block].call)
-          end
-        elsif initializer
-          klass.receives(Hyperloop::Application::Boot, initializer)
-        elsif opts[:block]
-          klass.receives(Hyperloop::Application::Boot) do
-            klass.mutate.__send__(:"#{name}", opts[:block].call)
-          end
-        end
-      end
-
-      private
-
-      def initializer_proc(initializer, klass, name)
-        # We gotta check the arity because a Proc passed in directly from initializer has no args,
-        # but if we created one then we might have wanted the class
-        if initializer.arity > 0
-          -> { klass.mutate.__send__(:"#{name}", initializer.call(klass)) }
-        else
-          -> { klass.mutate.__send__(:"#{name}", initializer.call) }
-        end
-      end
-    end
-
-    attr_accessor :__from__
-
-    def self.new(from)
-      instance = allocate
-      instance.__from__ = from
-      instance
-    end
-
-    # Any method_missing call will create a state and accessor with that name
-    def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-      (class << self; self end).add_method(nil, name)
-      __send__(name, *args, &block)
-    end
-  end
-end

data/lib/hyper-store/state_wrapper.rb

@@ -1,107 +0,0 @@
-module HyperStore
-  class StateWrapper < BaseStoreClass
-    extend ArgumentValidator
-
-    class << self
-      attr_reader :instance_state_wrapper, :class_state_wrapper,
-                  :instance_mutator_wrapper, :class_mutator_wrapper,
-                  :wrappers
-
-      def inherited(subclass)
-        subclass.add_class_instance_vars(subclass) if self == StateWrapper
-      end
-
-      def add_class_instance_vars(subclass)
-        @shared_state_wrapper     = subclass
-        @instance_state_wrapper   = Class.new(@shared_state_wrapper)
-        @class_state_wrapper      = Class.new(@shared_state_wrapper)
-
-        @shared_mutator_wrapper   = Class.new(MutatorWrapper)
-        @instance_mutator_wrapper = Class.new(@shared_mutator_wrapper)
-        @class_mutator_wrapper    = Class.new(@shared_mutator_wrapper)
-
-        @wrappers = [@instance_state_wrapper, @instance_mutator_wrapper,
-                     @class_state_wrapper, @class_mutator_wrapper]
-      end
-
-      def define_state_methods(klass, *args, &block)
-        return self if args.empty?
-
-        name, opts = validate_args!(klass, *args, &block)
-
-        add_readers(klass, name, opts)
-        klass.singleton_class.state.add_error_methods(name, opts)
-        klass.singleton_class.state.add_methods(klass, name, opts)
-        klass.singleton_class.state.remove_methods(name, opts)
-        klass.send(:"__#{opts[:scope]}_states") << [name, opts]
-      end
-
-      def add_readers(klass, name, opts)
-        return unless opts[:reader]
-
-        if [:instance, :shared].include?(opts[:scope])
-          klass.class_eval do
-            define_method(:"#{opts[:reader]}") { state.__send__(:"#{name}") }
-          end
-        end
-
-        if [:class, :shared].include?(opts[:scope])
-          klass.define_singleton_method(:"#{opts[:reader]}") { state.__send__(:"#{name}") }
-        end
-      end
-
-      def add_error_methods(name, opts)
-        return if opts[:scope] == :shared
-
-        [@shared_state_wrapper, @shared_mutator_wrapper].each do |klass|
-          klass.define_singleton_method(:"#{name}") do
-            'nope!'
-          end
-        end
-      end
-
-      def add_methods(klass, name, opts)
-        instance_variable_get("@#{opts[:scope]}_state_wrapper").add_method(klass, name, opts)
-        instance_variable_get("@#{opts[:scope]}_mutator_wrapper").add_method(klass, name, opts)
-      end
-
-      def add_method(klass, method_name, opts = {})
-        define_method(:"#{method_name}") do
-          from = opts[:scope] == :shared ? klass.state.__from__ : @__from__
-          React::State.get_state(from, method_name.to_s)
-        end
-      end
-
-      def remove_methods(name, opts)
-        return unless opts[:scope] == :shared
-
-        wrappers.each do |wrapper|
-          wrapper.send(:remove_method, :"#{name}") if wrapper.respond_to?(:"#{name}")
-        end
-      end
-
-      def default_scope(klass)
-        if self == klass.singleton_class.__state_wrapper.class_state_wrapper
-          :instance
-        else
-          :class
-        end
-      end
-    end
-
-    attr_accessor :__from__
-
-    def self.new(from)
-      instance = allocate
-      instance.__from__ = from
-      instance
-    end
-
-    # Any method_missing call will create a state and accessor with that name
-    def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-      $method_missing = [name, *args]
-      (class << self; self end).add_method(nil, name) #(class << self; self end).superclass.add_method(nil, name)
-      __send__(name, *args, &block)
-    end
-  end
-end

data/lib/hyper-store/state_wrapper/argument_validator.rb

@@ -1,91 +0,0 @@
-module HyperStore
-  class StateWrapper < BaseStoreClass
-    module ArgumentValidator
-      class InvalidOptionError < StandardError; end
-
-      def validate_args!(klass, *args, &block)
-        name, initial_value, opts = parse_arguments(*args, &block)
-
-        opts[:scope]     ||= default_scope(klass)
-        opts[:initializer] = validate_initializer(initial_value, klass, opts)
-        opts[:block]       = block if block
-
-        if opts[:reader]
-          opts[:reader] = opts[:reader] == true ? name : opts[:reader]
-        end
-
-        [name, opts]
-      end
-
-      private
-
-      def invalid_option(message)
-        raise InvalidOptionError, message
-      end
-
-      # Parses the arguments given to get the name, initial_value (if any), and options
-      def parse_arguments(*args)
-        # If the only argument is a hash, the first key => value is name => inital_value
-        if args.first.is_a?(Hash)
-          # If the first key passed in is not the name, raise an error
-          if [:reader, :initializer, :scope].include?(args.first.keys.first.to_sym)
-            message = 'The name of the state must be specified first as '\
-                      "either 'state :name' or 'state name: nil'"
-            invalid_option(message)
-          end
-
-          name, initial_value = args[0].shift
-        # Otherwise just the name is passed in by itself first
-        else
-          name = args.shift
-        end
-
-        # [name, initial_value (can be nil), args (if nil then return an empty hash)]
-        [name, initial_value, args[0] || {}]
-      end
-
-      # Converts the initialize option to a Proc
-      def validate_initializer(initial_value, klass, opts) # rubocop:disable Metrics/MethodLength
-        # If we pass in the name as a hash with a value ex: state foo: :bar,
-        # we just put that value inside a Proc and return that
-        if initial_value != nil
-          dup_or_return_intial_value(initial_value)
-        # If we pass in the initialize option
-        elsif opts[:initializer]
-          # If it's a Symbol we convert to to a Proc that calls the method on the instance
-          if [Symbol, String].include?(opts[:initializer].class)
-            method_name = opts[:initializer]
-            if [:class, :shared].include?(opts[:scope])
-              -> { klass.send(:"#{method_name}") }
-            else
-              ->(instance) { instance.send(:"#{method_name}") }
-            end
-          # If it is already a Proc we do nothing and just return what was given
-          elsif opts[:initializer].is_a?(Proc)
-            opts[:initializer]
-          # If it's not a Proc or a String we raise an error and return an empty Proc
-          else
-            invalid_option("'state' option 'initialize' must either be a Symbol or a Proc")
-            -> {}
-          end
-        # Otherwise if it's not specified we just return an empty Proc
-        else
-          -> {}
-        end
-      end
-
-      # Dup the initial value if possible, otherwise just return it
-      # Ruby has no nice way of doing this...
-      def dup_or_return_intial_value(value)
-        value =
-          begin
-            value.dup
-          rescue
-            value
-          end
-
-        -> { value }
-      end
-    end
-  end
-end

data/lib/hyper-store/version.rb

@@ -1,3 +0,0 @@
-module HyperStore
-  VERSION = '0.99.6'
-end

data/lib/hyperloop/application/boot.rb

@@ -1,34 +0,0 @@
-module Hyperloop
-  # insure at least a stub of operation is defined.  If
-  # Hyperloop::Operation is already loaded it will have
-  # defined these.
-  class Operation
-    class << self
-      def on_dispatch(&block)
-        receivers << block
-      end unless method_defined? :on_dispatch
-
-      def receivers
-        # use the force: true option so that system code needing to receive
-        # boot will NOT be erased on the next Hyperloop::Context.reset!
-        Hyperloop::Context.set_var(self, :@receivers, force: true) { [] }
-      end unless method_defined? :receivers
-    end
-  end
-  class Application
-    class Boot < Operation
-      class ReactDummyParams
-        attr_reader :context
-        def initialize(context)
-          @context = context
-        end
-      end
-      def self.run(context: nil)
-        params = ReactDummyParams.new(context)
-        receivers.each do |receiver|
-          receiver.call params
-        end
-      end
-    end unless defined? Boot
-  end
-end

data/lib/hyperloop/store.rb

@@ -1,12 +0,0 @@
-module Hyperloop
-  class Store
-    class << self
-      def inherited(child)
-        child.include(Mixin)
-      end
-    end
-    def initialize
-      init_store
-    end
-  end
-end

data/lib/hyperloop/store/mixin.rb

@@ -1,21 +0,0 @@
-module Hyperloop
-  class Store
-    module Mixin
-      class << self
-        def included(base)
-          base.include(HyperStore::InstanceMethods)
-          base.extend(HyperStore::ClassMethods)
-          base.extend(HyperStore::DispatchReceiver)
-
-          base.singleton_class.define_singleton_method(:__state_wrapper) do
-            @__state_wrapper ||= Class.new(HyperStore::StateWrapper)
-          end
-
-          base.singleton_class.define_singleton_method(:state) do |*args, &block|
-            __state_wrapper.define_state_methods(base, *args, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/react/observable.rb

@@ -1,29 +0,0 @@
-module React
-  class Observable
-    def initialize(value, on_change = nil, &block)
-      @value = value
-      @on_change = on_change || block
-    end
-
-    def method_missing(method_sym, *args, &block)
-      @value.send(method_sym, *args, &block).tap { |result| @on_change.call @value }
-    end
-
-    def respond_to?(method, *args)
-      if [:call, :to_proc].include? method
-        true
-      else
-        @value.respond_to? method, *args
-      end
-    end
-
-    def call(new_value)
-      @on_change.call new_value
-      @value = new_value
-    end
-
-    def to_proc
-      lambda { |arg = @value| @on_change.call arg }
-    end
-  end
-end

data/lib/react/state.rb

@@ -1,157 +0,0 @@
-module React
-  class State
-
-    ALWAYS_UPDATE_STATE_AFTER_RENDER = Hyperloop.on_client? # if on server then we don't wait to update the state
-    @rendering_level = 0
-
-    class << self
-      attr_reader :current_observer
-
-      def has_observers?(object, name)
-        !observers_by_name[object][name].empty?
-      end
-
-      def bulk_update
-        saved_bulk_update_flag = @bulk_update_flag
-        @bulk_update_flag = true
-        yield
-      ensure
-        @bulk_update_flag = saved_bulk_update_flag
-      end
-
-      # React already will batch together updates inside of event handlers
-      # so we don't have to, and having Hyperstack batch them outside of the
-      # event handler causes INPUT/TEXT/SELECT s not to work properly.
-      # This method is called by the Component event wrapper.
-      def ignore_bulk_updates(*args)
-        saved_ignore_bulk_update_flag = @ignore_bulk_update_flag
-        @ignore_bulk_update_flag = true
-        yield(*args)
-      ensure
-        @ignore_bulk_update_flag = saved_ignore_bulk_update_flag
-      end
-
-      def set_state2(object, name, value, updates, exclusions = nil)
-        # set object's name state to value, tell all observers it has changed.
-        # Observers must implement update_react_js_state
-        object_needs_notification = object.respond_to?(:update_react_js_state)
-        observers_by_name[object][name].dup.each do |observer|
-          next if exclusions && exclusions.include?(observer)
-          updates[observer] += [object, name, value]
-          object_needs_notification = false if object == observer
-        end
-        updates[object] += [nil, name, value] if object_needs_notification
-      end
-
-      def initialize_states(object, initial_values) # initialize objects' name/value pairs
-        states[object].merge!(initial_values || {})
-      end
-
-      def get_state(object, name, current_observer = @current_observer)
-        # get current value of name for object, remember that the current object depends on this state,
-        # current observer can be overriden with last param
-        if current_observer && !new_observers[current_observer][object].include?(name)
-          new_observers[current_observer][object] << name
-        end
-        if @delayed_updates && @delayed_updates[object][name]
-          @delayed_updates[object][name][1] << current_observer
-        end
-        states[object][name]
-      end
-
-      # ReactDOM.unstable_batchedUpdates does not seem to improve things here, ill leave it here commented for reference
-      # and later investigation
-      #if `ReactDOM.unstable_batchedUpdates !== undefined`
-      #  %x{
-      #    ReactDOM.unstable_batchedUpdates(function(){
-      #      #{updates.each { |observer, args| observer.update_react_js_state(*args) }}
-      #    });
-      #  }
-      #else # run the other one
-      def set_state(object, name, value, delay=ALWAYS_UPDATE_STATE_AFTER_RENDER)
-        states[object][name] = value
-        delay = false if object.respond_to?(:set_state_synchronously?) && object.set_state_synchronously?
-        if !@ignore_bulk_update_flag && (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
-            delayed_updates = @delayed_updates
-            @delayed_updates = Hash.new { |h, k| h[k] = {} } # could this be nil???
-            @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) }
-          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
-      ensure
-        'Disabling JIT for Safari bug'
-      end
-
-      def will_be_observing?(object, name, current_observer)
-        current_observer && new_observers[current_observer][object].include?(name)
-      end
-
-      def is_observing?(object, name, current_observer)
-        current_observer && observers_by_name[object][name].include?(current_observer)
-      end
-
-      def update_states_to_observe(current_observer = @current_observer)  # should be called after the last after_render callback, currently called after components render method
-        raise "update_states_to_observer called outside of watch block" unless current_observer
-        current_observers[current_observer].each do |object, names|
-          names.each do |name|
-            observers_by_name[object][name].delete(current_observer)
-          end
-        end
-        observers = current_observers[current_observer] = new_observers[current_observer]
-        new_observers.delete(current_observer)
-        observers.each do |object, names|
-          names.each do |name|
-            observers_by_name[object][name] << current_observer
-          end
-        end
-      end
-
-      def remove # call after component is unmounted
-        raise "remove called outside of watch block" unless @current_observer
-        current_observers[@current_observer].each do |object, names|
-          names.each do |name|
-            observers_by_name[object][name].delete(@current_observer)
-          end
-        end
-        current_observers.delete(@current_observer)
-      end
-
-      def set_state_context_to(observer, rendering = nil) # wrap all execution that may set or get states in a block so we know which observer is executing
-        saved_current_observer = @current_observer
-        @current_observer = observer
-        @rendering_level += 1 if rendering
-        return_value = yield
-        return_value
-      ensure
-        @current_observer = saved_current_observer
-        @rendering_level -= 1 if rendering
-        return_value
-      end
-
-      def states
-        @states ||= Hash.new { |h, k| h[k] = {} }
-      end
-
-      [:new_observers, :current_observers, :observers_by_name].each do |method_name|
-        define_method(method_name) do
-          instance_variable_get("@#{method_name}") ||
-          instance_variable_set("@#{method_name}", Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } })
-        end
-      end
-    end
-  end
-end