hyper-store 0.2.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Adam Creekroad, Mitch VanDuyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+[ ![Codeship Status for ruby-hyperloop/hyper-store](https://app.codeship.com/projects/4454c560-d4ea-0134-7c96-362b4886dd22/status?branch=master)](https://app.codeship.com/projects/202301)
+
+## Hyper-Store gem
+
+Stores are where the state of your Application lives. Anything but a completely static web page will have dynamic states that change because of user inputs, the passage of time, or other external events.
+
+**Stores are Ruby classes that keep the dynamic parts of the state in special state variables**
+
++ `Hyperloop::Store::Mixin` can be mixed in to any class to turn it into a Flux Store.
++ You can also create Stores by subclassing `Hyperloop::Store`.
++ Stores are built out of *reactive state variables*.
++ Components that *read* a Store's state will **automatically** update when the state changes.
++ All of your **shared** reactive state should be Stores - *The Store is the Truth*!
++ Stores can *receive* **dispatches** from *Operations*
+
+## Documentation and Help
+
++ Please see the [ruby-hyperloop.io](http://ruby-hyperloop.io/) website for documentation.
++ Join the Hyperloop [gitter.io](https://gitter.im/ruby-hyperloop/chat) chat for help and support.
+
+## Basic Installation and Setup
+
+The easiest way to install is to use the `hyper-rails` gem.
+
+1. Add `gem 'hyper-rails'` to your Rails `Gemfile` development section.
+2. Install the Gem: `bundle install`
+3. Run the generator: `bundle exec rails g hyperloop:install --all`
+4. Update the bundle: `bundle update`
+
+Your Isomorphic Operations live in a `hyperloop/stores` folder.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby-hyperloop/hyper-store. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Code of Conduct](https://github.com/ruby-hyperloop/hyper-store/blob/master/CODE_OF_CONDUCT.md) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hyper/store"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hyper-store.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hyper-store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hyper-store'
+  spec.version       = HyperStore::VERSION
+  spec.authors       = ['catmando', 'adamcreekroad']
+  spec.email         = ['mitch@catprint.com']
+
+  spec.summary       = 'Flux Stores and more for Hyperloop'
+  spec.homepage      = 'https://ruby-hyperloop.io'
+  spec.license       = 'MIT'
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'hyperloop-config'
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'hyper-react', '>= 0.12.0'
+  spec.add_development_dependency 'hyper-spec'
+  spec.add_development_dependency 'listen'
+  spec.add_development_dependency 'opal'
+  spec.add_development_dependency 'opal-browser'
+  spec.add_development_dependency 'opal-rails'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'react-rails', '< 1.10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-steps'
+  spec.add_development_dependency 'sqlite3'
+
+  # Keep linter-rubocop happy
+  spec.add_development_dependency 'rubocop'
+end

data/lib/hyper-store.rb

@@ -0,0 +1,26 @@
+require 'set'
+require 'hyperloop-config'
+Hyperloop.require 'hyper-store', gem: true
+
+
+module HyperStore # allows us to easily turn off BasicObject for debug
+  class BaseStoreClass < BasicObject
+  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'
+
+if RUBY_ENGINE != 'opal'
+  require 'opal'
+  Opal.append_path(File.expand_path('../', __FILE__).untaint)
+end

data/lib/hyper-store/class_methods.rb

@@ -0,0 +1,32 @@
+module HyperStore
+  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

data/lib/hyper-store/dispatch_receiver.rb

@@ -0,0 +1,38 @@
+module HyperStore
+  module DispatchReceiver
+    class InvalidOperationError < StandardError; end
+
+    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 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

data/lib/hyper-store/instance_methods.rb

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

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

@@ -0,0 +1,108 @@
+module HyperStore
+  class StateWrapper < BaseStoreClass #< BasicObject # TODO StateWrapper should from basic object to avoid name space conflicts
+    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
+          #puts "**************** args = #{args}"
+          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