resolution.rb in isomorfeus-react-16.13.12

- old
+ new
@@ -1,97 +1,97 @@
-module React
-  module Component
-    module Resolution
-      def self.included(base)
-        base.instance_exec do
-          unless method_defined?(:_react_component_class_resolution_original_const_missing)
-            alias _react_component_class_resolution_original_const_missing const_missing
-          end
-
-          def const_missing(const_name)
-            %x{
-              if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
-                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
-                new_const.react_component = Opal.global[const_name];
-                #{Object.const_set(const_name, `new_const`)};
-                return new_const;
-              } else {
-                return #{_react_component_class_resolution_original_const_missing(const_name)};
-              }
-            }
-          end
-
-          # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
-          # must load it first, done by const_get, and next time the method will be there.
-          unless method_defined?(:_react_component_class_resolution_original_method_missing)
-            alias _react_component_class_resolution_original_method_missing method_missing
-          end
-
-          def method_missing(component_name, *args, &block)
-            # check for ruby component and render it
-            # otherwise pass on method missing
-            %x{
-              var constant;
-              if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
-              try {
-                if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
-                  constant = self.iso_react_const_cache[component_name]
-                } else {
-                  constant = self.$const_get(component_name);
-                  self.iso_react_const_cache[component_name] = constant;
-                }
-                if (typeof constant.react_component !== 'undefined') {
-                  return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
-                }
-              } catch(err) { }
-              return #{_react_component_class_resolution_original_method_missing(component_name, *args, block)};
-            }
-          end
-        end
-      end
-
-      unless method_defined?(:_react_component_resolution_original_method_missing)
-        alias _react_component_resolution_original_method_missing method_missing
-      end
-
-      def method_missing(component_name, *args, &block)
-        # Further on it must check for modules, because $const_get does not take
-        # the full nesting into account, as usually its called via $$ with the
-        # nesting provided by the compiler.
-        %x{
-          var constant;
-          if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
-
-          if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
-            constant = self.iso_react_const_cache[component_name]
-          } else if (typeof self.$$is_a_module !== 'undefined') {
-            try {
-              constant = self.$const_get(component_name);
-              self.iso_react_const_cache[component_name] = constant;
-            } catch(err) { }
-          } else {
-            let sc = self.$class();
-            try {
-              constant = sc.$const_get(component_name);
-              self.iso_react_const_cache[component_name] = constant;
-            } catch(err) {
-              var module_names = sc.$to_s().split("::");
-              var module_name;
-              for (var i = module_names.length - 1; i > 0; i--) {
-                module_name = module_names.slice(0, i).join('::');
-                try {
-                  constant = sc.$const_get(module_name).$const_get(component_name, false);
-                  self.iso_react_const_cache[component_name] = constant;
-                  break;
-                } catch(err) { }
-              }
-            }
-          }
-          if (constant && typeof constant.react_component !== 'undefined') {
-            return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
-          }
-          return #{_react_component_resolution_original_method_missing(component_name, *args, block)};
-        }
-      end
-    end
-  end
-end
+module React
+  module Component
+    module Resolution
+      def self.included(base)
+        base.instance_exec do
+          unless method_defined?(:_react_component_class_resolution_original_const_missing)
+            alias _react_component_class_resolution_original_const_missing const_missing
+          end
+
+          def const_missing(const_name)
+            %x{
+              if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
+                var new_const = #{React::NativeConstantWrapper.new(`Opal.global[const_name]`, const_name)};
+                new_const.react_component = Opal.global[const_name];
+                #{Object.const_set(const_name, `new_const`)};
+                return new_const;
+              } else {
+                return #{_react_component_class_resolution_original_const_missing(const_name)};
+              }
+            }
+          end
+
+          # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
+          # must load it first, done by const_get, and next time the method will be there.
+          unless method_defined?(:_react_component_class_resolution_original_method_missing)
+            alias _react_component_class_resolution_original_method_missing method_missing
+          end
+
+          def method_missing(component_name, *args, &block)
+            # check for ruby component and render it
+            # otherwise pass on method missing
+            %x{
+              var constant;
+              if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
+              try {
+                if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
+                  constant = self.iso_react_const_cache[component_name]
+                } else {
+                  constant = self.$const_get(component_name);
+                  self.iso_react_const_cache[component_name] = constant;
+                }
+                if (typeof constant.react_component !== 'undefined') {
+                  return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
+                }
+              } catch(err) { }
+              return #{_react_component_class_resolution_original_method_missing(component_name, *args, block)};
+            }
+          end
+        end
+      end
+
+      unless method_defined?(:_react_component_resolution_original_method_missing)
+        alias _react_component_resolution_original_method_missing method_missing
+      end
+
+      def method_missing(component_name, *args, &block)
+        # Further on it must check for modules, because $const_get does not take
+        # the full nesting into account, as usually its called via $$ with the
+        # nesting provided by the compiler.
+        %x{
+          var constant;
+          if (typeof self.iso_react_const_cache === 'undefined') { self.iso_react_const_cache = {}; }
+
+          if (typeof self.iso_react_const_cache[component_name] !== 'undefined') {
+            constant = self.iso_react_const_cache[component_name]
+          } else if (typeof self.$$is_a_module !== 'undefined') {
+            try {
+              constant = self.$const_get(component_name);
+              self.iso_react_const_cache[component_name] = constant;
+            } catch(err) { }
+          } else {
+            let sc = self.$class();
+            try {
+              constant = sc.$const_get(component_name);
+              self.iso_react_const_cache[component_name] = constant;
+            } catch(err) {
+              var module_names = sc.$to_s().split("::");
+              var module_name;
+              for (var i = module_names.length - 1; i > 0; i--) {
+                module_name = module_names.slice(0, i).join('::');
+                try {
+                  constant = sc.$const_get(module_name).$const_get(component_name, false);
+                  self.iso_react_const_cache[component_name] = constant;
+                  break;
+                } catch(err) { }
+              }
+            }
+          }
+          if (constant && typeof constant.react_component !== 'undefined') {
+            return Opal.React.internal_prepare_args_and_render(constant.react_component, args, block);
+          }
+          return #{_react_component_resolution_original_method_missing(component_name, *args, block)};
+        }
+      end
+    end
+  end
+end