hyperloop-config 0.9.11 → 0.99.0

data/Rakefile

@@ -1,2 +1,11 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  task :prepare do
+  end
+end
+
 task :default => :spec

data/hyperloop-config.gemspec

@@ -1,37 +1,43 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hyperloop/config/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "hyperloop-config"
-  spec.version       = "0.9.11"
-  spec.authors       = ["catmando"]
-  spec.email         = ["mitch@catprint.com"]
-
+  spec.name          = 'hyperloop-config'
+  spec.version       = Hyperloop::Config::VERSION
+  spec.authors       = ['Mitch VanDuyn', 'Jan Biedermann']
+  spec.email         = ['mitch@catprint.com', 'jan@kursator.com']
   spec.summary       = %q{Provides a single point configuration module for hyperloop gems}
-  spec.homepage      = "http://ruby-hyperloop.io"
-  spec.license       = "MIT"
+  spec.homepage      = 'http://ruby-hyperloop.org'
+  spec.license       = 'MIT'
+  # spec.metadata      = {
+  #   "homepage_uri" => 'http://ruby-hyperloop.org',
+  #   "source_code_uri" => 'https://github.com/ruby-hyperloop/hyper-component'
+  # }
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency 'opal'
-  spec.add_dependency 'opal-browser'
-
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
-
-  spec.add_development_dependency 'hyper-spec'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'timecop'
-  spec.add_development_dependency 'opal-rails'
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'libv8', '~> 6.3.0' # see https://github.com/discourse/mini_racer/issues/92
+  spec.add_dependency 'mini_racer', '~> 0.1.15'
+  spec.add_dependency 'opal', '>= 0.11.0', '< 0.12.0'
+  spec.add_dependency 'opal-browser', '~> 0.2.0'
+  spec.add_dependency 'uglifier'
+
+
+  spec.add_development_dependency 'bundler', '~> 1.16.0'
+  spec.add_development_dependency 'chromedriver-helper'
+  spec.add_development_dependency 'hyper-spec', Hyperloop::Config::VERSION
+  spec.add_development_dependency 'opal-rails', '~> 0.9.4'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'puma'
+  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.7.0'
+  spec.add_development_dependency 'rubocop', '~> 0.51.0'
   spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'rails'
-  spec.add_development_dependency 'jquery-rails'
-
-  # Keep linter-rubocop happy
-  spec.add_development_dependency 'rubocop'
-
+  spec.add_development_dependency 'timecop', '~> 0.8.1'
 end

data/lib/hyperloop/active_support_string_inquirer.rb

@@ -0,0 +1,32 @@
+module ActiveSupport
+  # Wrapping a string in this class gives you a prettier way to test
+  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
+  # in a StringInquirer object, so instead of calling this:
+  #
+  #   Rails.env == 'production'
+  #
+  # you can call this:
+  #
+  #   Rails.env.production?
+  #
+  # == Instantiating a new StringInquirer
+  #
+  #   vehicle = ActiveSupport::StringInquirer.new('car')
+  #   vehicle.car?   # => true
+  #   vehicle.bike?  # => false
+  class StringInquirer < String
+    private
+
+      def respond_to_missing?(method_name, include_private = false)
+        (method_name[-1] == "?") || super
+      end
+
+      def method_missing(method_name, *arguments)
+        if method_name[-1] == "?"
+          self == method_name[0..-2]
+        else
+          super
+        end
+      end
+  end
+end

data/lib/hyperloop/autoloader.rb

@@ -0,0 +1,138 @@
+require 'set'
+
+module Hyperloop
+  class Autoloader
+    # All files ever loaded.
+    def self.history=(a)
+      @@history = a
+    end
+    def self.history
+      @@history
+    end
+    self.history = Set.new
+
+    def self.load_paths=(a)
+      @@load_paths = a
+    end
+    def self.load_paths
+      @@load_paths
+    end
+    self.load_paths = []
+
+    def self.loaded=(a)
+      @@loaded = a
+    end
+    def self.loaded
+      @@loaded
+    end
+    self.loaded = Set.new
+
+    def self.loading=(a)
+      @@loading = a
+    end
+    def self.loading
+      @@loading
+    end
+    self.loading = []
+
+    def self.const_missing(const_name, mod)
+      # name.nil? is testing for anonymous
+      from_mod = mod.name.nil? ? guess_for_anonymous(const_name) : mod
+      load_missing_constant(from_mod, const_name)
+    end
+
+    def self.guess_for_anonymous(const_name)
+      if Object.const_defined?(const_name)
+        raise NameError.new "#{const_name} cannot be autoloaded from an anonymous class or module", const_name
+      else
+        Object
+      end
+    end
+
+    def self.load_missing_constant(from_mod, const_name)
+      # see active_support/dependencies.rb in case of reloading on how to handle
+      qualified_name = qualified_name_for(from_mod, const_name)
+      qualified_path = underscore(qualified_name)
+
+      module_path = search_for_module(qualified_path)
+      if module_path
+        if loading.include?(module_path)
+          raise "Circular dependency detected while autoloading constant #{qualified_name}"
+        else
+          require_or_load(from_mod, module_path)
+          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{module_path} to define it" unless from_mod.const_defined?(const_name, false)
+          return from_mod.const_get(const_name)
+        end
+      elsif (parent = from_mod.parent) && parent != from_mod &&
+            ! from_mod.parents.any? { |p| p.const_defined?(const_name, false) }
+        begin
+          return parent.const_missing(const_name)
+        rescue NameError => e
+          raise unless missing_name?(e, qualified_name_for(parent, const_name))
+        end
+      end
+    end
+
+    def self.missing_name?(e, name)
+      mn = if /undefined/ !~ e.message
+             $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ e.message
+           end
+      mn == name
+    end
+
+    # Returns the constant path for the provided parent and constant name.
+    def self.qualified_name_for(mod, name)
+      mod_name = to_constant_name(mod)
+      mod_name == 'Object' ? name.to_s : "#{mod_name}::#{name}"
+    end
+
+    def self.require_or_load(from_mod, module_path)
+      return if loaded.include?(module_path)
+      loaded << module_path
+      loading << module_path
+
+      begin
+        result = require module_path
+      rescue Exception
+        loaded.delete module_path
+        raise LoadError, "Unable to autoload: require_or_load #{module_path} failed"
+      ensure
+        loading.pop
+      end
+
+      # Record history *after* loading so first load gets warnings.
+      history << module_path
+      result
+      # end
+    end
+
+    def self.search_for_module(path)
+      # oh my! imagine Bart Simpson, writing on the board:
+      # "javascript is not ruby, javascript is not ruby, javascript is not ruby, ..."
+      # then running home, starting irb, on the fly developing a chat client and opening a session with Homer at his workplace: "Hi Dad ..."
+      load_paths.each do |load_path|
+        mod_path = load_path + '/' + path
+        return mod_path if `Opal.modules.hasOwnProperty(#{mod_path})`
+      end
+      return path if `Opal.modules.hasOwnProperty(#{path})`
+      nil # Gee, I sure wish we had first_match ;-)
+    end
+
+    # Convert the provided const desc to a qualified constant name (as a string).
+    # A module, class, symbol, or string may be provided.
+    def self.to_constant_name(desc) #:nodoc:
+      case desc
+      when String then desc.sub(/^::/, '')
+      when Symbol then desc.to_s
+      when Module
+        desc.name ||
+          raise(ArgumentError, 'Anonymous modules have no name to be referenced by')
+      else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
+      end
+    end
+
+    def self.underscore(string)
+      string.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    end
+  end
+end

data/lib/hyperloop/autoloader_starter.rb

@@ -0,0 +1,15 @@
+Hyperloop::Autoloader.load_paths = %w[components models operations stores]
+
+class Object
+  class << self
+    alias _autoloader_original_const_missing const_missing
+
+    def const_missing(const_name)
+      # need to call original code because some things are set up there
+      # original code may also be overloaded by reactrb, for example
+      _autoloader_original_const_missing(const_name)
+    rescue StandardError => e
+      Hyperloop::Autoloader.const_missing(const_name, self) || raise(e)
+    end
+  end
+end

data/lib/hyperloop/config/version.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  module Config
+    VERSION = '0.99.0'
+  end
+end

data/lib/hyperloop/env.rb

@@ -0,0 +1,10 @@
+module Hyperloop
+  def self.env
+    @environment ||= begin
+      env = Rails.env if defined? Rails
+      env ||= ENV['RACK_ENV']
+      env = 'development' unless %w[development production test staging].include? env
+      ActiveSupport::StringInquirer.new(env)
+    end
+  end
+end

data/lib/hyperloop/environment/development/hyperloop_env.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('development')
+  end
+end

data/lib/hyperloop/environment/production/hyperloop_env.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('production')
+  end
+end

data/lib/hyperloop/environment/staging/hyperloop_env.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('staging')
+  end
+end

data/lib/hyperloop/environment/test/hyperloop_env.rb

@@ -0,0 +1,5 @@
+module Hyperloop
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('test')
+  end
+end

data/lib/hyperloop/imports.rb

@@ -5,41 +5,49 @@ module Hyperloop
       @import_list ||= []
     end
 
-    def import(value, gem: nil, instead_of: nil, client_only: nil, server_only: nil, tree: nil)
-      if instead_of
-        current_spec = import_list.detect { |old_value, *_rest| instead_of == old_value }
-        if current_spec
-          current_spec[0] = value
-        else
-          raise [
-            "Could not substitute import '#{instead_of}' with '#{value}'.  '#{instead_of}' not found.",
-            'The following files are currently being imported:',
-            *import_list.collect { |old_value, *_rest| old_value }
-          ].join("\n")
-        end
-      elsif !import_list.detect { |current_value, *_rest| value == current_value }
-        kind = if tree
-                 :tree
-               else
-                 :gem
-               end
-        import_list << [value, !client_only, !server_only, kind]
-      end
+    def import(value, gem: nil, cancelled: nil, client_only: nil, server_only: nil, tree: nil, js_import: nil, at_head: nil)
+      return if import_list.detect { |current_value, *_rest| value == current_value }
+      new_element = [
+        value, cancelled, !client_only, !server_only, (tree ? :tree : :gem), js_import
+      ]
+      import_list.send(at_head ? :unshift : :push, new_element)
     end
 
     alias imports import
 
-    def import_tree(value, instead_of: nil, client_only: nil, server_only: nil)
-      import(value, instead_of: instead_of, client_only: client_only, server_only: server_only, tree: true)
+    def import_tree(value, cancelled: nil, client_only: nil, server_only: nil)
+      import(value, cancelled: cancelled, client_only: client_only, server_only: server_only, tree: true)
     end
 
     def cancel_import(value)
-      import(nil, instead_of: value)
+      return unless value
+      current_spec = import_list.detect { |old_value, *_rest| value == old_value }
+      if current_spec
+        current_spec[1] = true
+      else
+        import_list << [value, true, true, true, false]
+      end
+    end
+
+    def cancel_webpack_imports
+      import_list.collect { |name, _c, _co, _so, _t, js_import, *_rest| js_import && name }
+                 .each { |name| cancel_import name }
+    end
+
+    def handle_webpack
+      return unless defined? Webpacker
+      client_only_manifest = Webpacker.manifest.lookup("client_only.js")
+      client_and_server_manifest = Webpacker.manifest.lookup("client_and_server.js")
+      return unless client_only_manifest || client_and_server_manifest
+      cancel_webpack_imports
+      import client_only_manifest.split("/").last, client_only: true, at_head: true if client_only_manifest
+      import client_and_server_manifest.split("/").last, at_head: true if client_and_server_manifest
     end
 
     def generate_requires(mode, sys, file)
-      import_list.collect do |value, render_on_server, render_on_client, kind|
-        next unless value
+      handle_webpack
+      import_list.collect do |value, cancelled, render_on_server, render_on_client, kind|
+        next if cancelled
         next if (sys && kind == :tree) || (!sys && kind != :tree)
         next if mode == :client && !render_on_client
         next if mode == :server && !render_on_server
@@ -89,31 +97,8 @@ module Hyperloop
       end
     end
 
-    Hyperloop.define_setting :compress_system_assets, true
-
-    def compile_and_compress(name, never_compress: false)
-      start_time = Time.now
-
-      puts "\n\n##########################################################################\n"
-      puts "      HYPERLOOP LIBRARIES PRECOMPILING AND MINIFYING\n"
-      puts "  FIRST TIME BOOTING YOUR APP IT CAN TAKE 1 OR 2 MINUTES\n"
-      puts " NB: You can force precompiling again by cleaning cache: rm -rf tmp/cache \n"
-      puts "##########################################################################\n\n"
-
-      puts "Compiling the system assets for #{name}"
-
-      compiled_code = Rails.application.assets[name].to_s
-      compilation_time = Time.now
-      compiled_code_length = compiled_code.length
-      puts "  compiled -  length: #{compiled_code_length}"
-      if Hyperloop.compress_system_assets && !never_compress
-        compiled_code = Uglifier.new.compile(compiled_code)
-        puts "  minimized - length: #{compiled_code.length}"
-        puts "  minification ratio #{(compiled_code.length*100.0/compiled_code_length).round}%"
-      end
-      puts "  total time: #{(Time.now-start_time).to_f.round(2)} seconds"
-      compiled_code
+    Hyperloop.define_setting(:compress_system_assets, true) do
+       puts "INFO: The configuration option 'compress_system_assets' is no longer used."
     end
-
   end
 end

data/lib/hyperloop/js_imports.rb

@@ -0,0 +1,18 @@
+module Hyperloop
+  class << self
+    def js_import(value, client_only: nil, server_only: nil, defines:)
+      defines = [*defines]
+      if RUBY_ENGINE != 'opal'
+        import(value, client_only: client_only, server_only: server_only, js_import: true)
+      else
+        on_server = `typeof Opal.global.document === 'undefined'`
+        return if (server_only && !on_server) || (client_only && on_server)
+        defines.each do |name|
+          next unless `Opal.global[#{name}] === undefined`
+          raise "The package #{name} was not found. Add it to the webpack "\
+                "#{client_only ? 'client_only.js' : 'client_and_server.js'} manifest."
+        end
+      end
+    end
+  end
+end