hyper-store 0.99.6 → 1.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 993335049ccaa5877cb790abaec2ab168f89e5bc1ec38d89616f6733cd05867f
-  data.tar.gz: cb09118eb82ad5e8f9fa28f107b15e114eb3defc436702de3c883cca9933a869
+  metadata.gz: 77cc0e86a8c00fb007cbb5db453a451b789d4e76b2ede5a65e1f2087bd8900e9
+  data.tar.gz: 95a9f7383681b7ac4d17300ddecdd941cbed5bb2b3956d2cfa2fc41f137ecefb
 SHA512:
-  metadata.gz: '0862df2d650305d95b9969041418a2ae426f25bb8636702644d2586fae982fbde183fdfcc243a595293635c056e39ab9487bdb4ae520f3843893755e00e21024'
-  data.tar.gz: fc88e1de07631474812e52362a540413a5ffc62f9a2d45b0040258e5e0227052a4dc2edad45a75a56029bbfa26cc54410d9f67eb5c64a7cd9e63effb834a1602
+  metadata.gz: 0c6278fda522efd1cc951a9f445ef604f5c4b198b28ec24b5b177a6eea2e7ffb13903d15a67174aadb851d1606645f922ce77614f7e6d3d521d63f7a0c0124e0
+  data.tar.gz: 209a0ba1e9bcb7a5ac685f0b37c277ad92c697553acde01fd6f48dae9897895c6d7bc8f1248af6d42085e638c6871537abdb3ab98e41efccf91b6a926889356e

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
-#gem "opal-jquery", git: "https://github.com/opal/opal-jquery.git", branch: "master"
 gem 'hyper-spec',       path: '../hyper-spec'
-gem 'hyperloop-config', path: '../hyperloop-config'
+gem 'hyperstack-config', path: '../hyperstack-config'
 gem 'hyper-component',  path: '../hyper-component'
+gem 'hyper-state', path: '../hyper-state'
 gemspec

data/hyper-store.gemspec

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hyper-store/version'
+require 'hyperstack/legacy/store/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'hyper-store'
-  spec.version       = HyperStore::VERSION
+  spec.version       = Hyperstack::Legacy::Store::VERSION
   spec.authors       = ['Mitch VanDuyn', 'Adam Creekroad', 'Jan Biedermann']
   spec.email         = ['mitch@catprint.com', 'jan@kursator.com']
   spec.summary       = 'Flux Stores and more for Hyperloop'
@@ -21,23 +21,28 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'hyperloop-config', HyperStore::VERSION
+  spec.add_dependency 'hyperstack-config', Hyperstack::Legacy::Store::VERSION
+  spec.add_dependency 'hyper-state', Hyperstack::Legacy::Store::VERSION
   spec.add_dependency 'opal', '>= 0.11.0', '< 0.12.0'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'chromedriver-helper'
-  spec.add_development_dependency 'hyper-component', HyperStore::VERSION
-  spec.add_development_dependency 'hyper-spec', HyperStore::VERSION
+  spec.add_development_dependency 'hyper-component', Hyperstack::Legacy::Store::VERSION
+  spec.add_development_dependency 'hyper-spec', Hyperstack::Legacy::Store::VERSION
   spec.add_development_dependency 'listen'
-  spec.add_development_dependency 'mini_racer', '~> 0.2.4'
+  spec.add_development_dependency 'mini_racer', '~> 0.1.15'
   spec.add_development_dependency 'opal-browser', '~> 0.2.0'
   spec.add_development_dependency 'opal-rails', '~> 0.9.4'
   spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'pry-rescue'
   spec.add_development_dependency 'puma'
   spec.add_development_dependency 'rails', '>= 4.0.0'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'react-rails', '>= 2.4.0', '< 2.5.0'
   spec.add_development_dependency 'rspec', '~> 3.7.0'
+  spec.add_development_dependency 'rspec-rails'
   spec.add_development_dependency 'rspec-steps', '~> 2.1.1'
   spec.add_development_dependency 'rubocop', '~> 0.51.0'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'timecop', '~> 0.8.1'
+
 end

data/lib/hyper-store.rb

@@ -1,24 +1,29 @@
 require 'set'
-require 'hyperloop-config'
-Hyperloop.import 'hyper-store'
+require 'hyperstack-config'
+require 'hyper-state'
+Hyperstack.import 'hyper-store'
 
-
-module HyperStore # allows us to easily turn off BasicObject for debug
-  class BaseStoreClass < BasicObject
+module Hyperstack
+  module Internal
+    module Store
+      # allows us to easily turn off BasicObject for debug
+      class BaseStoreClass < BasicObject
+      end
+    end
   end
 end
 
-require 'hyper-store/class_methods'
-require 'hyper-store/dispatch_receiver'
-require 'hyper-store/instance_methods'
-require 'hyper-store/mutator_wrapper'
-require 'hyper-store/state_wrapper/argument_validator'
-require 'hyper-store/state_wrapper'
-require 'hyper-store/version'
-require 'hyperloop/store'
-require 'hyperloop/application/boot'
-require 'hyperloop/store/mixin'
-require 'react/state'
+require 'hyperstack/internal/store/class_methods'
+require 'hyperstack/internal/store/dispatch_receiver'
+require 'hyperstack/internal/store/instance_methods'
+require 'hyperstack/internal/store/mutator_wrapper'
+require 'hyperstack/internal/store/observable'
+require 'hyperstack/internal/store/state_wrapper/argument_validator'
+require 'hyperstack/internal/store/state_wrapper'
+require 'hyperstack/internal/store/state'
+
+require 'hyperstack/legacy/store'
+require 'hyperstack/legacy/store/version'
 
 if RUBY_ENGINE != 'opal'
   require 'opal'

data/lib/hyperstack/internal/store/class_methods.rb

@@ -0,0 +1,36 @@
+module Hyperstack
+  module Internal
+    module Store
+      module ClassMethods
+        attr_accessor :__shared_states, :__class_states, :__instance_states
+
+        def state(*args, &block)
+          # If we're passing in any arguments then we are calling the macro to define a state
+          if args.count > 0
+            singleton_class.__state_wrapper.class_state_wrapper
+                           .define_state_methods(self, *args, &block)
+          # Otherwise we are just accessing it
+          else
+            @state ||= singleton_class.__state_wrapper.class_state_wrapper.new(self)
+          end
+        end
+
+        def mutate
+          @mutate ||= singleton_class.__state_wrapper.class_mutator_wrapper.new(self)
+        end
+
+        def __shared_states
+          @__shared_states ||= []
+        end
+
+        def __class_states
+          @__class_states ||= []
+        end
+
+        def __instance_states
+          @__instance_states ||= []
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/store/dispatch_receiver.rb

@@ -0,0 +1,41 @@
+module Hyperstack
+  module Internal
+    module Store
+      module DispatchReceiver
+
+        attr_accessor :params
+
+        def receives(*args, &block)
+          # Format the callback to be Proc or Nil
+          callback = format_callback(args)
+
+          if args.empty?
+            message = 'At least one operation must be passed in to the \'receives\' macro'
+            raise Legacy::Store::InvalidOperationError, message
+          end
+
+          # Loop through receivers and call callback and block on dispatch
+          args.each do |operation|
+            operation.on_dispatch do |params|
+              @params = params
+
+              callback.call if callback
+              yield params if block
+            end
+          end
+        end
+
+        private
+
+        def format_callback(args)
+          if args.last.is_a?(Symbol)
+            method_name = args.pop
+            -> { send(:"#{method_name}") }
+          elsif args.last.is_a?(Proc)
+            args.pop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/store/instance_methods.rb

@@ -0,0 +1,45 @@
+module Hyperstack
+  module Internal
+    module Store
+      module InstanceMethods
+        def init_store
+          return if @__hyperstack_store_initialized
+          @__hyperstack_store_initialized = true
+          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
+  end
+end

data/lib/hyperstack/internal/store/mutator_wrapper.rb

@@ -0,0 +1,84 @@
+module Hyperstack
+  module Internal
+    module Store
+      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__
+              from.init_store if from.respond_to? :init_store
+              current_value = State.get_state(from, method_name.to_s)
+
+              if args.count > 0
+                State.set_state(from, method_name.to_s, args[0])
+                current_value
+              else
+                State.set_state(from, method_name.to_s, current_value)
+                Observable.new(current_value) do |update|
+                  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(Hyperstack::Application::Boot, initializer) do
+                klass.mutate.__send__(:"#{name}", opts[:block].call)
+              end
+            elsif initializer
+              klass.receives(Hyperstack::Application::Boot, initializer)
+            elsif opts[:block]
+              klass.receives(Hyperstack::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
+
+        def []=(name, value)
+          __send__(name, value)
+        end
+
+        def [](name)
+          __send__(name)
+        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
+  end
+end

data/lib/hyperstack/internal/store/observable.rb

@@ -0,0 +1,33 @@
+module Hyperstack
+  module Internal
+    module Store
+      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
+  end
+end

data/lib/hyperstack/internal/store/state.rb

@@ -0,0 +1,174 @@
+module Hyperstack
+  module Internal
+    module Store
+      class State
+        class << self
+          def legacy_map
+            @legacy_map ||= Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = Array.new }}
+          end
+
+          def get_state(obj, name)
+            map_object = legacy_map[obj][name]
+            Hyperstack::Internal::State::Mapper.observed!(map_object.object_id)
+            map_object[0]
+          end
+
+          def set_state(obj, name, value)
+            map_object = legacy_map[obj][name]
+            map_object[0] = value
+            Hyperstack::Internal::State::Mapper.mutated!(map_object.object_id)
+            value
+          end
+
+          def observed?(obj, name)
+            map_object = legacy_map[obj][name]
+            Hyperstack::Internal::State::Mapper.observed?(map_object.object_id)
+          end
+        end
+      end
+    end
+  end
+end
+
+        # ALWAYS_UPDATE_STATE_AFTER_RENDER = Hyperstack.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
+        #
+        #   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 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
+        #   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
+#   end
+# end