reactrb 0.7.42

data/lib/react/component/api.rb

@@ -0,0 +1,50 @@
+module React
+  module Component
+    module API
+      def dom_node
+        if !(`typeof ReactDOM === 'undefined' || typeof ReactDOM.findDOMNode === 'undefined'`)
+          `ReactDOM.findDOMNode(#{self}.native)` # v0.14.0
+        elsif !(`typeof React.findDOMNode === 'undefined'`)
+          `React.findDOMNode(#{self}.native)`    # v0.13.0
+        else
+          `#{self}.native.getDOMNode`            # v0.12.0
+        end
+      end
+
+      def mounted?
+        `#{self}.native.isMounted()`
+      end
+
+      def force_update!
+        `#{self}.native.forceUpdate()`
+      end
+
+      def set_props(prop, &block)
+        set_or_replace_state_or_prop(prop, 'setProps', &block)
+      end
+
+      def set_props!(prop, &block)
+        set_or_replace_state_or_prop(prop, 'replaceProps', &block)
+      end
+
+      def set_state(state, &block)
+        set_or_replace_state_or_prop(state, 'setState', &block)
+      end
+
+      def set_state!(state, &block)
+        set_or_replace_state_or_prop(state, 'replaceState', &block)
+      end
+
+      private
+
+      def set_or_replace_state_or_prop(state_or_prop, method, &block)
+        raise "No native ReactComponent associated" unless @native
+        %x{
+          #{@native}[#{method}](#{state_or_prop.shallow_to_n}, function(){
+            #{block.call if block}
+          });
+        }
+      end
+    end
+  end
+end

data/lib/react/component/base.rb

@@ -0,0 +1,9 @@
+module React
+  module Component
+    class Base
+      def self.inherited(child)
+        child.include(Component)
+      end
+    end
+  end
+end

data/lib/react/component/class_methods.rb

@@ -0,0 +1,190 @@
+module React
+  module Component
+    module ClassMethods
+      def backtrace(*args)
+        @backtrace_off = (args[0] == :off)
+      end
+
+      def process_exception(e, component, reraise = nil)
+        message = ["Exception raised while rendering #{component}"]
+        if e.backtrace && e.backtrace.length > 1 && !@backtrace_off  # seems like e.backtrace is empty in safari???
+          message << "    #{e.backtrace[0]}"
+          message += e.backtrace[1..-1].collect { |line| line }
+        else
+          message[0] += ": #{e.message}"
+        end
+        message = message.join("\n")
+        `console.error(message)`
+        raise e if reraise
+      end
+
+      def deprecation_warning(message)
+        @deprecation_messages ||= []
+        message = "Warning: Deprecated feature used in #{self.name}. #{message}"
+        unless @deprecation_messages.include? message
+          @deprecation_messages << message
+          IsomorphicHelpers.log message, :warning
+        end
+      end
+
+      def validator
+        @validator ||= Validator.new(self)
+      end
+
+      def prop_types
+        if self.validator
+          {
+            _componentValidator: %x{
+              function(props, propName, componentName) {
+                var errors = #{validator.validate(Hash.new(`props`))};
+                var error = new Error(#{"In component `" + self.name + "`\n" + `errors`.join("\n")});
+                return #{`errors`.count > 0 ? `error` : `undefined`};
+              }
+            }
+          }
+        else
+          {}
+        end
+      end
+
+      def default_props
+        validator.default_props
+      end
+
+      def params(&block)
+        validator.build(&block)
+      end
+
+      def props_wrapper
+        @props_wrapper ||= Class.new(PropsWrapper)
+      end
+
+      def define_param(name, param_type)
+        props_wrapper.define_param(name, param_type, self)
+      end
+
+      def param(*args)
+        if args[0].is_a? Hash
+          options = args[0]
+          name = options.first[0]
+          default = options.first[1]
+          options.delete(name)
+          options.merge!({default: default})
+        else
+          name = args[0]
+          options = args[1] || {}
+        end
+        if options[:default]
+          validator.optional(name, options)
+        else
+          validator.requires(name, options)
+        end
+      end
+
+      def required_param(name, options = {})
+        deprecation_warning "`required_param` is deprecated, use `param` instead."
+        validator.requires(name, options)
+      end
+
+      alias_method :require_param, :required_param
+
+      def optional_param(name, options = {})
+        deprecation_warning "`optional_param` is deprecated, use `param param_name: default_value` instead."
+        validator.optional(name, options)
+      end
+
+      def collect_other_params_as(name)
+        validator.allow_undefined_props = true
+        define_method(name) do
+          @_all_others ||= self.class.validator.undefined_props(props)
+        end
+
+        validator_in_lexial_scope = validator
+        props_wrapper.define_method(name) do
+          @_all_others ||= validator_in_lexial_scope.undefined_props(props)
+        end
+      end
+
+      def define_state(*states, &block)
+        default_initial_value = (block && block.arity == 0) ? yield : nil
+        states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
+        states.each { |name| states_hash[name] = default_initial_value }
+        (self.initial_state ||= {}).merge! states_hash
+        states_hash.each do |name, initial_value|
+          define_state_methods(self, name, &block)
+        end
+      end
+
+      def export_state(*states, &block)
+        default_initial_value = (block && block.arity == 0) ? yield : nil
+        states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
+        states.each { |name| states_hash[name] = default_initial_value }
+        State.initialize_states(self, states_hash)
+        states_hash.each do |name, initial_value|
+          define_state_methods(self, name, self, &block)
+          define_state_methods(singleton_class, name, self, &block)
+        end
+      end
+
+      def define_state_methods(this, name, from = nil, &block)
+        this.define_method("#{name}") do
+          self.class.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead." if from.nil? || from == this
+          State.get_state(from || self, name)
+        end
+        this.define_method("#{name}=") do |new_state|
+          self.class.deprecation_warning "Direct assignment to state `#{name}`.  Use `#{(from && from != this) ? from : 'state'}.#{name}!` instead."
+          yield name, State.get_state(from || self, name), new_state if block && block.arity > 0
+          State.set_state(from || self, name, new_state)
+        end
+        this.define_method("#{name}!") do |*args|
+          self.class.deprecation_warning "Direct access to state `#{name}`.  Use `state.#{name}` instead."  if from.nil? or from == this
+          if args.count > 0
+            yield name, State.get_state(from || self, name), args[0] if block && block.arity > 0
+            current_value = State.get_state(from || self, name)
+            State.set_state(from || self, name, args[0])
+            current_value
+          else
+            current_state = State.get_state(from || self, name)
+            yield name, State.get_state(from || self, name), current_state if block && block.arity > 0
+            State.set_state(from || self, name, current_state)
+            Observable.new(current_state) do |update|
+              yield name, State.get_state(from || self, name), update if block && block.arity > 0
+              State.set_state(from || self, name, update)
+            end
+          end
+        end
+      end
+
+      def native_mixin(item)
+        native_mixins << item
+      end
+
+      def native_mixins
+        @native_mixins ||= []
+      end
+
+      def static_call_back(name, &block)
+        static_call_backs[name] = block
+      end
+
+      def static_call_backs
+        @static_call_backs ||= {}
+      end
+
+      def export_component(opts = {})
+        export_name = (opts[:as] || name).split("::")
+        first_name = export_name.first
+        Native(`window`)[first_name] = add_item_to_tree(Native(`window`)[first_name], [React::API.create_native_react_class(self)] + export_name[1..-1].reverse).to_n
+      end
+
+      def add_item_to_tree(current_tree, new_item)
+        if Native(current_tree).class != Native::Object || new_item.length == 1
+          new_item.inject { |memo, sub_name| { sub_name => memo } }
+        else
+          Native(current_tree)[new_item.last] = add_item_to_tree(Native(current_tree)[new_item.last], new_item[0..-2])
+          current_tree
+        end
+      end
+    end
+  end
+end

data/lib/react/component/props_wrapper.rb

@@ -0,0 +1,82 @@
+module React
+  module Component
+    class PropsWrapper
+      attr_reader :props
+
+      def self.define_param(name, param_type, owner)
+        owner.define_method("#{name}") do |*args, &block|
+          deprecated_params_method("#{name}", *args, &block)
+        end
+        if param_type == Observable
+          owner.define_method("#{name}!") do |*args|
+            deprecated_params_method("#{name}!", *args)
+          end
+          define_method("#{name}") do
+            value_for(name)
+          end
+          define_method("#{name}!") do |*args|
+            current_value = value_for(name)
+            if args.count > 0
+              props[name].call args[0]
+              current_value
+            else
+              # rescue in case we in middle of render... What happens during a
+              # render that causes exception?
+              # Where does `dont_update_state` come from?
+              props[name].call current_value unless @dont_update_state rescue nil
+              props[name]
+            end
+          end
+        elsif param_type == Proc
+          define_method("#{name}") do |*args, &block|
+            props[name].call(*args, &block) if props[name]
+          end
+        else
+          define_method("#{name}") do
+            if @processed_params.has_key? name
+              @processed_params[name]
+            else
+              @processed_params[name] = if param_type.respond_to? :_react_param_conversion
+                param_type._react_param_conversion props[name]
+              elsif param_type.is_a?(Array) &&
+                param_type[0].respond_to?(:_react_param_conversion)
+                props[name].collect do |param|
+                  param_type[0]._react_param_conversion param
+                end
+              else
+                props[name]
+              end
+            end
+          end
+        end
+      end
+
+      def unchanged_processed_params(new_props)
+        Hash[
+          *@processed_params.collect do |key, value|
+            [key, value] if @props[key].equal? new_props[key] # `#{@props[key]} == #{new_props[key]}`
+          end.compact.flatten(1)
+        ]
+      end
+
+      def initialize(props, current_props_wrapper=nil)
+        @props = props || {}
+        @processed_params = if current_props_wrapper
+          current_props_wrapper.unchanged_processed_params(props)
+        else
+          {}
+        end
+      end
+
+      def [](prop)
+        props[prop]
+      end
+
+      private
+
+      def value_for(name)
+        self[name].instance_variable_get("@value") if self[name]
+      end
+    end
+  end
+end

data/lib/react/element.rb

@@ -0,0 +1,77 @@
+require 'react/ext/string'
+
+module React
+  class Element
+    include Native
+
+    alias_native :element_type, :type
+    alias_native :props, :props
+
+    attr_reader :type
+    attr_reader :properties
+    attr_reader :block
+
+    attr_accessor :waiting_on_resources
+
+    def initialize(native_element, type, properties, block)
+      @type = type
+      @properties = (`typeof #{properties} === 'undefined'` ? nil : properties) || {}
+      @block = block
+      @native = native_element
+    end
+
+    def on(event_name)
+      name = event_name.to_s.event_camelize
+      props = if React::Event::BUILT_IN_EVENTS.include?("on#{name}")
+        {"on#{name}" => %x{
+          function(event){
+            #{yield React::Event.new(`event`)}
+          }
+        }}
+      else
+        {"_on#{name}" => %x{
+          function(){
+            #{yield *Array(`arguments`)}
+          }
+        }}
+      end
+      @native = `React.cloneElement(#{self.to_n}, #{props.to_n})`
+      @properties.merge! props
+      self
+    end
+
+    def render(props = {})  # for rendering children
+      if props.empty?
+        React::RenderingContext.render(self)
+      else
+        React::RenderingContext.render(
+          Element.new(
+            `React.cloneElement(#{self.to_n}, #{API.convert_props(props)})`,
+            type,
+            properties.merge(props),
+            block
+          )
+        )
+      end
+    end
+
+    def method_missing(class_name, args = {}, &new_block)
+      class_name = class_name.split("__").collect { |s| s.gsub("_", "-") }.join("_")
+      new_props = properties.dup
+      new_props["class"] = "#{new_props['class']} #{class_name} #{args.delete("class")} #{args.delete('className')}".split(" ").uniq.join(" ")
+      new_props.merge! args
+      React::RenderingContext.replace(
+        self,
+        React::RenderingContext.build { React::RenderingContext.render(type, new_props, &new_block) }
+      )
+    end
+
+    def as_node
+      React::RenderingContext.as_node(self)
+    end
+
+    def delete
+      React::RenderingContext.delete(self)
+    end
+  end
+end

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