closes #157 closes #158

fixed multiple haml classes not working

# Conflicts:
#	spec/react/dsl_spec.rb

Author: catmando

lib/react/api.rb

@@ -104,36 +104,42 @@ def self.create_element(type, properties = {}, &block)
         params << create_native_react_class(type)
       elsif React::Component::Tags::HTML_TAGS.include?(type)
         params << type
+        html_tag = true
       elsif type.is_a? String
         return React::Element.new(type)
       else
         raise "#{type} not implemented"
       end
 
-      # Passed in properties
-      params << convert_props(properties)
+      # Convert Passed in properties
+      properties = convert_props(properties, html_tag)
+      params << properties.shallow_to_n
 
       # Children Nodes
       if block_given?
-        children = [yield].flatten.each do |ele|
+        [yield].flatten.each do |ele|
           params << ele.to_n
         end
       end
-      return React::Element.new(`React.createElement.apply(null, #{params})`, type, properties, block)
+      React::Element.new(`React.createElement.apply(null, #{params})`, type, properties, block)
     end
 
     def self.clear_component_class_cache
       @@component_classes = {}
     end
 
-    def self.convert_props(properties)
+    def self.convert_props(properties, html_tag)
       raise "Component parameters must be a hash. Instead you sent #{properties}" unless properties.is_a? Hash
       props = {}
+      updated = false
       properties.map do |key, value|
         if key == "class_name" && value.is_a?(Hash)
           props[lower_camelize(key)] = `React.addons.classSet(#{value.to_n})`
         elsif key == "class"
           props["className"] = value
+        elsif key == 'value' && value.nil? && html_tag
+          updated = true
+          props['value'] = ''
         elsif ["style", "dangerously_set_inner_HTML"].include? key
           props[lower_camelize(key)] = value.to_n
         elsif React::HASH_ATTRIBUTES.include?(key) && value.is_a?(Hash)
@@ -142,16 +148,16 @@ def self.convert_props(properties)
           props[React.html_attr?(lower_camelize(key)) ? lower_camelize(key) : key] = value
         end
       end
-      props.shallow_to_n
+      props
     end
 
     private
 
     def self.lower_camelize(snake_cased_word)
-      words = snake_cased_word.split("_")
+      words = snake_cased_word.split('_')
       result = [words.first]
       result.concat(words[1..-1].map {|word| word[0].upcase + word[1..-1] })
-      result.join("")
+      result.join('')
     end
   end
 end

lib/react/element.rb

@@ -48,11 +48,10 @@ def render(props = {})
       if props.empty?
         React::RenderingContext.render(self)
       else
+        props = API.convert_props(props)
         React::RenderingContext.render(
-          Element.new(
-            `React.cloneElement(#{to_n}, #{API.convert_props(props)})`,
-            type, properties.merge(props), block
-          )
+          Element.new(`React.cloneElement(#{to_n}, #{props.shallow_to_n})`,
+                      type, properties.merge(props), block)
         )
       end
     end
@@ -80,8 +79,8 @@ def as_node
     def method_missing(class_name, args = {}, &new_block)
       class_name = class_name.gsub(/__|_/, '__' => '_', '_' => '-')
       new_props = properties.dup
-      new_props[:class] = "\
-        #{class_name} #{new_props[:class]} #{args.delete(:class)} #{args.delete(:className)}\
+      new_props[:className] = "\
+        #{class_name} #{new_props[:className]} #{args.delete(:class)} #{args.delete(:className)}\
       ".split(' ').uniq.join(' ')
       new_props.merge! args
       React::RenderingContext.replace(

spec/react/dsl_spec.rb

@@ -56,7 +56,32 @@ def render
     expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<div>hello</div>')
   end
 
-  it "can use the upcase version of builtin tags" do
+  it "will pass the empty string for the value attribute" do
+    stub_const 'Foo', Class.new
+    Foo.class_eval do
+      include React::Component
+      def render
+        INPUT(value: nil).on(:change) {}
+      end
+    end
+
+    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<input value=""/>')
+  end
+
+
+  it "will pass converted props through event handlers" do
+    stub_const 'Foo', Class.new
+    Foo.class_eval do
+      include React::Component
+      def render
+        INPUT(data: {foo: 12}).on(:change) {}
+      end
+    end
+
+    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<input data-foo="12"/>')
+  end
+
+  it "will turn the last string in a block into a element" do
     stub_const 'Foo', Class.new
     Foo.class_eval do
       include React::Component
@@ -190,11 +215,11 @@ def render
     stub_const 'Foo', Class.new(React::Component::Base)
     Foo.class_eval do
       def render
-        Mod::Bar().the_class
+        Mod::Bar().the_class.other_class
       end
     end
 
-    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<span class="the-class">a man walks into a bar</span>')
+    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<span class="other-class the-class">a man walks into a bar</span>')
   end
 
   it "can use the 'class' keyword for classes" do
@@ -214,11 +239,11 @@ def render
     Foo.class_eval do
       include React::Component
       def render
-        span { "hello".span.as_node.class.name }.as_node.render
+        span(data: {size: 12}) { "hello".span.as_node.class.name }.as_node.render
       end
     end
 
-    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<span>React::Element</span>')
+    expect(React.render_to_static_markup(React.create_element(Foo))).to eq('<span data-size="12">React::Element</span>')
   end
 
   it "can use the dangerously_set_inner_HTML param" do