reactrb 0.7.42

data/lib/react/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/react/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/react/native_library.rb

@@ -0,0 +1,53 @@
+module React
+  class NativeLibrary
+    def self.renames_and_exclusions
+      @renames_and_exclusions ||= {}
+    end
+
+    def self.libraries
+      @libraries ||= []
+    end
+
+    def self.const_missing(name)
+      if renames_and_exclusions.has_key? name
+        if native_name = renames_and_exclusions[name]
+          native_name
+        else
+          super
+        end
+      else
+        libraries.each do |library|
+          native_name = "#{library}.#{name}"
+          native_component = `eval(#{native_name})` rescue nil
+          React::API.import_native_component(name, native_component) and return name if native_component and `native_component != undefined`
+        end
+        name
+      end
+    end
+
+    def self.method_missing(n, *args, &block)
+      name = n
+      if name =~ /_as_node$/
+        node_only = true
+        name = name.gsub(/_as_node$/, "")
+      end
+      unless name = const_get(name)
+        return super
+      end
+      React::RenderingContext.build_or_render(node_only, name, *args, &block)
+    rescue
+    end
+
+    def self.imports(library)
+      libraries << library
+    end
+
+    def self.rename(rename_list={})
+      renames_and_exclusions.merge!(rename_list.invert)
+    end
+
+    def self.exclude(*exclude_list)
+      renames_and_exclusions.merge(Hash[exclude_list.map {|k| [k, nil]}])
+    end
+  end
+end

data/lib/react/observable.rb

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

data/lib/react/rendering_context.rb

@@ -0,0 +1,109 @@
+module React
+  class RenderingContext
+    class << self
+      attr_accessor :waiting_on_resources
+    end
+
+    def self.build_or_render(node_only, name, *args, &block)
+      if node_only
+        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+      else
+        React::RenderingContext.render(name, *args, &block)
+      end
+    end
+
+    def self.render(name, *args, &block)
+      remove_nodes_from_args(args)
+      @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 && (  # !name means called from outer render so we check that it has rendered correctly
+              (@buffer.count > 1) || # should only render one element
+              (@buffer.count == 1 && @buffer.last != result) || # it should return that element
+              (@buffer.count == 0 && !(result.is_a?(String) || (result.respond_to?(:acts_as_string?) && result.acts_as_string?) || 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 || (result.respond_to?(:acts_as_string?) && result.acts_as_string?) # For convience we push the last return value on if its a string
+          @buffer << result if result.is_a?(Element) && @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
+      elsif name.is_a? React::Element
+        element = name
+        # I BELIEVE WAITING ON RESOURCES SHOULD ALREADY BE SET
+      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
+
+    def self.remove_nodes_from_args(args)
+      args[0].each do |key, value|
+        value.as_node if value.is_a?(Element) rescue nil
+      end if args[0] && args[0].is_a?(Hash)
+    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 para(*args, &block)
+      args.unshift("p")
+      return self.method_missing(*args, &block) if self.is_a? React::Component
+      React::RenderingContext.render(*args) { self.to_s }
+    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

data/lib/react/state.rb

@@ -0,0 +1,140 @@
+module React
+  class StateWrapper < BasicObject
+    def initialize(native, from)
+      @state_hash = Hash.new(`#{native}.state`)
+      @from = from
+    end
+
+    def [](state)
+      @state_hash[state]
+    end
+
+    def []=(state, new_value)
+      @state_hash[state] = new_value
+    end
+
+    def method_missing(method, *args)
+      if match = method.match(/^(.+)\!$/)
+        if args.count > 0
+          current_value = State.get_state(@from, match[1])
+          State.set_state(@from, $1, args[0])
+          current_value
+        else
+          current_state = State.get_state(@from, match[1])
+          State.set_state(@from, $1, current_state)
+          Observable.new(current_state) do |update|
+            State.set_state(@from, $1, update)
+          end
+        end
+      else
+        State.get_state(@from, method)
+      end
+    end
+  end
+
+  class State
+    class << self
+      attr_reader :current_observer
+
+      def initialize_states(object, initial_values) # initialize objects' name/value pairs
+        states[object].merge!(initial_values || {})
+      end
+
+      def get_state(object, name, current_observer = @current_observer)
+        # get current value of name for object, remember that the current object depends on this state, current observer can be overriden with last param
+        new_observers[current_observer][object] << name if current_observer && !new_observers[current_observer][object].include?(name)
+        states[object][name]
+      end
+
+      def set_state2(object, name, value)  # set object's name state to value, tell all observers it has changed.  Observers must implement update_react_js_state
+        object_needs_notification = object.respond_to? :update_react_js_state
+        observers_by_name[object][name].dup.each do |observer|
+          observer.update_react_js_state(object, name, value)
+          object_needs_notification = false if object == observer
+        end
+        object.update_react_js_state(nil, name, value) if object_needs_notification
+      end
+
+      def set_state(object, name, value, delay=nil)
+        states[object][name] = value
+        if delay
+          @delayed_updates ||= []
+          @delayed_updates << [object, name, value]
+          @delayed_updater ||= after(0.001) do
+            delayed_updates = @delayed_updates
+            @delayed_updates = []
+            @delayed_updater = nil
+            delayed_updates.each do |object, name, value|
+              set_state2(object, name, value)
+            end
+          end
+        else
+          set_state2(object, name, value)
+        end
+        value
+      end
+
+      def will_be_observing?(object, name, current_observer)
+        current_observer && new_observers[current_observer][object].include?(name)
+      end
+
+      def is_observing?(object, name, current_observer)
+        current_observer && observers_by_name[object][name].include?(current_observer)
+      end
+
+      def update_states_to_observe(current_observer = @current_observer)  # should be called after the last after_render callback, currently called after components render method
+        raise "update_states_to_observer called outside of watch block" unless current_observer
+        current_observers[current_observer].each do |object, names|
+          names.each do |name|
+            observers_by_name[object][name].delete(current_observer)
+          end
+        end
+        observers = current_observers[current_observer] = new_observers[current_observer]
+        new_observers.delete(current_observer)
+        observers.each do |object, names|
+          names.each do |name|
+            observers_by_name[object][name] << current_observer
+          end
+        end
+      end
+
+      def remove # call after component is unmounted
+        raise "remove called outside of watch block" unless @current_observer
+        current_observers[@current_observer].each do |object, names|
+          names.each do |name|
+            observers_by_name[object][name].delete(@current_observer)
+          end
+        end
+        current_observers.delete(@current_observer)
+      end
+
+      def set_state_context_to(observer) # wrap all execution that may set or get states in a block so we know which observer is executing
+        if `typeof window.reactive_ruby_timing !== 'undefined'`
+          @nesting_level = (@nesting_level || 0) + 1
+          start_time = Time.now.to_f
+          observer_name = (observer.class.respond_to?(:name) ? observer.class.name : observer.to_s) rescue "object:#{observer.object_id}"
+        end
+        saved_current_observer = @current_observer
+        @current_observer = observer
+        return_value = yield
+        return_value
+      ensure
+        @current_observer = saved_current_observer
+        @nesting_level = [0, @nesting_level - 1].max if `typeof window.reactive_ruby_timing !== 'undefined'`
+        return_value
+      end
+
+      def states
+        @states ||= Hash.new { |h, k| h[k] = {} }
+      end
+
+      [:new_observers, :current_observers, :observers_by_name].each do |method_name|
+        define_method(method_name) do
+          instance_variable_get("@#{method_name}") or
+          instance_variable_set("@#{method_name}", Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } })
+        end
+      end
+
+    end
+  end
+end

data/lib/react/top_level.rb

@@ -0,0 +1,97 @@
+require "native"
+require 'active_support'
+require 'react/component/base'
+
+module React
+  HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
+                button canvas caption cite code col colgroup data datalist dd del details dfn
+                dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5
+                h6 head header hr html i iframe img input ins kbd keygen label legend li link
+                main map mark menu menuitem meta meter nav noscript object ol optgroup option
+                output p param picture pre progress q rp rt ruby s samp script section select
+                small source span strong style sub summary sup table tbody td textarea tfoot th
+                thead time title tr track u ul var video wbr)
+  ATTRIBUTES = %w(accept acceptCharset accessKey action allowFullScreen allowTransparency alt
+                async autoComplete autoPlay cellPadding cellSpacing charSet checked classID
+                className cols colSpan content contentEditable contextMenu controls coords
+                crossOrigin data dateTime defer dir disabled download draggable encType form
+                formAction formEncType formMethod formNoValidate formTarget frameBorder height
+                hidden href hrefLang htmlFor httpEquiv icon id label lang list loop manifest
+                marginHeight marginWidth max maxLength media mediaGroup method min multiple
+                muted name noValidate open pattern placeholder poster preload radioGroup
+                readOnly rel required role rows rowSpan sandbox scope scrolling seamless
+                selected shape size sizes span spellCheck src srcDoc srcSet start step style
+                tabIndex target title type useMap value width wmode dangerouslySetInnerHTML)
+
+  def self.create_element(type, properties = {}, &block)
+    React::API.create_element(type, properties, &block)
+  end
+
+  def self.render(element, container)
+    container = `container.$$class ? container[0] : container`
+    if !(`typeof ReactDOM === 'undefined'`)
+      component = Native(`ReactDOM.render(#{element.to_n}, container, function(){#{yield if block_given?}})`) # v0.15+
+    elsif !(`typeof React.renderToString === 'undefined'`)
+      component = Native(`React.render(#{element.to_n}, container, function(){#{yield if block_given?}})`)
+    else
+      raise "render is not defined.  In React >= v15 you must import it with ReactDOM"
+    end
+
+    component.class.include(React::Component::API)
+    component
+  end
+
+  def self.is_valid_element(element)
+    element.kind_of?(React::Element) && `React.isValidElement(#{element.to_n})`
+  end
+
+  def self.render_to_string(element)
+    if !(`typeof ReactDOMServer === 'undefined'`)
+      React::RenderingContext.build { `ReactDOMServer.renderToString(#{element.to_n})` } # v0.15+
+    elsif !(`typeof React.renderToString === 'undefined'`)
+      React::RenderingContext.build { `React.renderToString(#{element.to_n})` }
+    else
+      raise "renderToString is not defined.  In React >= v15 you must import it with ReactDOMServer"
+    end
+  end
+
+  def self.render_to_static_markup(element)
+    if !(`typeof ReactDOMServer === 'undefined'`)
+      React::RenderingContext.build { `ReactDOMServer.renderToStaticMarkup(#{element.to_n})` } # v0.15+
+    elsif !(`typeof React.renderToString === 'undefined'`)
+      React::RenderingContext.build { `React.renderToStaticMarkup(#{element.to_n})` }
+    else
+      raise "renderToStaticMarkup is not defined.  In React >= v15 you must import it with ReactDOMServer"
+    end
+  end
+
+  def self.unmount_component_at_node(node)
+    if !(`typeof ReactDOM === 'undefined'`)
+      `ReactDOM.unmountComponentAtNode(node.$$class ? node[0] : node)` # v0.15+
+    elsif !(`typeof React.renderToString === 'undefined'`)
+      `React.unmountComponentAtNode(node.$$class ? node[0] : node)`
+    else
+      raise "unmountComponentAtNode is not defined.  In React >= v15 you must import it with ReactDOM"
+    end
+  end
+
+end
+
+Element.instance_eval do
+
+  class ::Element::DummyContext < React::Component::Base
+  end
+
+  def self.find(selector)
+    selector = selector.dom_node if selector.respond_to? :dom_node rescue selector
+    `$(#{selector})`
+  end
+
+  def self.[](selector)
+    find(selector)
+  end
+
+  def render(&block)
+    React.render(React::RenderingContext.render(nil) {::Element::DummyContext.new.instance_eval &block}, self)
+  end
+end if Object.const_defined?("Element")