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

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

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

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

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

@@ -1,84 +0,0 @@
-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::Variable.get(from, method_name.to_s)
-
-              if args.count > 0
-                State::Variable.set(from, method_name.to_s, args[0])
-                current_value
-              else
-                State::Variable.set(from, method_name.to_s, current_value)
-                Observable.new(current_value) do |update|
-                  State::Variable.set(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

@@ -1,33 +0,0 @@
-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_wrapper.rb

@@ -1,116 +0,0 @@
-module Hyperstack
-  module Internal
-    module Store
-      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__
-              from.init_store if from.respond_to? :init_store
-              State::Variable.get(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
-
-        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
-          $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
-  end
-end

data/lib/hyperstack/internal/store/state_wrapper/argument_validator.rb

@@ -1,93 +0,0 @@
-module Hyperstack
-  module Internal
-    module Store
-      class StateWrapper < BaseStoreClass
-        module ArgumentValidator
-          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 Legacy::Store::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
-  end
-end