hyper-component 0.99.6 → 1.0.alpha1

data/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2015 Yi-Cheng Chang (http://github.com/zetachang)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/README.md

@@ -1,49 +0,0 @@
-<div class="githubhyperloopheader">
-
-<p align="center">
-
-<a href="http://ruby-hyperloop.org/" alt="Hyperloop" title="Hyperloop">
-<img width="350px" src="http://ruby-hyperloop.org/images/hyperloop-github-logo.png">
-</a>
-
-</p>
-
-<h2 align="center">The Complete Isomorphic Ruby Framework</h2>
-
-<br>
-
-<a href="http://ruby-hyperloop.org/" alt="Hyperloop" title="Hyperloop">
-<img src="http://ruby-hyperloop.org/images/githubhyperloopbadge.png">
-</a>
-
-<a href="https://gitter.im/ruby-hyperloop/chat" alt="Gitter chat" title="Gitter chat">
-<img src="http://ruby-hyperloop.org/images/githubgitterbadge.png">
-</a>
-
-[![Build Status](https://travis-ci.org/ruby-hyperloop/hyper-react.svg?branch=master)](https://travis-ci.org/ruby-hyperloop/hyper-react)
-[![Gem Version](https://badge.fury.io/rb/hyper-react.svg)](https://badge.fury.io/rb/hyper-react)
-
-<p align="center">
-<img src="http://ruby-hyperloop.org/images/HyperComponents.png" width="100" alt="Hyper-components">
-</p>
-
-</div>
-
-## Hyper-React GEM is part of Hyperloop GEMS family
-
-Hyper-react GEM comes with the Hyperloop GEM. 
-
-But if you want to install it separately, please install the [Hyper-component GEM](https://github.com/ruby-hyperloop/hyper-component).
-
-## Community
-
-#### Getting Help
-Please **do not post** usage questions to GitHub Issues. For these types of questions use our [Gitter chatroom](https://gitter.im/ruby-hyperloop/chat) or [StackOverflow](http://stackoverflow.com/questions/tagged/hyperloop).
-
-#### Submitting Bugs and Enhancements
-[GitHub Issues](https://github.com/ruby-hyperloop/hyperloop/issues) is for suggesting enhancements and reporting bugs. Before submiting a bug make sure you do the following:
-* Check out our [contributing guide](https://github.com/ruby-hyperloop/hyperloop/blob/master/CONTRIBUTING.md) for info on our release cycle.
-
-## License
-
-Hyperloop is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/hyper-component/jquery.rb

@@ -1,2 +0,0 @@
-require 'opal-jquery' # remove this line if you don't need jquery'
-require 'react/ext/opal-jquery/element'

data/lib/rails-helpers/top_level_rails_component.rb

@@ -1,79 +0,0 @@
-module React
-  class TopLevelRailsComponent
-    include Hyperloop::Component::Mixin
-
-    def self.search_path
-      @search_path ||= [Object]
-    end
-
-    export_component
-
-    param :component_name
-    param :controller
-    param :render_params
-
-    backtrace :off
-
-    def render
-      top_level_render
-    end
-
-    def top_level_render
-      paths_searched = []
-      component = nil
-      if params.component_name.start_with?('::')
-        # if absolute path of component is given, look it up and fail if not found
-        paths_searched << params.component_name
-        component = begin
-                      Object.const_get(params.component_name)
-                    rescue NameError
-                      nil
-                    end
-      else
-        # if relative path is given, look it up like this
-        # 1) we check each path + controller-name + component-name
-        # 2) if we can't find it there we check each path + component-name
-        # if we can't find it we just try const_get
-        # so (assuming controller name is Home)
-        # ::Foo::Bar will only resolve to some component named ::Foo::Bar
-        # but Foo::Bar will check (in this order) ::Home::Foo::Bar, ::Components::Home::Foo::Bar, ::Foo::Bar, ::Components::Foo::Bar
-        self.class.search_path.each do |scope|
-          paths_searched << "#{scope.name}::#{params.controller}::#{params.component_name}"
-          component = begin
-                        scope.const_get(params.controller, false).const_get(params.component_name, false)
-                      rescue NameError
-                        nil
-                      end
-          break if component != nil
-        end
-        unless component
-          self.class.search_path.each do |scope|
-            paths_searched << "#{scope.name}::#{params.component_name}"
-            component = begin
-                          scope.const_get(params.component_name, false)
-                        rescue NameError
-                          nil
-                        end
-            break if component != nil
-          end
-        end
-      end
-      return React::RenderingContext.render(component, params.render_params) if component && component.method_defined?(:render)
-      raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
-    end
-  end
-end
-
-class Module
-  def add_to_react_search_path(replace_search_path = nil)
-    if replace_search_path
-      React::TopLevelRailsComponent.search_path = [self]
-    elsif !React::TopLevelRailsComponent.search_path.include? self
-      React::TopLevelRailsComponent.search_path << self
-    end
-  end
-end
-
-module Components
-  add_to_react_search_path
-end

data/lib/react/api.rb

@@ -1,272 +0,0 @@
-require 'react/native_library'
-
-module React
-  # Provides the internal mechanisms to interface between reactrb and native components
-  # the code will attempt to create a js component wrapper on any rb class that has a
-  # render (or possibly _render_wrapper) method.  The mapping between rb and js components
-  # is kept in the @@component_classes hash.
-
-  # Also provides the mechanism to build react elements
-
-  # TOOO - the code to deal with components should be moved to a module that will be included
-  # in a class which will then create the JS component for that class.  That module will then
-  # be included in React::Component, but can be used by any class wanting to become a react
-  # component (but without other DSL characteristics.)
-  class API
-    @@component_classes = {}
-
-    def self.import_native_component(opal_class, native_class)
-      opal_class.instance_variable_set("@native_import", true)
-      @@component_classes[opal_class] = native_class
-    end
-
-    def self.eval_native_react_component(name)
-      component = `eval(name)`
-      raise "#{name} is not defined" if `#{component} === undefined`
-      is_component_class = `#{component}.prototype !== undefined` &&
-                            (`!!#{component}.prototype.isReactComponent` ||
-                             `!!#{component}.prototype.render`)
-      is_functional_component = `typeof #{component} === "function"`
-      unless is_component_class || is_functional_component
-        raise 'does not appear to be a native react component'
-      end
-      component
-    end
-
-    def self.native_react_component?(name = nil)
-      return false unless name
-      eval_native_react_component(name)
-    rescue
-      nil
-    end
-
-    def self.add_after_error_hook(klass)
-      add_after_error_hook_to_native(@@component_classes[klass])
-    end
-
-    def self.add_after_error_hook_to_native(native_comp)
-      return unless native_comp
-      %x{
-        native_comp.prototype.componentDidCatch = function(error, info) {
-          this.__opalInstanceSyncSetState = false;
-          this.__opalInstance.$component_did_catch(error, Opal.Hash.$new(info));
-        }
-      }
-    end
-
-    def self.create_native_react_class(type)
-      raise "Provided class should define `render` method"  if !(type.method_defined? :render)
-      render_fn = (type.method_defined? :_render_wrapper) ? :_render_wrapper : :render
-      # this was hashing type.to_s, not sure why but .to_s does not work as it Foo::Bar::View.to_s just returns "View"
-
-      @@component_classes[type] ||= begin
-        comp = %x{
-          class extends React.Component {
-            constructor(props) {
-              super(props);
-              this.mixins = #{type.respond_to?(:native_mixins) ? type.native_mixins : `[]`};
-              this.statics = #{type.respond_to?(:static_call_backs) ? type.static_call_backs.to_n : `{}`};
-              this.state = {};
-              this.__opalInstanceInitializedState = false;
-              this.__opalInstanceSyncSetState = true;
-              this.__opalInstance = #{type.new(`this`)};
-              this.__opalInstanceInitializedState = true;
-              this.__opalInstanceSyncSetState = false;
-              this.__name = #{type.name};
-            }
-            static get displayName() {
-              if (typeof this.__name != "undefined") {
-                return this.__name;
-              } else {
-                return #{type.name};
-              }
-            }
-            static set displayName(name) {
-              this.__name = name;
-            }
-            static get defaultProps() {
-              return #{type.respond_to?(:default_props) ? type.default_props.to_n : `{}`};
-            }
-            static get propTypes() {
-              return  #{type.respond_to?(:prop_types) ? type.prop_types.to_n : `{}`};
-            }
-            componentWillMount() {
-              if (#{type.method_defined? :component_will_mount}) {
-                this.__opalInstanceSyncSetState = true;
-                this.__opalInstance.$component_will_mount();
-                this.__opalInstanceSyncSetState = false;
-              }
-            }
-            componentDidMount() {
-              this.__opalInstance.is_mounted = true
-              if (#{type.method_defined? :component_did_mount}) {
-                this.__opalInstanceSyncSetState = false;
-                this.__opalInstance.$component_did_mount();
-              }
-            }
-            componentWillReceiveProps(next_props) {
-              if (#{type.method_defined? :component_will_receive_props}) {
-                this.__opalInstanceSyncSetState = true;
-                this.__opalInstance.$component_will_receive_props(Opal.Hash.$new(next_props));
-                this.__opalInstanceSyncSetState = false;
-              }
-            }
-            shouldComponentUpdate(next_props, next_state) {
-              if (#{type.method_defined? :should_component_update?}) {
-                this.__opalInstanceSyncSetState = false;
-                return this.__opalInstance["$should_component_update?"](Opal.Hash.$new(next_props), Opal.Hash.$new(next_state));
-              } else { return true; }
-            }
-            componentWillUpdate(next_props, next_state) {
-              if (#{type.method_defined? :component_will_update}) {
-                this.__opalInstanceSyncSetState = false;
-                this.__opalInstance.$component_will_update(Opal.Hash.$new(next_props), Opal.Hash.$new(next_state));
-              }
-            }
-            componentDidUpdate(prev_props, prev_state) {
-              if (#{type.method_defined? :component_did_update}) {
-                this.__opalInstanceSyncSetState = false;
-                this.__opalInstance.$component_did_update(Opal.Hash.$new(prev_props), Opal.Hash.$new(prev_state));
-              }
-            }
-            componentWillUnmount() {
-              if (#{type.method_defined? :component_will_unmount}) {
-                this.__opalInstanceSyncSetState = false;
-                this.__opalInstance.$component_will_unmount();
-              }
-              this.__opalInstance.is_mounted = false;
-            }
-
-            render() {
-              this.__opalInstanceSyncSetState = false;
-              return this.__opalInstance.$send(render_fn).$to_n();
-            }
-          }
-        }
-        # check to see if there is an after_error callback.  If there is add a
-        # componentDidCatch handler. Because legacy behavior is to allow any object
-        # that responds to render to act as a component we have to make sure that
-        # we have a callbacks_for method.  This all becomes much easier once issue
-        # #270 is resolved.
-        if type.respond_to?(:callbacks_for) && type.callbacks_for(:after_error) != []
-          add_after_error_hook_to_native comp
-        end
-        comp
-      end
-    end
-
-    def self.create_element(type, *args, &block)
-      params = []
-
-      # Component Spec, Normal DOM, String or Native Component
-      ncc = @@component_classes[type]
-      if ncc
-        params << ncc
-      elsif type.is_a?(Class)
-        params << create_native_react_class(type)
-      elsif block_given? || React::Component::Tags::HTML_TAGS.include?(type)
-        params << type
-      elsif type.is_a?(String)
-        return React::Element.new(type)
-      else
-        raise "#{type} not implemented"
-      end
-
-      # Convert Passed in properties
-      properties = convert_props(args)
-      params << properties.shallow_to_n
-
-      # Children Nodes
-      if block_given?
-        a = [yield].flatten
-        %x{
-          for(var i=0, l=a.length; i<l; i++) {
-            params.push(a[i].$to_n());
-          }
-        }
-      end
-      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(args)
-      # merge args together into a single properties hash
-      properties = {}
-      args.each do |arg|
-        if arg.is_a? String
-          properties[arg] = true
-        elsif arg.is_a? Hash
-          arg.each do |key, value|
-            if ['class', 'className', 'class_name'].include? key
-              next unless value
-
-              if value.is_a?(String)
-                value = value.split(' ')
-              elsif !value.is_a?(Array)
-                raise "The class param must be a string or array of strings"
-              end
-
-              properties['className'] = [*properties['className'], *value]
-            elsif key == 'style'
-              next unless value
-
-              if !value.is_a?(Hash)
-                raise "The style param must be a Hash"
-              end
-
-              properties['style'] = (properties['style'] || {}).merge(value)
-            elsif React::HASH_ATTRIBUTES.include?(key) && value.is_a?(Hash)
-              properties[key] = (properties[key] || {}).merge(value)
-            else
-              properties[key] = value
-            end
-          end
-        end
-      end
-      # process properties according to react rules
-      props = {}
-      properties.each do |key, value|
-        if ["style", "dangerously_set_inner_HTML"].include? key
-          props[lower_camelize(key)] = value.to_n
-
-        elsif key == "className"
-          props[key] = value.join(' ')
-
-        elsif key == "key"
-          props["key"] = value.to_key
-
-        elsif key == 'ref' && value.respond_to?(:call)
-          # currently react still accepts the syntax ref: :foo meaning set refs.foo to the ref.
-          # in hyperstack release 0.1 we can put this behavior on a switch or use the notation `ref_key: :foo` for old school
-          props[key] = %x{
-                          function(dom_node){
-                            if (dom_node !== null && dom_node.__opalInstance !== undefined && dom_node.__opalInstance !== null) {
-                              #{ value.call(`dom_node.__opalInstance`) };
-                            } else if(dom_node !== null && ReactDOM.findDOMNode !== undefined && dom_node.nodeType === undefined) {
-                              #{ value.call(`ReactDOM.findDOMNode(dom_node)`) };
-                            } else {
-                              #{ value.call(`dom_node`) };
-                            }
-                          }
-                        }
-        elsif React::HASH_ATTRIBUTES.include?(key) && value.is_a?(Hash)
-          value.each { |k, v| props["#{key}-#{k.gsub(/__|_/, '__' => '_', '_' => '-')}"] = v.to_n }
-        else
-          props[React.html_attr?(lower_camelize(key)) ? lower_camelize(key) : key] = value
-        end
-      end
-      props
-    end
-
-    private
-
-    def self.lower_camelize(snake_cased_word)
-      words = snake_cased_word.split('_')
-      result = [words.first]
-      result.concat(words[1..-1].map {|word| word[0].upcase + word[1..-1] }).join('')
-    end
-  end
-end

data/lib/react/callbacks.rb

@@ -1,42 +0,0 @@
-require 'hyperloop-config'
-
-module React
-  module Callbacks
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    def run_callback(name, *args)
-      self.class.callbacks_for(name).each do |callback|
-        if callback.is_a?(Proc)
-          instance_exec(*args, &callback)
-        else
-          send(callback, *args)
-        end
-      end
-    end
-
-    module ClassMethods
-      def define_callback(callback_name, &after_define_hook)
-        wrapper_name = "_#{callback_name}_callbacks"
-        define_singleton_method(wrapper_name) do
-          Hyperloop::Context.set_var(self, "@#{wrapper_name}", force: true) { [] }
-        end
-        define_singleton_method(callback_name) do |*args, &block|
-          send(wrapper_name).concat(args)
-          send(wrapper_name).push(block) if block_given?
-          after_define_hook.call(*args, &block) if after_define_hook
-        end
-      end
-
-      def callbacks_for(callback_name)
-        wrapper_name = "_#{callback_name}_callbacks"
-        if superclass.respond_to? :callbacks_for
-          superclass.callbacks_for(callback_name)
-        else
-          []
-        end + send(wrapper_name)
-      end
-    end
-  end
-end