reactive-ruby 0.7.3

data/lib/reactive-ruby/element.rb

@@ -0,0 +1,87 @@
+require "reactive-ruby/ext/string"
+
+module React
+  class Element
+    include Native
+
+    alias_native :element_type, :type
+    alias_native :props, :props
+    
+    attr_reader :type
+    attr_reader :properties
+    attr_reader :block
+    
+    attr_accessor :waiting_on_resources
+
+    def initialize(native_element, type, properties, block)
+      @type = type
+      @properties = properties
+      @block = block
+      @native = native_element
+    end
+
+    def on(event_name)
+      name = event_name.to_s.event_camelize
+      if React::Event::BUILT_IN_EVENTS.include?("on#{name}")
+        self.props["on#{name}"] = %x{
+          function(event){
+            #{yield React::Event.new(`event`)}
+          }
+        }
+      else
+        self.props["_on#{name}"] = %x{
+          function(){
+            #{yield *Array(`arguments`)}
+          }
+        }
+      end
+      self
+    end
+    
+    def method_missing(class_name, args = {}, &new_block)
+      class_name = class_name.split("__").collect { |s| s.gsub("_", "-") }.join("_")
+      new_props = properties.dup
+      new_props["class"] = "#{new_props['class']} #{class_name} #{args.delete("class")} #{args.delete('className')}".split(" ").uniq.join(" ")
+      new_props.merge! args
+      RenderingContext.replace(
+        self,
+        React::RenderingContext.build { React::RenderingContext.render(type, new_props, &new_block) }
+      )
+    end
+    
+    def delete
+      RenderingContext.delete(self)
+    end
+
+    def children
+      nodes = self.props.children
+      class << nodes
+        include Enumerable
+
+        def to_n
+          self
+        end
+
+        def each(&block)
+          if block_given?
+            %x{
+              React.Children.forEach(#{self.to_n}, function(context){
+                #{block.call(React::Element.new(`context`))}
+              })
+            }
+          else
+            Enumerator.new(`React.Children.count(#{self.to_n})`) do |y|
+              %x{
+                React.Children.forEach(#{self.to_n}, function(context){
+                  #{y << React::Element.new(`context`)}
+                })
+              }
+            end
+          end
+        end
+      end
+
+      nodes
+    end
+  end
+end

data/lib/reactive-ruby/event.rb

@@ -0,0 +1,76 @@
+module React
+  class Event
+    include Native
+    alias_native :bubbles, :bubbles
+    alias_native :cancelable, :cancelable
+    alias_native :current_target, :currentTarget
+    alias_native :default_prevented, :defaultPrevented
+    alias_native :event_phase, :eventPhase
+    alias_native :is_trusted?, :isTrusted
+    alias_native :native_event, :nativeEvent
+    alias_native :target, :target
+    alias_native :timestamp, :timeStamp
+    alias_native :event_type, :type
+    alias_native :prevent_default, :preventDefault
+    alias_native :stop_propagation, :stopPropagation
+    # Clipboard
+    alias_native :clipboard_data, :clipboardData
+    # Keyboard
+    alias_native :alt_key, :altKey
+    alias_native :char_code, :charCode
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :key, :key
+    alias_native :key_code, :keyCode
+    alias_native :locale, :locale
+    alias_native :location, :location
+    alias_native :meta_key, :metaKey
+    alias_native :repeat, :repeat
+    alias_native :shift_key, :shiftKey
+    alias_native :which, :which
+    # Focus
+    alias_native :related_target, :relatedTarget
+    # Mouse
+    alias_native :alt_key, :altKey
+    alias_native :button, :button
+    alias_native :buttons, :buttons
+    alias_native :client_x, :clientX
+    alias_native :client_y, :clientY
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :meta_key, :metaKey
+    alias_native :page_x, :pageX
+    alias_native :page_y, :pageY
+    alias_native :related_target, :relatedTarget
+    alias_native :screen_x, :screen_x
+    alias_native :screen_y, :screen_y
+    alias_native :shift_key, :shift_key
+    # Touch
+    alias_native :alt_key, :altKey
+    alias_native :changed_touches, :changedTouches
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :meta_key, :metaKey
+    alias_native :shift_key, :shiftKey
+    alias_native :target_touches, :targetTouches
+    alias_native :touches, :touches
+    # UI
+    alias_native :detail, :detail
+    alias_native :view, :view
+    # Wheel
+    alias_native :delta_mode, :deltaMode
+    alias_native :delta_x, :deltaX
+    alias_native :delta_y, :deltaY
+    alias_native :delta_z, :deltaZ
+
+    BUILT_IN_EVENTS = %w{onCopy onCut onPaste onKeyDown onKeyPress onKeyUp
+      onFocus onBlur onChange onInput onSubmit onClick onDoubleClick onDrag
+      onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop
+      onMouseDown onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver
+      onMouseUp onTouchCancel onTouchEnd onTouchMove onTouchStart onScroll}
+
+    def initialize(native_element)
+      @native = native_element
+    end
+  end
+end

data/lib/reactive-ruby/ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def shallow_to_n
+    hash = `{}`
+    self.map do |key, value|
+       `hash[#{key}] = #{value}`
+    end
+    hash
+  end
+end

data/lib/reactive-ruby/ext/string.rb

@@ -0,0 +1,8 @@
+class String
+  def event_camelize
+    `#{self}.replace(/(^|_)([^_]+)/g, function(match, pre, word, index) {
+      var capitalize = true;
+      return capitalize ? word.substr(0,1).toUpperCase()+word.substr(1) : word;
+    })`
+  end
+end

data/lib/reactive-ruby/isomorphic_helpers.rb

@@ -0,0 +1,223 @@
+module React
+  
+  module IsomorphicHelpers
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    if RUBY_ENGINE != 'opal'
+      
+      def self.load_context(ctx, controller)
+        puts "************************** React Server Context Initialized *********************************************"
+        @context = Context.new("#{controller.object_id}-#{Time.now.to_i}", ctx, controller) 
+      end
+
+    else
+      
+      def self.load_context(unique_id = nil)  # can be called on the client to force re-initialization for testing purposes
+        if !unique_id or !@context or @context.unique_id != unique_id
+          if on_opal_server?
+            message = "************************ React Prerendering Context Initialized ***********************"
+          else
+            message = "************************ React Browser Context Initialized ****************************"
+          end
+          log(message)
+          @context = Context.new(unique_id) 
+        end
+        @context
+      end
+      
+    end
+    
+    def self.log(message, message_type = :info)
+      message = [message] unless message.is_a? Array
+      if message_type == :info
+        if on_opal_server?
+          style = 'background: #00FFFF; color: red'
+        else
+          style = 'background: #222; color: #bada55'
+        end
+        message = ["%c" + message[0], style]+message[1..-1]
+        `console.log.apply(console, message)`
+      elsif message_type == :warning
+        `console.warn.apply(console, message)`
+      else
+        `console.error.apply(console, message)`
+      end
+    end
+    
+    if RUBY_ENGINE != 'opal'
+      
+      def self.on_opal_server?
+        false
+      end
+      
+      def self.on_opal_client?
+        false
+      end
+      
+    else
+      
+      def self.on_opal_server?
+        `typeof window.document === 'undefined'`
+      end
+      
+      def self.on_opal_client?
+        !on_opal_server?
+      end
+      
+    end
+    
+    def log(*args)
+      IsomorphicHelpers.log(*args)
+    end
+    
+    def on_opal_server?
+      IsomorphicHelpers.on_opal_server?
+    end
+    
+    def on_opal_client?
+      IsomorphicHelpers.on_opal_client?
+    end
+      
+    def self.prerender_footers
+      footer = Context.prerender_footer_blocks.collect { |block| block.call }.join("\n")
+      if RUBY_ENGINE != 'opal'
+        footer = (footer + "#{@context.send_to_opal(:prerender_footers)}") if @context
+        footer = footer.html_safe
+      end
+      footer
+    end
+    
+    class Context
+      
+      attr_reader :controller
+      attr_reader :unique_id
+      
+      def self.before_first_mount_blocks
+        @before_first_mount_blocks ||= []
+      end
+      
+      def self.prerender_footer_blocks
+        @prerender_footer_blocks ||= []
+      end
+      
+      def initialize(unique_id, ctx = nil, controller = nil)
+        @unique_id = unique_id
+        if RUBY_ENGINE != 'opal' 
+          @controller = controller
+          @ctx = ctx 
+          ctx["ServerSideIsomorphicMethods"] = self
+          send_to_opal(:load_context, @unique_id)
+        end
+        self.class.before_first_mount_blocks.each { |block| block.call(self) } 
+      end
+      
+      def eval(js)
+        @ctx.eval(js) if @ctx
+      end
+      
+      def send_to_opal(method, *args)
+        args = [1] if args.length == 0
+        if @ctx
+          unless @ctx.eval('Opal.React')
+            @ctx.eval(Opal::Processor.load_asset_code(::Rails.application.assets, 'components')) rescue nil
+            raise "No opal-react components found in the components.rb file" unless @ctx.eval('Opal.React')
+          end
+          @ctx.eval("Opal.React.IsomorphicHelpers.$#{method}(#{args.join(', ')})")
+        end
+      end
+      
+      def self.register_before_first_mount_block(&block)
+        before_first_mount_blocks << block
+      end
+      
+      def self.register_prerender_footer_block(&block)
+        prerender_footer_blocks << block
+      end
+      
+    end
+    
+    class IsomorphicProcCall
+      
+      def result
+        @result.first if @result
+      end
+      
+      def initialize(name, block, *args)
+        @name = name
+        block.call(self, *args)
+        @result ||= send_to_server(*args) if IsomorphicHelpers.on_opal_server?
+      end
+      
+      def when_on_client(&block)
+        @result = [block.call] if IsomorphicHelpers.on_opal_client?
+      end
+            
+      def send_to_server(*args) 
+        if IsomorphicHelpers.on_opal_server?
+          args_as_json = args.to_json
+          @result = [JSON.parse(`window.ServerSideIsomorphicMethods[#{@name}](#{args_as_json})`)] 
+        end
+      end
+      
+      def when_on_server(&block)
+        @result = [block.call.to_json] unless IsomorphicHelpers.on_opal_client? or IsomorphicHelpers.on_opal_server?
+      end
+      
+    end
+      
+    
+    module ClassMethods
+      
+      def on_opal_server?
+        IsomorphicHelpers.on_opal_server?
+      end
+
+      def on_opal_client?
+        IsomorphicHelpers.on_opal_client?
+      end
+      
+      def log(*args)
+        IsomorphicHelpers.log(*args)
+      end
+      
+      def controller
+        IsomorphicHelpers.context.controller
+      end
+  
+      def before_first_mount(&block)
+        React::IsomorphicHelpers::Context.register_before_first_mount_block &block
+      end
+      
+      def prerender_footer(&block)
+        React::IsomorphicHelpers::Context.register_prerender_footer_block &block
+      end
+        
+      if RUBY_ENGINE != 'opal'
+        
+        def isomorphic_method(name, &block)
+          React::IsomorphicHelpers::Context.send(:define_method, name) do |args_as_json|
+            React::IsomorphicHelpers::IsomorphicProcCall.new(name, block, *JSON.parse(args_as_json)).result
+          end
+        end
+        
+      else
+        
+        require 'json'
+        
+        def isomorphic_method(name, &block)
+          self.class.send(:define_method, name) do | *args |
+            React::IsomorphicHelpers::IsomorphicProcCall.new(name, block, *args).result
+          end
+        end
+        
+      end
+      
+      
+    end
+    
+  end
+  
+end

data/lib/reactive-ruby/observable.rb

@@ -0,0 +1,33 @@
+module React
+  
+  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 result }
+    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

data/lib/reactive-ruby/rendering_context.rb

@@ -0,0 +1,91 @@
+module React
+  
+  class RenderingContext
+    
+    class << self
+      attr_accessor :waiting_on_resources
+    end
+    
+    def self.render(name, *args, &block)
+      @buffer = [] unless @buffer
+      if block
+        element = build do
+          saved_waiting_on_resources = waiting_on_resources
+          self.waiting_on_resources = nil
+          result = block.call
+          # Todo figure out how children rendering should happen, probably should have special method that pushes children into the buffer
+          # i.e. render_child/render_children that takes Element/Array[Element] and does the push into the buffer
+          if !name and (  # !name means called from outer render so we check that it has rendered correctly
+              (@buffer.count > 1) or # should only render one element
+              (@buffer.count == 1 and @buffer.last != result) or # it should return that element 
+              (@buffer.count == 0 and !(result.is_a? String or (result.respond_to? :acts_as_string? and result.acts_as_string?) or result.is_a? Element)) #for convience we will also convert the return value to a span if its a string
+            )
+            raise "a components render method must generate and return exactly 1 element or a string"
+          end
+          
+          @buffer << result.to_s if result.is_a? String or (result.respond_to? :acts_as_string? and result.acts_as_string?) # For convience we push the last return value on if its a string
+          @buffer << result if result.is_a? Element and @buffer.count == 0
+          if name
+            buffer = @buffer.dup
+            React.create_element(name, *args) { buffer }.tap do |element| 
+              element.waiting_on_resources = saved_waiting_on_resources || !!buffer.detect { |e| e.waiting_on_resources if e.respond_to? :waiting_on_resources }
+            end
+          elsif @buffer.last.is_a? React::Element
+            @buffer.last.tap { |element| element.waiting_on_resources ||= saved_waiting_on_resources }
+          else
+            @buffer.last.to_s.span.tap { |element| element.waiting_on_resources = saved_waiting_on_resources }
+          end
+        end
+      else
+        element = React.create_element(name, *args)
+        element.waiting_on_resources = waiting_on_resources
+      end
+      @buffer << element 
+      self.waiting_on_resources = nil
+      element
+    end
+    
+    def self.build(&block)
+      current = @buffer
+      @buffer = []
+      return_val = yield @buffer
+      @buffer = current
+      return_val
+    #ensure
+    #  @buffer = current
+    #  return_val
+    end
+    
+    def self.as_node(element)
+      @buffer.delete(element)
+      element
+    end
+    
+    class << self; alias_method :delete, :as_node; end
+    
+    def self.replace(e1, e2)
+      @buffer[@buffer.index(e1)] = e2 
+    end
+    
+  end
+ 
+  class ::Object
+    
+    alias_method :old_method_missing, :method_missing
+    
+    ["span", "para", "td", "th", "while_loading"].each do |tag|
+      define_method(tag) do | *args, &block |
+        args.unshift(tag)
+        return self.method_missing(*args, &block) if self.is_a? React::Component 
+        React::RenderingContext.render(*args) { self.to_s }
+      end
+    end
+    
+    def br
+      return self.method_missing(*["br"]) if self.is_a? React::Component
+      React::RenderingContext.render("span") { React::RenderingContext.render(self.to_s); React::RenderingContext.render("br") }
+    end
+    
+  end
+
+end