hyper-react 0.10.0

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

@@ -0,0 +1,13 @@
+class Hash
+
+  alias_method :_pre_react_patch_initialize, :initialize
+
+  def initialize(defaults = undefined, &block)
+    if (`defaults===null`)
+      _pre_react_patch_initialize(&block)
+    else
+      _pre_react_patch_initialize(defaults, &block)
+    end
+  end
+
+end

data/lib/react/native_library.rb

@@ -0,0 +1,92 @@
+module React
+  # NativeLibrary handles importing JS libraries. Importing native components is handled
+  # by the React::Base.  It also provides several methods used by auto-import.rb
+
+  # A NativeLibrary is simply a wrapper that holds the name of the native js library.
+  # It responds to const_missing and method_missing by looking up objects within the js library.
+  # If the object is a react component it is wrapped by a reactrb component class, otherwise
+  # a nested NativeLibrary is returned.
+
+  # Two macros are provided: imports (for naming the native library) and renames which allows
+  # the members of a library to be given different names within the ruby name space.
+
+  # Public methods used by auto-import.rb are import_const_from_native and find_and_render_component
+  class NativeLibrary
+    class << self
+      def imports(native_name)
+        @native_prefix = "#{native_name}."
+        self
+      end
+
+      def rename(rename_list)
+        # rename_list is a hash in the form: native_name => ruby_name, native_name => ruby_name
+        rename_list.each do |js_name, ruby_name|
+          native_name = lookup_native_name(js_name)
+          if lookup_native_name(js_name)
+            create_component_wrapper(self, native_name, ruby_name) ||
+              create_library_wrapper(self, native_name, ruby_name)
+          else
+            raise "class #{name} < React::NativeLibrary could not import #{js_name}. "\
+            "Native value #{scope_native_name(js_name)} is undefined."
+          end
+        end
+      end
+
+      def import_const_from_native(klass, const_name, create_library)
+        native_name = lookup_native_name(const_name) ||
+                      lookup_native_name(const_name[0].downcase + const_name[1..-1])
+        native_name && (
+          create_component_wrapper(klass, native_name, const_name) || (
+            create_library &&
+              create_library_wrapper(klass, native_name, const_name)))
+      end
+
+      def const_missing(const_name)
+        import_const_from_native(self, const_name, true) || super
+      end
+
+      def method_missing(method_name, *args, &block)
+        method = method_name.gsub(/_as_node$/, '') # remove once _as_node is deprecated.
+        component_class = get_const(method) if const_defined?(method)
+        component_class ||= import_const_from_native(self, method, false)
+        raise 'could not import a react component named: '\
+              "#{scope_native_name method}" unless component_class
+        if method == method_name
+          React::RenderingContext.render(component_class, *args, &block)
+        else # remove once _as_node is deprecated.
+          React::RenderingContext.build_only(component_class, *args, &block)
+        end
+      end
+
+      private
+
+      def lookup_native_name(js_name)
+        native_name = scope_native_name(js_name)
+        `eval(#{native_name}) !== undefined && native_name`
+      # rubocop:disable Lint/RescueException  # that is what eval raises in Opal >= 0.10.
+      rescue Exception
+        nil
+        # rubocop:enable Lint/RescueException
+      end
+
+      def scope_native_name(js_name)
+        "#{@native_prefix}#{js_name}"
+      end
+
+      def create_component_wrapper(klass, native_name, ruby_name)
+        if React::API.native_react_component?(native_name)
+          new_klass = klass.const_set ruby_name, Class.new
+          new_klass.class_eval do
+            include React::Component
+            imports native_name
+          end
+          new_klass
+        end
+      end
+
+      def create_library_wrapper(klass, native_name, ruby_name)
+        klass.const_set ruby_name, Class.new(React::NativeLibrary).imports(native_name)
+      end
+    end
+  end
+end

data/lib/react/object.rb

@@ -0,0 +1,15 @@
+# Lazy load HTML tag constants in the form DIV or A
+# This is needed to allow for a HAML expression like this DIV.my_class
+class Object
+  class << self
+    alias _reactrb_tag_original_const_missing const_missing
+
+    def const_missing(const_name)
+      # Opal uses const_missing to initially define things,
+      # so we always call the original, and respond to the exception
+      _reactrb_tag_original_const_missing(const_name)
+    rescue StandardError => e
+      React::Component::Tags.html_tag_class_for(const_name) || raise(e)
+    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/react-source.rb

@@ -0,0 +1,9 @@
+if RUBY_ENGINE == 'opal'
+  require 'react.js'
+  require "react-server.js"
+else
+  require "react/rails/asset_variant"
+  react_directory = React::Rails::AssetVariant.new(addons: true).react_directory
+  Opal.append_path react_directory.untaint
+  Opal.append_path File.expand_path('../../react-sources/', __FILE__).untaint
+end

data/lib/react/rendering_context.rb

@@ -0,0 +1,142 @@
+module React
+  class RenderingContext
+    class << self
+      attr_accessor :waiting_on_resources
+
+      def build_only(name, *args, &block)
+        React::Component.deprecation_warning(
+          '..._as_node is deprecated.  Render component and then use the .node method instead'
+        )
+        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+      end
+
+      def 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
+            run_child_block(name.nil?, &block)
+            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
+        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 build
+        current = @buffer
+        @buffer = []
+        return_val = yield @buffer
+        @buffer = current
+        return_val
+      end
+
+      def as_node(element)
+        @buffer.delete(element)
+        element
+      end
+
+      alias delete as_node
+
+      def rendered?(element)
+        @buffer.include? element
+      end
+
+      def replace(e1, e2)
+        @buffer[@buffer.index(e1)] = e2
+      end
+
+      def 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
+
+      # run_child_block gathers the element(s) generated by a child block.
+      # for example when rendering this div: div { "hello".span; "goodby".span }
+      # two child Elements will be generated.
+      #
+      # the final value of the block should either be
+      #   1 an object that responds to :acts_as_string?
+      #   2 a string,
+      #   3 an element that is NOT yet pushed on the rendering buffer
+      #   4 or the last element pushed on the buffer
+      #
+      # in case 1 we change the object to a string, and then it becomes case 2
+      # in case 2 we automatically push the string onto the buffer
+      # in case 3 we also push the Element onto the buffer IF the buffer is empty
+      # case 4 requires no special processing
+      #
+      # Once we have taken care of these special cases we do a check IF we are in an
+      # outer rendering scope.  In this case react only allows us to generate 1 Element
+      # so we insure that is the case, and also check to make sure that element in the buffer
+      # is the element returned
+
+      def run_child_block(is_outer_scope)
+        result = yield
+        result = result.to_s if result.try :acts_as_string?
+        @buffer << result if result.is_a?(String) || (result.is_a?(Element) && @buffer.empty?)
+        raise_render_error(result) if is_outer_scope && @buffer != [result]
+      end
+
+      # heurestically raise a meaningful error based on the situation
+
+      def raise_render_error(result)
+        improper_render 'A different element was returned than was generated within the DSL.',
+                        'Possibly improper use of Element#delete.' if @buffer.count == 1
+        improper_render "Instead #{@buffer.count} elements were generated.",
+                        'Do you want to wrap your elements in a div?' if @buffer.count > 1
+        improper_render "Instead the component #{result} was returned.",
+                        "Did you mean #{result}()?" if result.try :reactrb_component?
+        improper_render "Instead the #{result.class} #{result} was returned.",
+                        'You may need to convert this to a string.'
+      end
+
+      def improper_render(message, solution)
+        raise "a component's render method must generate and return exactly 1 element or a string.\n"\
+              "    #{message}  #{solution}"
+      end
+    end
+  end
+
+  class ::Object
+    [:span, :td, :th, :while_loading].each do |tag|
+      define_method(tag) do |*args, &block|
+        args.unshift(tag)
+        return send(*args, &block) if is_a? React::Component
+        React::RenderingContext.render(*args) { to_s }
+      end
+    end
+
+    def para(*args, &block)
+      args.unshift(:p)
+      return send(*args, &block) if is_a? React::Component
+      React::RenderingContext.render(*args) { to_s }
+    end
+
+    def br
+      return send(:br) if is_a? React::Component
+      React::RenderingContext.render(:span) do
+        React::RenderingContext.render(to_s)
+        React::RenderingContext.render(:br)
+      end
+    end
+  end
+end

data/lib/react/state.rb

@@ -0,0 +1,190 @@
+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
+
+    @rendering_level = 0
+
+    class << self
+      attr_reader :current_observer
+
+      def has_observers?(object, name)
+        !observers_by_name[object][name].empty?
+      end
+
+      def bulk_update
+        saved_bulk_update_flag = @bulk_update_flag
+        @bulk_update_flag = true
+        yield
+      ensure
+        @bulk_update_flag = saved_bulk_update_flag
+      end
+
+      def set_state2(object, name, value, updates, exclusions = nil)
+        # 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|
+          next if exclusions && exclusions.include?(observer)
+          updates[observer] += [object, name, value]
+          object_needs_notification = false if object == observer
+        end
+        updates[object] += [nil, name, value] if object_needs_notification
+      end
+
+      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
+        if current_observer && !new_observers[current_observer][object].include?(name)
+          new_observers[current_observer][object] << name
+        end
+        if @delayed_updates && @delayed_updates[object][name]
+          @delayed_updates[object][name][1] << current_observer
+        end
+        states[object][name]
+      end
+
+      def set_state(object, name, value, delay=nil)
+        states[object][name] = value
+        if delay || @bulk_update_flag
+          @delayed_updates ||= Hash.new { |h, k| h[k] = {} }
+          @delayed_updates[object][name] = [value, Set.new]
+          @delayed_updater ||= after(0.001) do
+            delayed_updates = @delayed_updates
+            @delayed_updates = Hash.new { |h, k| h[k] = {} } # could this be nil???
+            @delayed_updater = nil
+            updates = Hash.new { |hash, key| hash[key] = Array.new }
+            delayed_updates.each do |object, name_hash|
+              name_hash.each do |name, value_and_set|
+                set_state2(object, name, value_and_set[0], updates, value_and_set[1])
+              end
+            end
+            updates.each { |observer, args| observer.update_react_js_state(*args) }
+          end
+        elsif @rendering_level == 0
+          updates = Hash.new { |hash, key| hash[key] = Array.new }
+          set_state2(object, name, value, updates)
+          updates.each { |observer, args| observer.update_react_js_state(*args) }
+        end
+        value
+      end
+
+      def notify_observers(object, name, value)
+        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 notify_observers_after_thread_completes(object, name, value)
+        (@delayed_updates ||= []) << [object, name, value]
+        @delayed_updater ||= after(0) do
+          delayed_updates = @delayed_updates
+          @delayed_updates = []
+          @delayed_updater = nil
+          delayed_updates.each { |args| notify_observers(*args) }
+        end
+      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, rendering = nil) # 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
+        @rendering_level += 1 if rendering
+        return_value = yield
+        return_value
+      ensure
+        @current_observer = saved_current_observer
+        @rendering_level -= 1 if rendering
+        @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}") ||
+          instance_variable_set("@#{method_name}", Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } })
+        end
+      end
+    end
+  end
+end