hyper-store 1.0.alpha1.8 → 1.0.0.lap28

data/Gemfile

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

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,80 @@
+<div class="githubhyperloopheader">
+
+<p align="center">
+
+<a href="http://ruby-hyperloop.io/" alt="Hyperloop" title="Hyperloop">
+<img width="350px" src="http://ruby-hyperloop.io/images/hyperloop-github-logo.png">
+</a>
+
+</p>
+
+<h2 align="center">The Complete Isomorphic Ruby Framework</h2>
+
+<br>
+
+<a href="http://ruby-hyperloop.io/" alt="Hyperloop" title="Hyperloop">
+<img src="http://ruby-hyperloop.io/images/githubhyperloopbadge.png">
+</a>
+
+<a href="https://gitter.im/ruby-hyperloop/chat" alt="Gitter chat" title="Gitter chat">
+<img src="http://ruby-hyperloop.io/images/githubgitterbadge.png">
+</a>
+
+[![Build Status](https://travis-ci.org/ruby-hyperloop/hyper-store.svg?branch=master)](https://travis-ci.org/ruby-hyperloop/hyper-store)
+[![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)
+[![Gem Version](https://badge.fury.io/rb/hyper-store.svg)](https://badge.fury.io/rb/hyper-store)
+
+<p align="center">
+<img src="http://ruby-hyperloop.io/images/HyperStores.png" width="100" alt="Hyperstores">
+</p>
+
+</div>
+
+## Hyper-Store GEM is part of Hyperloop GEMS family
+
+Build interactive Web applications quickly. Hyperloop encourages rapid development with clean, pragmatic design. With developer productivity as our highest goal, Hyperloop takes care of much of the hassle of Web development, so you can focus on innovation and delivering end-user value.
+
+One language. One model. One set of tests. The same business logic and domain models running on the clients and the server. Hyperloop is fully integrated with Rails and also gives you unfettered access to the complete universe of JavaScript libraries (including React) from within your Ruby code. Hyperloop lets you build beautiful interactive user interfaces in Ruby.
+
+Everything has a place in our architecture. Components deliver interactive user experiences, Operations encapsulate business logic, Models magically synchronize data between clients and servers, Policies govern authorization and Stores hold local state. 
+
+**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**
+
+## Getting Started
+
+1. Update your Gemfile:
+        
+```ruby
+#Gemfile
+
+gem 'hyperloop'
+```
+
+2. At the command prompt, update your bundle :
+
+        $ bundle update
+
+3. Run the hyperloop install generator:
+
+        $ rails g hyperloop:install
+
+4. Follow the guidelines to start developing your application. You may find
+   the following resources handy:
+    * [Getting Started with Hyperloop](http://ruby-hyperloop.io/start/components/)
+    * [Hyperloop Guides](http://ruby-hyperloop.io/docs/architecture)
+    * [Hyperloop Tutorial](http://ruby-hyperloop.io/tutorials)
+
+## Community
+
+#### Getting Help
+Please **do not post** usage questions to GitHub Issues. For these types of questions use our [Gitter chatroom](https://gitter.im/ruby-hyperloop/chat) or [StackOverflow](http://stackoverflow.com/questions/tagged/hyperloop).
+
+#### Submitting Bugs and Enhancements
+[GitHub Issues](https://github.com/ruby-hyperloop/hyperloop/issues) is for suggesting enhancements and reporting bugs. Before submiting a bug make sure you do the following:
+* Check out our [contributing guide](https://github.com/ruby-hyperloop/hyperloop/blob/master/CONTRIBUTING.md) for info on our release cycle.
+
+## License
+
+Hyperloop is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/Rakefile

@@ -5,6 +5,8 @@ RSpec::Core::RakeTask.new(:spec)
 
 namespace :spec do
   task :prepare do
+    sh %{bundle update}
+    sh %{cd spec/test_app; bundle update}
   end
 end
 

data/dciy.toml

@@ -0,0 +1,3 @@
+[dciy.commands]
+prepare = ["rake spec:prepare"]
+cibuild = ["bundle exec rake"]

data/hyper-store.gemspec

@@ -1,43 +1,41 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hyperstack/legacy/store/version'
+require 'hyper-store/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'hyper-store'
-  spec.version       = Hyperstack::Legacy::Store::VERSION
+  spec.version       = HyperStore::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'
-  spec.homepage      = 'https://hyperstack.org'
+  spec.homepage      = 'https://ruby-hyperloop.org'
   spec.license       = 'MIT'
+  # spec.metadata      = {
+  #   "homepage_uri" => 'http://ruby-hyperloop.org',
+  #   "source_code_uri" => 'https://github.com/ruby-hyperloop/hyper-component'
+  # }
+
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(gemfiles|spec)/}) }
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'hyper-state', Hyperstack::Legacy::Store::VERSION
-  spec.add_dependency 'hyperstack-config', Hyperstack::Legacy::Store::VERSION
-
+  spec.add_dependency 'hyperloop-config', HyperStore::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', Hyperstack::Legacy::Store::VERSION
-  spec.add_development_dependency 'hyper-spec', Hyperstack::Legacy::Store::VERSION
+  spec.add_development_dependency 'hyper-react', HyperStore::VERSION
+  spec.add_development_dependency 'hyper-spec', HyperStore::VERSION
   spec.add_development_dependency 'listen'
-  # spec.add_development_dependency 'mini_racer', '~> 0.2.6'
+  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', '< 2.0'
-  spec.add_development_dependency 'pry-rescue'
-  spec.add_development_dependency 'pry-stack_explorer'
-  spec.add_development_dependency 'puma'
-  spec.add_development_dependency 'rails', ENV['RAILS_VERSION'] || '>= 5.0.0', '< 7.0'
+  spec.add_development_dependency 'opal-rails', '~> 0.9.4'
+  spec.add_development_dependency 'pry-byebug'
+  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', '~> 1.4.2'
-  spec.add_development_dependency 'timecop', '~> 0.8.1'
-
+  spec.add_development_dependency 'rubocop', '~> 0.51.0'
+  spec.add_development_dependency 'sqlite3'
 end

data/lib/hyper-store.rb

@@ -1,27 +1,24 @@
 require 'set'
-require 'hyperstack-config'
-require 'hyper-state'
-Hyperstack.import 'hyper-store'
+require 'hyperloop-config'
+Hyperloop.import 'hyper-store'
 
-module Hyperstack
-  module Internal
-    module Store
-      # allows us to easily turn off BasicObject for debug
-      class BaseStoreClass < BasicObject
-      end
-    end
+
+module HyperStore # allows us to easily turn off BasicObject for debug
+  class BaseStoreClass < BasicObject
   end
 end
 
-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/legacy/store'
-require 'hyperstack/legacy/store/version'
+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'

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,107 @@
+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