rbdux 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e2b52fe3fdf03fb4b57e8875edf152dfa7dba39
+  data.tar.gz: 2a4cdd6c7dd86694bac2dee6af8fddeb793bdbed
+SHA512:
+  metadata.gz: 7bbe51b93c102910fac95498117eff8774c924448bcb3b7e7308b8cf5f204f605321eb4bccc6c0cf2d1835d0674872cd1e6c1b20f64e6e16a7f38919d53f9b7a
+  data.tar.gz: 0b81e094159550b1bad1fe2508471abf88c9fb7a350c8ba2230f6c52320cca4e351f8b1bc61a836f918a2f5338dab073ba3fe612e00abacc80fb3f2d52559b0d

data/lib/rbdux/action.rb

@@ -0,0 +1,66 @@
+module Rbdux
+  class Action
+    class << self
+      def define(type_name, &block)
+        klass_name = "#{prepare_action_name(type_name)}Action"
+
+        return Object.const_get(klass_name) if Object.const_defined? klass_name
+
+        Object.const_set(klass_name, build_action_type(block))
+      end
+
+      private
+
+      class BaseAction
+        class << self
+          attr_reader :dispatch_func
+
+          def empty
+            new(nil, nil)
+          end
+
+          def with_payload(payload)
+            new(payload, nil)
+          end
+
+          def with_error(error)
+            new(nil, error)
+          end
+        end
+
+        attr_reader :payload, :error
+
+        def error?
+          !error.nil?
+        end
+
+        private
+
+        def initialize(payload, error)
+          @payload = payload
+          @error = error
+        end
+      end
+
+      def prepare_action_name(name)
+        camelize_action_name(name.tr('-', '_')).gsub('Action', '')
+      end
+
+      def camelize_action_name(name)
+        name.split('_').collect { |n| capitalize(n) }.join
+      end
+
+      def capitalize(name)
+        name_array = name.split('')
+        name_array.first.upcase!
+        name_array.join
+      end
+
+      def build_action_type(func)
+        Class.new(BaseAction) do
+          @dispatch_func = func
+        end
+      end
+    end
+  end
+end

data/lib/rbdux/middleware/dispatch_interceptor.rb

@@ -0,0 +1,13 @@
+module Rbdux
+  module Middleware
+    module_function
+
+    def dispatch_interceptor(store, action)
+      func = action.class.dispatch_func
+
+      return nil unless func
+
+      func.call(store, action)
+    end
+  end
+end

data/lib/rbdux/store.rb

@@ -0,0 +1,166 @@
+require 'securerandom'
+
+module Rbdux
+  class Store
+    class << self
+      @instance = nil
+
+      def instance
+        @instance ||= Store.new
+      end
+
+      def reset
+        @instance = nil
+      end
+
+      def with_state(state)
+        @instance = Store.new(state)
+      end
+
+      def method_missing(method, *args, &block)
+        return unless instance.respond_to?(method)
+
+        @instance.send(method, *args, &block)
+      end
+    end
+
+    attr_reader :state
+
+    def reduce(action, state_key = nil, &block)
+      add_reducer(action, state_key, true, block)
+
+      self
+    end
+
+    def reduce_and_merge(action, state_key = nil, &block)
+      add_reducer(action, state_key, false, block)
+
+      self
+    end
+
+    def when_merging(&block)
+      validate_functional_inputs(block)
+
+      @merge_func = block
+
+      self
+    end
+
+    def before(&block)
+      @before_middleware << block if block
+
+      self
+    end
+
+    def after(&block)
+      @after_middleware << block if block
+
+      self
+    end
+
+    def dispatch(action)
+      previous_state = state
+
+      dispatched_action = apply_before_middleware(action)
+
+      reducers.fetch(action.class.name, []).each do |reducer|
+        apply_reducer!(reducer, dispatched_action)
+      end
+
+      apply_after_middleware(previous_state, dispatched_action)
+
+      observers.values.each(&:call)
+    end
+
+    def subscribe(&block)
+      validate_functional_inputs(block)
+
+      subscriber_id = SecureRandom.uuid
+
+      observers[subscriber_id] = block
+
+      subscriber_id
+    end
+
+    def unsubscribe(subscriber_id)
+      observers.delete(subscriber_id)
+    end
+
+    private
+
+    Reducer = Struct.new(:state_key, :auto_merge, :func)
+
+    attr_reader :observers, :reducers
+
+    def initialize(state = {})
+      @state = state
+      @observers = {}
+      @reducers = {}
+      @before_middleware = []
+      @after_middleware = []
+      @merge_func = nil
+    end
+
+    def add_reducer(action, state_key, auto_merge, func)
+      validate_functional_inputs(func)
+
+      key = action.name
+
+      reducers[key] = [] unless reducers.key?(key)
+      reducers[key] << Reducer.new(state_key, auto_merge, func)
+    end
+
+    def apply_before_middleware(action)
+      dispatched_action = action
+
+      @before_middleware.each do |m|
+        new_action = m.call(self, dispatched_action)
+        dispatched_action = new_action unless new_action.nil?
+      end
+
+      dispatched_action
+    end
+
+    def apply_after_middleware(previous_state, action)
+      @after_middleware.each do |m|
+        m.call(previous_state, state, action)
+      end
+    end
+
+    def apply_reducer!(reducer, action)
+      reducer_params = [slice_state(reducer.state_key), action]
+      reducer_params << state unless reducer.auto_merge
+      new_state = reducer.func.call(*reducer_params)
+
+      return if new_state.nil?
+
+      @state =  if reducer.auto_merge
+                  merge_state(new_state, reducer.state_key)
+                else
+                  new_state
+                end
+    end
+
+    def slice_state(state_key)
+      return state unless state_key
+
+      state[state_key]
+    end
+
+    def merge_state(new_state, state_key)
+      if @merge_func.nil?
+        default_merge(state, new_state, state_key)
+      else
+        @merge_func.call(state, new_state, state_key)
+      end
+    end
+
+    def default_merge(old_state, new_state, state_key)
+      old_state.dup.merge(state_key ? { state_key => new_state } : new_state)
+    end
+
+    def validate_functional_inputs(block)
+      raise ArgumentError, 'You must define a block.' unless block
+    end
+  end
+end

data/lib/rbdux.rb

@@ -0,0 +1,3 @@
+require 'rbdux/action'
+require 'rbdux/store'
+require 'rbdux/middleware/dispatch_interceptor'

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: rbdux
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joshua Tompkins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: josh@joshtompkins.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rbdux.rb
+- lib/rbdux/action.rb
+- lib/rbdux/middleware/dispatch_interceptor.rb
+- lib/rbdux/store.rb
+homepage: https://github.com/jtompkins/rbdux
+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: A simple one-way dataflow library, inspired by Redux
+test_files: []