reactrb 0.8.3 → 0.8.4

data/lib/react/component/dsl_instance_methods.rb

@@ -0,0 +1,57 @@
+module React
+  module Component
+    module DslInstanceMethods
+      def children
+        if `#{@native}.props.children==undefined`
+          nodes = []
+        else
+          nodes = [`#{@native}.props.children`].flatten
+        end
+        class << nodes
+          include Enumerable
+
+          def to_n
+            self
+          end
+
+          def each(&block)
+            if block_given?
+              %x{
+                    React.Children.forEach(#{self.to_n}, function(context){
+              #{yield React::Element.new(`context`)}
+                    })
+              }
+              nil
+            else
+              Enumerator.new(`React.Children.count(#{self.to_n})`) do |y|
+                %x{
+                      React.Children.forEach(#{self.to_n}, function(context){
+                #{y << Element.new(`context`)}
+                      })
+                }
+              end
+            end
+          end
+        end
+
+        nodes
+      end
+
+      def params
+        @props_wrapper
+      end
+
+      def props
+        Hash.new(`#{@native}.props`)
+      end
+
+      def refs
+        Hash.new(`#{@native}.refs`)
+      end
+
+      def state
+        @state_wrapper ||= StateWrapper.new(@native, self)
+      end
+    end
+  end
+end

data/lib/react/component/props_wrapper.rb

@@ -1,5 +1,11 @@
 module React
   module Component
+
+    def deprecated_params_method(name, *args, &block)
+      React::Component.deprecation_warning"Direct access to param `#{name}`.  Use `params.#{name}` instead."
+      params.send(name, *args, &block)
+    end
+
     class PropsWrapper
       attr_reader :props
 

data/lib/react/component/tags.rb

@@ -0,0 +1,96 @@
+module React
+  module Component
+    # contains the name of all HTML tags, and the mechanism to register a component
+    # class as a new tag
+    module Tags
+      HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
+                     button canvas caption cite code col colgroup data datalist dd del details dfn
+                     dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5
+                     h6 head header hr html i iframe img input ins kbd keygen label legend li link
+                     main map mark menu menuitem meta meter nav noscript object ol optgroup option
+                     output p param picture pre progress q rp rt ruby s samp script section select
+                     small source span strong style sub summary sup table tbody td textarea tfoot th
+                     thead time title tr track u ul var video wbr)
+
+      # note: any tag can end in _as_node but this is deprecated
+
+      # the present method is retained as a legacy behavior
+
+      def present(component, *params, &children)
+        React::RenderingContext.render(component, *params, &children)
+      end
+
+      def present_as_node(component, *params, &children)
+        React::RenderingContext.build_only(component, *params, &children)
+      end
+
+      # define each predefined tag as an instance method
+
+      HTML_TAGS.each do |tag|
+        define_method(tag) do |*params, &children|
+          React::RenderingContext.render(tag, *params, &children)
+        end
+        alias_method tag.upcase, tag
+        const_set tag.upcase, tag
+        # handle deprecated _as_node style
+        define_method("#{tag}_as_node") do |*params, &children|
+          React::RenderingContext.build_only(tag, *params, &children)
+        end
+      end
+
+      # use method_missing to look up component names in the form of "Foo(..)"
+      # where there is no preceeding scope.
+
+      def method_missing(name, *params, &children)
+        if name =~ /_as_node$/
+          # handle deprecated _as_node style
+          component = find_component(name.gsub(/_as_node$/, ''))
+          return React::RenderingContext.build_only(component, *params, &children) if component
+        else
+          component = find_component(name)
+          return React::RenderingContext.render(component, *params, &children) if component
+        end
+        Object.method_missing(name, *params, &children)
+      end
+
+      # install methods with the same name as the component in the parent class/module
+      # thus component names in the form Foo::Bar(...) will work
+
+      class << self
+        def included(component)
+          _name, parent = find_name_and_parent(component)
+          class << parent
+            define_method _name do |*params, &children|
+              React::RenderingContext.render(component, *params, &children)
+            end
+            # handle deprecated _as_node style
+            define_method "#{_name}_as_node" do |*params, &children|
+              React::RenderingContext.build_only(component, *params, &children)
+            end
+          end
+        end
+
+        private
+
+        def find_name_and_parent(component)
+          split_name = component.name && component.name.split('::')
+          if split_name && split_name.length > 1
+            [split_name.last, split_name.inject([Module]) { |a, e| a + [a.last.const_get(e)] }[-2]]
+          end
+        end
+      end
+
+      private
+
+      def find_component(name)
+        scopes = self.class.name.split('::').inject([Module]) do |nesting, next_const|
+          nesting + [nesting.last.const_get(next_const)]
+        end.reverse
+        scope = scopes.detect { |s| s.const_defined?(name) } || return
+        component = scope.const_get(name)
+        return component if component.method_defined?(:render)
+        raise "#{name} does not appear to be a react component."
+      end
+    end
+  end
+end

data/lib/react/native_library.rb

@@ -1,53 +1,90 @@
 module React
-  class NativeLibrary
-    def self.renames_and_exclusions
-      @renames_and_exclusions ||= {}
-    end
+  # NativeLibrary handles importing JS libraries. Importing native components is handled
+  # by the React::Base.  It also provides several methods used by auto-import.rb
 
-    def self.libraries
-      @libraries ||= []
-    end
+  # 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.
 
-    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`
+  # 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
-        name
       end
-    end
 
-    def self.method_missing(n, *args, &block)
-      name = n
-      if name =~ /_as_node$/
-        node_only = true
-        name = name.gsub(/_as_node$/, "")
+      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
-      unless name = const_get(name)
-        return super
+
+      def const_missing(const_name)
+        import_const_from_native(self, const_name, true) || super
       end
-      React::RenderingContext.build_or_render(node_only, name, *args, &block)
-    rescue
-    end
 
-    def self.imports(library)
-      libraries << library
-    end
+      def method_missing(method_name, *args, &block)
+        method = method_name.gsub(/_as_node$/, '')  # remove once _as_node is deprecated.
+        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
+        if method == method_name
+          React::RenderingContext.render(component_class, *args, &block)
+        else # remove once _as_node is deprecated.
+          React::RenderingContext.build_only(component_class, *args, &block)
+        end
+      end
 
-    def self.rename(rename_list={})
-      renames_and_exclusions.merge!(rename_list.invert)
-    end
+      private
 
-    def self.exclude(*exclude_list)
-      renames_and_exclusions.merge(Hash[exclude_list.map {|k| [k, nil]}])
+      def lookup_native_name(js_name)
+        native_name = scope_native_name(js_name)
+        `eval(#{native_name}) !== undefined && native_name`
+      rescue
+        nil
+      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 React::Component
+            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/rendering_context.rb

@@ -4,12 +4,11 @@ module React
       attr_accessor :waiting_on_resources
     end
 
-    def self.build_or_render(node_only, name, *args, &block)
-      if node_only
-        React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
-      else
-        React::RenderingContext.render(name, *args, &block)
-      end
+    def self.build_only(name, *args, &block)
+      React::Component.deprecation_warning(
+        '..._as_node is deprecated.  Render component and then use the .node method instead'
+      )
+      React::RenderingContext.build { React::RenderingContext.render(name, *args, &block) }.to_n
     end
 
     def self.render(name, *args, &block)
@@ -55,15 +54,12 @@ module React
       element
     end
 
-    def self.build(&block)
+    def self.build
       current = @buffer
       @buffer = []
       return_val = yield @buffer
       @buffer = current
       return_val
-    #ensure
-    #  @buffer = current
-    #  return_val
     end
 
     def self.as_node(element)
@@ -71,7 +67,7 @@ module React
       element
     end
 
-    class << self; alias_method :delete, :as_node; end
+    class << self; alias delete as_node; end
 
     def self.replace(e1, e2)
       @buffer[@buffer.index(e1)] = e2
@@ -85,24 +81,26 @@ module React
   end
 
   class ::Object
-
-    ["span", "td", "th", "while_loading"].each do |tag|
-      define_method(tag) do | *args, &block |
+    [:span, :td, :th, :while_loading].each do |tag|
+      define_method(tag) do |*args, &block|
         args.unshift(tag)
-        return self.method_missing(*args, &block) if self.is_a? React::Component
-        React::RenderingContext.render(*args) { self.to_s }
+        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 self.method_missing(*args, &block) if self.is_a? React::Component
-      React::RenderingContext.render(*args) { self.to_s }
+      args.unshift(:p)
+      return send(*args, &block) if is_a? React::Component
+      React::RenderingContext.render(*args) { to_s }
     end
 
     def br
-      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") }
+      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

data/lib/react/top_level.rb

@@ -3,25 +3,20 @@ require 'active_support'
 require 'react/component/base'
 
 module React
-  HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
-                button canvas caption cite code col colgroup data datalist dd del details dfn
-                dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5
-                h6 head header hr html i iframe img input ins kbd keygen label legend li link
-                main map mark menu menuitem meta meter nav noscript object ol optgroup option
-                output p param picture pre progress q rp rt ruby s samp script section select
-                small source span strong style sub summary sup table tbody td textarea tfoot th
-                thead time title tr track u ul var video wbr)
+
   ATTRIBUTES = %w(accept acceptCharset accessKey action allowFullScreen allowTransparency alt
-                async autoComplete autoPlay cellPadding cellSpacing charSet checked classID
-                className cols colSpan content contentEditable contextMenu controls coords
-                crossOrigin data dateTime defer dir disabled download draggable encType form
-                formAction formEncType formMethod formNoValidate formTarget frameBorder height
-                hidden href hrefLang htmlFor httpEquiv icon id label lang list loop manifest
-                marginHeight marginWidth max maxLength media mediaGroup method min multiple
-                muted name noValidate open pattern placeholder poster preload radioGroup
-                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)
+                  async autoComplete autoPlay cellPadding cellSpacing charSet checked classID
+                  className cols colSpan content contentEditable contextMenu controls coords
+                  crossOrigin data dateTime defer dir disabled download draggable encType form
+                  formAction formEncType formMethod formNoValidate formTarget frameBorder height
+                  hidden href hrefLang htmlFor httpEquiv icon id label lang list loop manifest
+                  marginHeight marginWidth max maxLength media mediaGroup method min multiple
+                  muted name noValidate open pattern placeholder poster preload radioGroup
+                  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)
+
+  HASH_ATTRIBUTES = %w(data aria)
 
   def self.create_element(type, properties = {}, &block)
     React::API.create_element(type, properties, &block)
@@ -78,11 +73,6 @@ module React
 end
 
 Element.instance_eval do
-  class Element
-    class DummyContext < React::Component::Base
-    end
-  end
-
   def self.find(selector)
     selector = begin
       selector.dom_node
@@ -96,11 +86,11 @@ Element.instance_eval do
     find(selector)
   end
 
-  define_method :render do |&block|
-    React.render(
-      React::RenderingContext.render(nil) do
-        ::Element::DummyContext.new.instance_eval(&block)
-      end, self
-    )
+  define_method :render do |container = nil, params = {}, &block|
+    klass = Class.new(React::Component::Base)
+    klass.class_eval do
+      render(container, params, &block)
+    end
+    React.render(React.create_element(klass), self)
   end
 end if Object.const_defined?('Element')

data/lib/reactive-ruby/rails/component_mount.rb

@@ -10,7 +10,9 @@ module ReactiveRuby
       def react_component(name, props = {}, options = {}, &block)
         options = context_initializer_options(options, name) if options[:prerender]
         props = serialized_props(props, name, controller)
-        super(top_level_name, props, options, &block) + footers
+        super(top_level_name, props, options, &block).gsub("\n","")
+          .gsub(/(<script>.*<\/script>)<\/div>$/,'</div>\1').html_safe +
+          footers
       end
 
       private