reactive-ruby 0.7.28 → 0.7.29

data/lib/react/component/class_methods.rb

@@ -0,0 +1,183 @@
+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 !@backtrace_off
+          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 validator
+        @validator ||= React::Validator.new
+      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 define_param_method(name, param_type)
+        if param_type == React::Observable
+          (@two_way_params ||= []) << name
+          define_method("#{name}") do
+            params[name].instance_variable_get("@value") if params[name]
+          end
+          define_method("#{name}!") do |*args|
+            return unless params[name]
+            if args.count > 0
+              current_value = params[name].instance_variable_get("@value")
+              params[name].call args[0]
+              current_value
+            else
+              current_value = params[name].instance_variable_get("@value")
+              params[name].call current_value unless @dont_update_state rescue nil # rescue in case we in middle of render
+              params[name]
+            end
+          end
+        elsif param_type == Proc
+          define_method("#{name}") do |*args, &block|
+            params[name].call(*args, &block) if params[name]
+          end
+        else
+          define_method("#{name}") do
+            @processed_params[name] ||= if param_type.respond_to? :_react_param_conversion
+                                          param_type._react_param_conversion params[name]
+                                        elsif param_type.is_a? Array and param_type[0].respond_to? :_react_param_conversion
+                                          params[name].collect { |param| param_type[0]._react_param_conversion param }
+                                        else
+                                          params[name]
+                                        end
+          end
+        end
+      end
+
+      def required_param(name, options = {})
+        validator.requires(name, options)
+        define_param_method(name, options[:type])
+      end
+
+      alias_method :require_param, :required_param
+
+      def optional_param(name, options = {})
+        validator.optional(name, options)
+        define_param_method(name, options[:type]) unless name == :params
+      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
+      end
+
+      def define_state(*states, &block)
+        default_initial_value = (block and 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 and block.arity == 0) ? yield : nil
+        states_hash = (states.last.is_a? Hash) ? states.pop : {}
+        states.each { |name| states_hash[name] = default_initial_value }
+        React::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
+          React::State.get_state(from || self, name)
+        end
+        this.define_method("#{name}=") do |new_state|
+          yield name, React::State.get_state(from || self, name), new_state if block and block.arity > 0
+          React::State.set_state(from || self, name, new_state)
+        end
+        this.define_method("#{name}!") do |*args|
+          #return unless @native
+          if args.count > 0
+            yield name, React::State.get_state(from || self, name), args[0] if block and block.arity > 0
+            current_value = React::State.get_state(from || self, name)
+            React::State.set_state(from || self, name, args[0])
+            current_value
+          else
+            current_state = React::State.get_state(from || self, name)
+            yield name, React::State.get_state(from || self, name), current_state if block and block.arity > 0
+            React::State.set_state(from || self, name, current_state)
+            React::Observable.new(current_state) do |update|
+              yield name, React::State.get_state(from || self, name), update if block and block.arity > 0
+              React::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 or new_item.length == 1
+          new_item.inject do |memo, sub_name| {sub_name => memo} end
+        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/{reactive-ruby → react}/element.rb

@@ -1,4 +1,4 @@
-require "reactive-ruby/ext/string"
+require 'react/ext/string'
 
 module React
   class Element
@@ -6,11 +6,11 @@ module React
 
     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)
@@ -39,22 +39,22 @@ module React
       @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), 
+            `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
@@ -65,14 +65,13 @@ module React
         React::RenderingContext.build { React::RenderingContext.render(type, new_props, &new_block) }
       )
     end
-    
+
     def as_node
       RenderingContext.as_node(self)
     end
-    
+
     def delete
       RenderingContext.delete(self)
     end
-
   end
 end

data/lib/react/native_library.rb

@@ -0,0 +1,57 @@
+module React
+  class NativeLibrary
+    def self.renames_and_exclusions
+      @renames_and_exclusions ||= {}
+    end
+
+    def self.libraries
+      @libraries ||= []
+    end
+
+    def self.const_missing(name)
+      if renames_and_exclusions.has_key? name
+        if native_name = renames_and_exclusions[name]
+          native_name
+        else
+          super
+        end
+      else
+        libraries.each do |library|
+          native_name = "#{library}.#{name}"
+          native_component = `eval(#{native_name})` rescue nil
+          React::API.import_native_component(name, native_component) and return name if native_component and `native_component != undefined`
+        end
+        name
+      end
+    end
+
+    def self.method_missing(n, *args, &block)
+      name = n
+      if name =~ /_as_node$/
+        node_only = true
+        name = name.gsub(/_as_node$/, "")
+      end
+      unless name = const_get(name)
+        return super
+      end
+      if node_only
+        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
+      else
+        React::RenderingContext.render(name, *args, &block)
+      end
+    rescue
+    end
+
+    def self.imports(library)
+      libraries << library
+    end
+
+    def self.rename(rename_list={})
+      renames_and_exclusions.merge!(rename_list.invert)
+    end
+
+    def self.exclude(*exclude_list)
+      renames_and_exclusions.merge(Hash[exclude_list.map {|k| [k, nil]}])
+    end
+  end
+end

data/lib/{reactive-ruby → react}/observable.rb

@@ -1,7 +1,5 @@
 module React
-
   class Observable
-
     def initialize(value, on_change = nil, &block)
       @value = value
       @on_change = on_change || block
@@ -27,7 +25,5 @@ module React
     def to_proc
       lambda { |arg = @value| @on_change.call arg }
     end
-
   end
-
 end

data/lib/{reactive-ruby → react}/rendering_context.rb

@@ -1,7 +1,5 @@
 module React
-
   class RenderingContext
-
     class << self
       attr_accessor :waiting_on_resources
     end
@@ -76,11 +74,9 @@ module React
         value.as_node if value.is_a? Element rescue nil
       end if args[0] and args[0].is_a? Hash
     end
-
   end
 
   class ::Object
-
     alias_method :old_method_missing, :method_missing
 
     ["span", "para", "td", "th", "while_loading"].each do |tag|
@@ -101,7 +97,5 @@ module React
       return self.method_missing(*["br"]) if self.is_a? React::Component
       React::RenderingContext.render("span") { React::RenderingContext.render(self.to_s); React::RenderingContext.render("br") }
     end
-
   end
-
 end

data/lib/{reactive-ruby → react}/state.rb

@@ -1,9 +1,6 @@
 module React
-
   class State
-
     class << self
-
       attr_reader :current_observer
 
       def initialize_states(object, initial_values) # initialize objects' name/value pairs
@@ -17,9 +14,12 @@ module React
       end
 
       def set_state2(object, name, value)  # 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|
           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 set_state(object, name, value, delay=nil)
@@ -110,9 +110,6 @@ module React
       def observers_by_name
         @observers_by_name ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = [] } }
       end
-
     end
-
   end
-
 end

data/lib/{reactive-ruby → react}/top_level.rb

@@ -1,6 +1,6 @@
 require "native"
 require 'active_support'
-require 'reactive-ruby/component'
+require 'react/component'
 
 module React
   HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
@@ -22,7 +22,7 @@ module React
                 readOnly rel required role rows rowSpan sandbox scope scrolling seamless
                 selected shape size sizes span spellCheck src srcDoc srcSet start step style
                 tabIndex target title type useMap value width wmode dangerouslySetInnerHTML)
-  
+
   def self.create_element(type, properties = {}, &block)
     React::API.create_element(type, properties, &block)
   end
@@ -49,5 +49,4 @@ module React
   def self.unmount_component_at_node(node)
     `React.unmountComponentAtNode(node.$$class ? node[0] : node)`
   end
-  
 end

data/lib/react/validator.rb

@@ -0,0 +1,127 @@
+module React
+  class Validator
+    attr_accessor :errors
+    private :errors
+
+    def self.build(&block)
+      self.new.build(&block)
+    end
+
+    def build(&block)
+      instance_eval(&block)
+      self
+    end
+
+    def requires(name, options = {})
+      options[:required] = true
+      define_rule(name, options)
+    end
+
+    def optional(name, options = {})
+      options[:required] = false
+      define_rule(name, options)
+    end
+
+    def allow_undefined_props=(allow)
+      @allow_undefined_props = allow
+    end
+
+    def undefined_props(props)
+      self.allow_undefined_props = true
+      props.reject { |name, value| rules[name] }
+    end
+
+    def validate(props)
+      self.errors = []
+      validate_undefined(props) unless allow_undefined_props?
+      props = coerce_native_hash_values(defined_props(props))
+      validate_required(props)
+      props.each do |name, value|
+        validate_types(name, value)
+        validate_allowed(name, value)
+      end
+      errors
+    end
+
+    def default_props
+      rules
+        .select {|key, value| value.keys.include?("default") }
+        .inject({}) {|memo, (k,v)| memo[k] = v[:default]; memo}
+    end
+
+    private
+
+    def defined_props(props)
+      props.select { |name| rules.keys.include?(name) }
+    end
+
+    def allow_undefined_props?
+      !!@allow_undefined_props
+    end
+
+    def rules
+      @rules ||= { children: { required: false } }
+    end
+
+    def define_rule(name, options = {})
+      rules[name] = coerce_native_hash_values(options)
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def validate_types(prop_name, value)
+      return unless klass = rules[prop_name][:type]
+      if klass.is_a?(Array) && klass.length > 0
+        validate_value_array(prop_name, value)
+      else
+        allow_nil = !!rules[prop_name][:allow_nil]
+        type_check("`#{prop_name}`", value, klass, allow_nil)
+      end
+    end
+
+    def type_check(prop_name, value, klass, allow_nil)
+      return if allow_nil && value.nil?
+      return if value.is_a?(klass)
+      return if klass.respond_to?(:_react_param_conversion) &&
+        klass._react_param_conversion(value, :validate_only)
+      errors << "Provided prop #{prop_name} could not be converted to #{klass}"
+    end
+
+    def validate_allowed(prop_name, value)
+      return unless values = rules[prop_name][:values]
+      return if values.include?(value)
+      errors << "Value `#{value}` for prop `#{prop_name}` is not an allowed value"
+    end
+
+    def validate_required(props)
+      (rules.keys - props.keys).each do |name|
+        next unless rules[name][:required]
+        errors << "Required prop `#{name}` was not specified"
+      end
+    end
+
+    def validate_undefined(props)
+      (props.keys - rules.keys).each do |prop_name|
+        errors <<  "Provided prop `#{prop_name}` not specified in spec"
+      end
+    end
+
+    def validate_value_array(name, value)
+      klass = rules[name][:type]
+      allow_nil = !!rules[name][:allow_nil]
+      value.each_with_index do |item, index|
+        type_check("`#{name}`[#{index}]", Native(item), klass[0], allow_nil)
+      end
+    rescue NoMethodError
+      errors << "Provided prop `#{name}` was not an Array"
+    end
+
+    def coerce_native_hash_values(hash)
+      hash.each do |key, value|
+        hash[key] = Native(value)
+      end
+    end
+  end
+end