hyper-react 0.12.7 → 0.99.0

data/lib/react/event.rb

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

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

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

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

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

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

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

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

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

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

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

data/lib/react/react-source.rb

@@ -1,20 +0,0 @@
-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(
-    addons: true,
-    variant: React::Config.config[:environment].to_sym
-  ).react_directory
-  Opal.append_path react_directory.untaint
-  Opal.append_path File.expand_path('../../react-sources/', __FILE__).untaint
-end

data/lib/react/ref_callback.rb

@@ -1,31 +0,0 @@
-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}._getOpalInstance !== undefined`
-              value.call(`#{native_inst}._getOpalInstance()`)
-            elsif `React.findDOMNode !== undefined && #{native_inst}.nodeType === undefined`
-              value.call(`React.findDOMNode(#{native_inst})`)
-            else
-              value.call(native_inst)
-            end
-          end
-          props[key] = new_proc
-        end
-      end
-      props
-    end
-  end
-end

data/lib/react/rendering_context.rb

@@ -1,144 +0,0 @@
-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.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 ||= buffer.last.is_a?(String) && 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
-      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 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|
-          begin
-            value.as_node if value.is_a?(Element)
-          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
-        result = result.to_s.span if result.try :acts_as_string? || result.is_a?(String)
-        @buffer << result if result.is_a?(String) || (result.is_a?(React::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