hyper-react 0.99.6 → 1.0.0.lap21

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.each do |key, value|
+       `hash[#{key}] = #{value}`
+    end
+    hash
+  end
+end

data/lib/react/ext/opal-jquery/element.rb

@@ -0,0 +1,26 @@
+Element.instance_eval do
+  def self.find(selector)
+    selector = begin
+      selector.dom_node
+    rescue
+      selector
+    end if `#{selector}.$dom_node !== undefined`
+    `$(#{selector})`
+  end
+
+  def self.[](selector)
+    find(selector)
+  end
+
+  define_method :render do |container = nil, params = {}, &block|
+    if `#{self.to_n}._reactrb_component_class === undefined`
+      `#{self.to_n}._reactrb_component_class = #{Class.new(Hyperloop::Component)}`
+    end
+    klass = `#{self.to_n}._reactrb_component_class`
+    klass.class_eval do
+      render(container, params, &block)
+    end
+
+    React.render(React.create_element(`#{self.to_n}._reactrb_component_class`), self)
+  end
+end if Object.const_defined?('Element')

data/lib/react/ext/string.rb

@@ -0,0 +1,8 @@
+class String
+  def event_camelize
+    `return #{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,87 @@
+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, *args, &block)
+        component_class = const_get(method) if const_defined?(method, false)
+        component_class ||= import_const_from_native(self, method, false)
+        raise 'could not import a react component named: '\
+              "#{scope_native_name method}" unless component_class
+        React::RenderingContext.render(component_class, *args, &block)
+      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 Hyperloop::Component::Mixin
+            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/react-source-browser.rb

@@ -0,0 +1,3 @@
+if RUBY_ENGINE == 'opal'
+  require 'react.js'
+end

data/lib/react/react-source-server.rb

@@ -0,0 +1,3 @@
+if RUBY_ENGINE == 'opal'
+  require 'react-server.js'
+end

data/lib/react/react-source.rb

@@ -0,0 +1,16 @@
+if RUBY_ENGINE == 'opal'
+  %x{
+    var ms = [
+      "Warning: `react/react-source` is deprecated, ",
+      "use `react/react-source-browser` or `react/react-source-server` instead."
+    ]
+    console.error(ms.join(""));
+  }
+  require 'react.js'
+  require "react-server.js"
+else
+  require "react/config"
+  require "react/rails/asset_variant"
+  react_directory = React::Rails::AssetVariant.new(React::Config.config).react_directory
+  Opal.append_path react_directory.untaint
+end

data/lib/react/ref_callback.rb

@@ -0,0 +1,31 @@
+require 'react/native_library'
+
+module React
+  module RefsCallbackExtension
+  end
+
+  class API
+    class << self
+      alias :orig_convert_props :convert_props
+    end
+
+    def self.convert_props(properties)
+      props = self.orig_convert_props(properties)
+      props.map do |key, value|
+        if key == "ref" && value.is_a?(Proc)
+          new_proc = Proc.new do |native_inst|
+            if `#{native_inst}.__opalInstance !== undefined && #{native_inst}.__opalInstance !== null`
+              value.call(`#{native_inst}.__opalInstance`)
+            elsif `ReactDOM.findDOMNode !== undefined && #{native_inst}.nodeType === undefined`
+              value.call(`ReactDOM.findDOMNode(#{native_inst})`) # react >= v0.15.`)
+            else
+              value.call(native_inst)
+            end
+          end
+          props[key] = new_proc
+        end
+      end
+      props
+    end
+  end
+end

data/lib/react/rendering_context.rb

@@ -0,0 +1,146 @@
+module React
+  class RenderingContext
+    class << self
+      attr_accessor :waiting_on_resources
+
+      def render(name, *args, &block)
+        was_outer_most = !@not_outer_most
+        @not_outer_most = true
+        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::API.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) }
+                element.waiting_on_resources ||= waiting_on_resources if buffer.last.is_a?(String)
+              end
+            elsif @buffer.last.is_a? React::Element
+              @buffer.last.tap { |element| element.waiting_on_resources ||= saved_waiting_on_resources }
+            else
+              buffer_s = @buffer.last.to_s
+              React::RenderingContext.render(:span) { buffer_s }.tap { |element| element.waiting_on_resources = saved_waiting_on_resources }
+            end
+          end
+        elsif name.is_a? React::Element
+          element = name
+        else
+          element = React::API.create_element(name, *args)
+          element.waiting_on_resources = waiting_on_resources
+        end
+        @buffer << element
+        self.waiting_on_resources = nil
+        element
+      ensure
+        @not_outer_most = @buffer = nil if was_outer_most
+      end
+
+      def build
+        current = @buffer
+        @buffer = []
+        return_val = yield @buffer
+        @buffer = current
+        return_val
+      end
+
+      def delete(element)
+        @buffer.delete(element)
+        element
+      end
+      alias as_node delete
+
+      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|
+          begin
+            value.delete if value.is_a?(Element) # deletes Element from buffer
+          rescue Exception
+          end
+        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
+        if result.respond_to?(:acts_as_string?) && result.acts_as_string?
+          @buffer << result.to_s
+        elsif result.is_a?(String) || (result.is_a?(React::Element) && @buffer.empty?)
+          @buffer << result
+        end
+        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
+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