hyper-store 0.2.0

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

@@ -0,0 +1,91 @@
+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
+          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

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

data/lib/hyperloop/application/boot.rb

@@ -0,0 +1,34 @@
+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
+
+      def receivers
+        @receivers ||= []
+      end
+    end
+  end unless defined? Operation
+  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
+      rescue Exception => e
+        puts "called Boot.run and she broke #{e}"
+      end
+    end unless defined? Boot
+  end
+end

data/lib/hyperloop/store.rb

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,158 @@
+module React
+  class State
+
+    ALWAYS_UPDATE_STATE_AFTER_RENDER = true
+    @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
+
+      def set_state(object, name, value, delay=ALWAYS_UPDATE_STATE_AFTER_RENDER)
+        states[object][name] = value
+        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 notify_observers(object, name, value)
+        object_needs_notification = object.respond_to? :update_react_js_state
+        observers_by_name[object][name].dup.each do |observer|
+          observer.update_react_js_state(object, name, value)
+          object_needs_notification = false if object == observer
+        end
+        object.update_react_js_state(nil, name, value) if object_needs_notification
+      end
+
+      def notify_observers_after_thread_completes(object, name, value)
+        (@delayed_updates ||= []) << [object, name, value]
+        @delayed_updater ||= after(0) do
+          delayed_updates = @delayed_updates
+          @delayed_updates = []
+          @delayed_updater = nil
+          delayed_updates.each { |args| notify_observers(*args) }
+        end
+      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
+        if `typeof Opal.global.reactive_ruby_timing !== 'undefined'`
+          @nesting_level = (@nesting_level || 0) + 1
+          start_time = Time.now.to_f
+          observer_name = (observer.class.respond_to?(:name) ? observer.class.name : observer.to_s) rescue "object:#{observer.object_id}"
+        end
+        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
+        @nesting_level = [0, @nesting_level - 1].max if `typeof Opal.global.reactive_ruby_timing !== 'undefined'`
+        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

metadata

@@ -0,0 +1,293 @@
+--- !ruby/object:Gem::Specification
+name: hyper-store
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- catmando
+- adamcreekroad
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hyperloop-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: hyper-react
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: hyper-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: react-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-steps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- mitch@catprint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- hyper-store.gemspec
+- lib/hyper-store.rb
+- lib/hyper-store/class_methods.rb
+- lib/hyper-store/dispatch_receiver.rb
+- lib/hyper-store/instance_methods.rb
+- lib/hyper-store/mutator_wrapper.rb
+- lib/hyper-store/state_wrapper.rb
+- lib/hyper-store/state_wrapper/argument_validator.rb
+- lib/hyper-store/version.rb
+- lib/hyperloop/application/boot.rb
+- lib/hyperloop/store.rb
+- lib/hyperloop/store/mixin.rb
+- lib/react/observable.rb
+- lib/react/state.rb
+homepage: https://ruby-hyperloop.io
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Flux Stores and more for Hyperloop
+test_files: []