hyper-component 0.99.6 → 1.0.alpha1

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
-    # aliased above: alias_native :alt_key, :altKey
-    alias_native :button, :button
-    alias_native :buttons, :buttons
-    alias_native :client_x, :clientX
-    alias_native :client_y, :clientY
-    # aliased above: alias_native :ctrl_key, :ctrlKey
-    alias_native :get_modifier_state, :getModifierState
-    # aliased above: alias_native :meta_key, :metaKey
-    alias_native :page_x, :pageX
-    alias_native :page_y, :pageY
-    # aliased above: alias_native :related_target, :relatedTarget
-    alias_native :screen_x, :screen_x
-    alias_native :screen_y, :screen_y
-    # aliased above: alias_native :shift_key, :shift_key
-    # Touch
-    # aliased above: alias_native :alt_key, :altKey
-    alias_native :changed_touches, :changedTouches
-    # aliased above: alias_native :ctrl_key, :ctrlKey
-    # aliased above: alias_native :get_modifier_state, :getModifierState
-    # aliased above: alias_native :meta_key, :metaKey
-    # aliased above: 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 onContextMenu onDoubleClick onDrag
-      onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop
-      onMouseDown onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver
-      onMouseUp onSelect onTouchCancel onTouchEnd onTouchMove onTouchStart onScroll onWheel}
-
-    def initialize(native_event)
-      @native = native_event
-    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 = 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

@@ -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/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} !== null && #{native_inst}.__opalInstance !== undefined && #{native_inst}.__opalInstance !== null`
-              value.call(`#{native_inst}.__opalInstance`)
-            elsif `#{native_inst} !== null &&  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

@@ -1,149 +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::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 render a span
-      # 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?
-          # hyper-mesh DummyValues respond to acts_as_string, and must
-          # be converted to spans INSIDE the parent, otherwise the waiting_on_resources
-          # flag will get set in the wrong context
-          React::RenderingContext.render(:span) { 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

data/lib/react/server.rb

@@ -1,19 +0,0 @@
-module React
-  module Server
-    def self.render_to_string(element)
-      if !(`typeof ReactDOMServer === 'undefined'`)
-        React::RenderingContext.build { `ReactDOMServer.renderToString(#{element.to_n})` } # v0.15+
-      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+
-      else
-        raise "renderToStaticMarkup is not defined.  In React >= v15 you must import it with ReactDOMServer"
-      end
-    end
-  end
-end

data/lib/react/state_wrapper.rb

@@ -1,23 +0,0 @@
-module HyperStore
-  class StateWrapper < BaseStoreClass # < BasicObject
-
-    def [](state)
-      `#{__from__.instance_variable_get('@native')}.state[#{state}] || #{nil}`
-    end
-
-    def []=(state, new_value)
-      `#{__from__.instance_variable_get('@native')}.state[#{state}] = new_value`
-    end
-
-    alias pre_component_method_missing method_missing
-
-    def method_missing(method, *args)
-      if method.end_with?('!') && __from__.respond_to?(:deprecation_warning)
-        __from__.deprecation_warning("The mutator 'state.#{method}' has been deprecated.  Use 'mutate.#{method.sub(/\!$/,'')}' instead.")
-        __from__.mutate.__send__(method.chop, *args)
-      else
-        pre_component_method_missing(method, *args)
-      end
-    end
-  end
-end

data/lib/react/test.rb

@@ -1,16 +0,0 @@
-require 'react/test/session'
-require 'react/test/dsl'
-
-module React
-  module Test
-    class << self
-      def current_session
-        @current_session ||= Session.new
-      end
-
-      def reset_session!
-        @current_session = nil
-      end
-    end
-  end
-end

data/lib/react/test/dsl.rb

@@ -1,17 +0,0 @@
-require 'react/test'
-
-module React
-  module Test
-    module DSL
-      def component
-        React::Test.current_session
-      end
-
-      Session::DSL_METHODS.each do |method|
-        define_method method do |*args, &block|
-          component.public_send(method, *args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/react/test/matchers/render_html_matcher.rb

@@ -1,56 +0,0 @@
-module React
-  module Test
-    module Matchers
-      class RenderHTMLMatcher
-        def initialize(expected)
-          @expected = expected
-          @params = {}
-        end
-
-        def with_params(params)
-          @params = params
-          self
-        end
-
-        def matches?(component)
-          @component = component
-          @actual = render_to_html
-          @expected == @actual
-        end
-
-        def failure_message
-          failure_string
-        end
-
-        def failure_message_when_negated
-          failure_string(:negative)
-        end
-
-        alias negative_failure_message failure_message_when_negated
-
-        private
-
-        def render_to_html
-          element = React.create_element(@component, @params)
-          React::Server.render_to_static_markup(element)
-        end
-
-        def failure_string(negative = false)
-          str = "expected '#{@component.name}' with params '#{@params}' to "
-          str = str + "not " if negative
-          str = str + "render '#{@expected}', but '#{@actual}' was rendered."
-          str
-        end
-      end
-
-      def render_static_html(*args)
-        RenderHTMLMatcher.new(*args)
-      end
-
-      def render(*args)
-        %x{ console.error("Warning: `render` matcher is deprecated in favor of `render_static_html`."); }
-        RenderHTMLMatcher.new(*args)
-      end
-    end
-  end
-end