hyper-operation 0.5.0

data/lib/hyper-operation/boot.rb

@@ -0,0 +1,24 @@
+module Hyperloop
+  # Tricky business here. Hyperloop::Store will define boot
+  # if it is not already defined.  It creates a minimal compatible
+  # API that includes the run and on_dispatch methods.  This way
+  # you can use the Boot interface without loading operations.
+
+  # Here we define Boot, but in case it has already been defined
+  # we make sure to run the inherited method, and define the
+  # on_dispatch and run methods.   Finally we copy any receivers
+  # that may have been defined on the existing Boot to the new class.
+  class Application
+    Operation.inherited(Boot) if defined? Boot
+    class Boot < Operation
+      def self.on_dispatch(&block)
+        _Railway.add_receiver(&block)
+      end
+      def self.run(*args)
+        ClientDrivers.initialize_client_drivers_on_boot
+        _run(*args)
+      end
+    end
+    Boot.receivers.each { |r| Boot.on_dispatch &r } if Boot.respond_to? :receivers
+  end
+end

data/lib/hyper-operation/call_by_class_name.rb

@@ -0,0 +1,60 @@
+module Hyperloop
+  class Operation
+  end
+end
+
+# patch so that we recognize Foo(...) as an operation inside a React Component
+module React
+  module Component
+    module Tags
+
+      private
+
+      # redefine find_component so if its a HyperOperation we return nil which will
+      # let Object.method_missing (see below) handle the method call to run.
+      def find_component(name)
+        component = lookup_const(name)
+        return nil if component && component < Hyperloop::Operation
+        if component && !component.method_defined?(:render)
+          raise "#{name} does not appear to be a react component."
+        end
+        component
+      end
+    end
+  end
+end
+
+class Object
+  class << self
+    alias _hyper_operation_original_method_missing method_missing
+
+    def method_missing(name, *args, &block)
+      if name =~ /^[A-Z]/
+        scopes = self.name.to_s.split('::').inject([Module]) do |nesting, next_const|
+          nesting + [nesting.last.const_get(next_const)]
+        end.reverse
+        #cant use const_defined? on server because it wont invoke rails auto loading
+        scope = scopes.detect { |s| s.const_get(name) rescue nil }
+        const = scope.const_get(name) if scope
+      end
+      _hyper_operation_original_method_missing(name, *args, &block) unless const.is_a?(Class) && const < Hyperloop::Operation
+      const.send(:run, *args)
+    end
+  end
+
+  alias _hyper_operation_original_method_missing method_missing
+
+  def method_missing(name, *args, &block)
+    if name =~ /^[A-Z]/
+      first = self.is_a?(Module) || self.is_a?(Class) ? self.name : self.class.name
+      scopes = first.to_s.split('::').inject([Module]) do |nesting, next_const|
+        nesting + [nesting.last.const_get(next_const)]
+      end.reverse
+      #cant use const_defined? on server because it wont invoke rails auto loading
+      scope = scopes.detect { |s| s.const_get(name) rescue nil }
+      const = scope.const_get(name) if scope
+    end
+    _hyper_operation_original_method_missing(name, *args, &block) unless const.is_a?(Class) && const < Hyperloop::Operation
+    const.send(:run, *args)
+  end
+end

data/lib/hyper-operation/delay_and_interval.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def every(time, &block)
+    Thread.new { loop { sleep time; block.call }}
+  end
+
+  def after(time, &block)
+    Thread.new { sleep time; block.call }
+  end
+end

data/lib/hyper-operation/engine.rb

@@ -0,0 +1,11 @@
+module Hyperloop
+  class Engine < ::Rails::Engine
+    isolate_namespace Hyperloop
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/hyper-operation/exception.rb

@@ -0,0 +1,13 @@
+module Hyperloop
+  class AccessViolation < StandardError
+    def message
+      "Hyperloop::Operation::AccessViolation: #{super}"
+    end
+  end
+
+  class Operation
+    class ValidationException < Mutations::ValidationException
+    end
+  end
+
+end

data/lib/hyper-operation/filters/acting_user.rb

@@ -0,0 +1,19 @@
+module Hyperloop
+  class ActingUser
+    @default_options = {
+      :nils => false   # true allows an explicit nil to be valid. Overrides any other options
+    }
+
+    def filter(data)
+
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+
+      # otherwise, we win.
+      return [data, nil]
+    end
+  end
+end

data/lib/hyper-operation/filters/outbound_filter.rb

@@ -0,0 +1,9 @@
+module Mutations
+  class OutboundFilter < AdditionalFilter
+    @default_options = {}
+
+    def filter(data)
+      return [data, :outbound]
+    end
+  end
+end

data/lib/hyper-operation/filters/simple_hash.rb

@@ -0,0 +1,22 @@
+module Mutations
+  class SimpleHashFilter < AdditionalFilter
+    @default_options = {
+      :nils => false   # true allows an explicit nil to be valid. Overrides any other options
+    }
+
+    def filter(data)
+
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+      
+      # Now check if it's empty:
+      return [data, :empty] if data == {}
+
+      # If data is a hash, we win.
+      return [data, nil] if data.is_a? Hash
+    end
+  end
+end

data/lib/hyper-operation/opal_patches.rb

@@ -0,0 +1,39 @@
+class Date
+  alias broken_equals ==
+  def ==(other)
+    return false unless other.is_a?(Date)
+    broken_equals(other)
+  end
+end
+
+class Time
+  alias broken_equals ==
+  def ==(other)
+    return false unless other.is_a?(Time)
+    broken_equals(other)
+  end
+end
+
+begin
+  JSON.parse("test")
+rescue Exception => e
+  JSON.class_eval do
+    class << self
+      alias old_parse parse
+    end
+    def self.parse(*args, &block)
+      old_parse *args, &block
+    rescue Exception => e
+      raise StandardError.new e.message
+    end
+  end unless e.is_a? StandardError
+end
+
+class Set
+  def &(enum)
+    n = self.class.new
+    enum.each { |o| n.add(o) if include?(o) }
+    n
+  end
+  alias intersection &
+end unless Set.method_defined? :intersection

data/lib/hyper-operation/promise.rb

@@ -0,0 +1,347 @@
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :error, :prev, :next
+
+  def initialize(action = {})
+    @action = action
+
+    @realized  = false
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = false
+
+    @prev = nil
+    @next = []
+  end
+
+  def value
+    if Promise === @value
+      @value.value
+    else
+      @value
+    end
+  end
+
+  def act?
+    @action.has_key?(:success) || @action.has_key?(:always)
+  end
+
+  def action
+    @action.keys
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    !!@realized
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def pending?
+    !realized?
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next << promise
+
+    if exception?
+      promise.reject(@delayed[0])
+    elsif resolved?
+      promise.resolve(@delayed ? @delayed[0] : value)
+    elsif rejected?
+      if !@action.has_key?(:failure) || Promise === (@delayed ? @delayed[0] : @error)
+        promise.reject(@delayed ? @delayed[0] : error)
+      elsif promise.action.include?(:always)
+        promise.reject(@delayed ? @delayed[0] : error)
+      end
+    end
+
+    self
+  end
+
+  def resolve(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:success] || @action[:always]
+        value = block.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    @realized = :resolve
+    @value    = value
+
+    if @next.any?
+      @next.each { |p| p.resolve(value) }
+    else
+      @delayed = [value]
+    end
+  end
+
+  def reject(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:failure] || @action[:always]
+        value = block.call(value)
+      end
+
+      if @action.has_key?(:always)
+        resolve!(value)
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    @realized = :reject
+    @error    = value
+
+    if @next.any?
+      @next.each { |p| p.reject(value) }
+    else
+      @delayed = [value]
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    self ^ Promise.new(success: block)
+  end
+
+  def then!(&block)
+    there_can_be_only_one!
+    self.then(&block)
+  end
+
+  alias do then
+  alias do! then!
+
+  def fail(&block)
+    self ^ Promise.new(failure: block)
+  end
+
+  def fail!(&block)
+    there_can_be_only_one!
+    fail(&block)
+  end
+
+  alias rescue fail
+  alias catch fail
+  alias rescue! fail!
+  alias catch! fail!
+
+  def always(&block)
+    self ^ Promise.new(always: block)
+  end
+
+  def always!(&block)
+    there_can_be_only_one!
+    always(&block)
+  end
+
+  alias finally always
+  alias ensure always
+  alias finally! always!
+  alias ensure! always!
+
+  def trace(depth = nil, &block)
+    self ^ Trace.new(depth, block)
+  end
+
+  def trace!(*args, &block)
+    there_can_be_only_one!
+    trace(*args, &block)
+  end
+
+  def there_can_be_only_one!
+    if @next.any?
+      raise ArgumentError, 'a promise has already been chained'
+    end
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next.any?
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      current = []
+
+      if promise.act? || promise.prev.nil?
+        current.push(promise.value)
+      end
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(depth, block)
+      @depth = depth
+
+      super success: proc {
+        trace = Trace.it(self).reverse
+        trace.pop
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next.any?
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end