hyperstack-config 0.1

data/bin/hyperstack-hotloader

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require "hyperstack/hotloader/server"
+
+options = {:port => 25222, :directories => []}
+OptionParser.new do |opts|
+  opts.banner = "Usage: opal-hot-reloader [options]"
+
+  opts.on("-p", '--port [INTEGER]', Integer, 'port to run on, defaults to 25222') do |v|
+    options[:port] = v
+  end
+
+  opts.on("-d", '--directories x,y,z', Array, "comma separated directories to watch. Ex. to add 2 directories '-d app/assets/js,app/client/components'. Directoriess automatically included if they exist are:\n\t\t* app/assets/javascripts\n\t\t* app/views/components") do |v|
+    options[:directories] = v
+  end
+
+end.parse!
+
+server = Hyperstack::Hotloader::Server.new(options)
+puts "Listening on port #{options[:port]}, watching for changes in #{options[:directories].join(', ')}"
+server.loop

data/hyperstack-config.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hyperstack/config/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hyperstack-config'
+  spec.version       = Hyperstack::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 hyperstack gems}
+  spec.homepage      = 'http://ruby-hyperstack.org'
+  spec.license       = 'MIT'
+  # spec.metadata      = {
+  #   "homepage_uri" => 'http://ruby-hyperstack.org',
+  #   "source_code_uri" => 'https://github.com/ruby-hyperstack/hyper-component'
+  # }
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  #spec.bindir        = 'exe'
+  #spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables << 'hyperstack-hotloader'
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'libv8', '~> 6.3.0' # see https://github.com/discourse/mini_racer/issues/92
+  spec.add_dependency 'listen', '~> 3.0'  # for hot loader
+  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_dependency 'websocket' # for hot loader
+
+
+  spec.add_development_dependency 'bundler', '~> 1.16.0'
+  spec.add_development_dependency 'chromedriver-helper'
+  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 'timecop', '~> 0.8.1'
+end

data/lib/hyperstack-config.rb

@@ -0,0 +1,45 @@
+require 'hyperstack/boot'
+if RUBY_ENGINE == 'opal'
+  require 'hyperstack/deprecation_warning'
+  require 'hyperstack/string'
+  require 'hyperstack/client_stubs'
+  require 'hyperstack/context'
+  require 'hyperstack/js_imports'
+  require 'hyperstack/on_client'
+  require 'hyperstack/active_support_string_inquirer.rb'
+  require 'hyperstack_env'
+  require 'hyperstack/hotloader/stub'
+else
+  require 'opal'
+  require 'opal-browser'
+  # We need opal-rails to be loaded for Gem code to be properly included by sprockets.
+  begin
+    require 'opal-rails' if defined? Rails
+  rescue LoadError
+    puts "****** WARNING: To use Hyperstack with Rails you must include the 'opal-rails' gem in your gem file."
+  end
+  require 'hyperstack/config_settings'
+  require 'hyperstack/context'
+  require 'hyperstack/imports'
+  require 'hyperstack/js_imports'
+  require 'hyperstack/client_readers'
+  require 'hyperstack/on_client'
+
+  if defined? Rails
+    require 'hyperstack/rail_tie'
+  end
+  require 'hyperstack/active_support_string_inquirer.rb' unless defined? ActiveSupport
+  require 'hyperstack/env'
+  require 'hyperstack/on_error'
+  Hyperstack.define_setting :hotloader_port, 25222
+  Hyperstack.define_setting :hotloader_ping, nil
+  Hyperstack.import 'opal', gem: true
+  Hyperstack.import 'browser', client_only: true
+  Hyperstack.import 'hyperstack-config', gem: true
+  Hyperstack.import 'hyperstack/autoloader'
+  Hyperstack.import 'hyperstack/autoloader_starter'
+  # based on the environment pick the directory containing the file with the matching
+  # value for the client.  This avoids use of ERB for builds outside of sprockets environment
+  Opal.append_path(File.expand_path("../hyperstack/environment/#{Hyperstack.env}/", __FILE__).untaint)
+  Opal.append_path(File.expand_path('../', __FILE__).untaint)
+end

data/lib/hyperstack-hotloader-config.js.erb

@@ -0,0 +1,7 @@
+console.log('hotloader config doing its thing')
+if ((typeof(window) !== 'undefined') && (window.Hyperstack==undefined || window.Hyperstack.hotloader==undefined)) {
+  window.Hyperstack = { hotloader: function(port, ping) { }}
+}
+//if (typeof(Hyperstack) === 'undefined') { Hyperstack = {} }
+Hyperstack.hotloader.port = <%= Hyperstack.hotloader_port %>
+Hyperstack.hotloader.ping = <%= !!Hyperstack.hotloader_ping %>

data/lib/hyperstack-loader-application.rb.erb

@@ -0,0 +1 @@
+<%= Hyperstack.generate_requires(:client, false, __FILE__) %>

data/lib/hyperstack-loader-system-code.rb.erb

@@ -0,0 +1 @@
+<%= Hyperstack.generate_requires(:client, true, __FILE__) %>

data/lib/hyperstack-loader.js

@@ -0,0 +1,6 @@
+//= require hyperstack-loader-system-code
+//= require hyperstack-loader-application
+//= require hyperstack-hotloader-config
+Opal.load('hyperstack-loader-system-code')
+Opal.load('hyperstack-loader-application')
+Hyperstack.hotloader(Hyperstack.hotloader.port, Hyperstack.hotloader.ping)

data/lib/hyperstack-prerender-loader-application.rb.erb

@@ -0,0 +1 @@
+<%= Hyperstack.generate_requires(:server, false, __FILE__) %>

data/lib/hyperstack-prerender-loader-system-code.rb.erb

@@ -0,0 +1 @@
+<%= Hyperstack.generate_requires(:server, true, __FILE__) %>

data/lib/hyperstack-prerender-loader.js

@@ -0,0 +1,4 @@
+//= require hyperstack-prerender-loader-system-code
+//= require hyperstack-prerender-loader-application
+Opal.load('hyperstack-prerender-loader-system-code')
+Opal.load('hyperstack-prerender-loader-application')

data/lib/hyperstack/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/hyperstack/autoloader.rb

@@ -0,0 +1,140 @@
+require 'set'
+
+module Hyperstack
+  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)
+    rescue Exception => e
+      puts "HyperStack autoloader failed attempting to load #{mod}::#{const_name}.  Could be a bug in autoloader"
+    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 from_mod.respond_to?(:parent) &&  (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/hyperstack/autoloader_starter.rb

@@ -0,0 +1,15 @@
+Hyperstack::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
+      Hyperstack::Autoloader.const_missing(const_name, self) || raise(e)
+    end
+  end
+end

data/lib/hyperstack/boot.rb

@@ -0,0 +1,41 @@
+# Define a primitive Boot Operation that will act like a full blown operation.
+# If Operation is defined before this then we skip the whole exercise.  Likewise
+# when Operation defines the Boot class, it will check for a receivers method and
+# copy any defined receivers into the updated Boot class.
+
+module Hyperstack
+  unless defined? Operation
+    class Operation
+    end
+    class Application
+      class Boot < Operation
+        class ReactDummyParams
+          # behaves simplistically like a true Operation broadcast Params object with a
+          # single param named context.
+          attr_reader :context
+          def initialize(context)
+            @context = context
+          end
+        end
+        class << self
+          def on_dispatch(&block)
+            receivers << block
+          end
+
+          def receivers
+            # use the force: true option so that system code needing to receive
+            # boot will NOT be erased on the next Hyperloop::Context.reset!
+            Hyperstack::Context.set_var(self, :@receivers, force: true) { [] }
+          end
+
+          def run(context: nil)
+            params = ReactDummyParams.new(context)
+            receivers.each do |receiver|
+              receiver.call params
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/client_readers.rb

@@ -0,0 +1,19 @@
+module Hyperstack
+# configuration utility
+  class << self
+    def client_readers
+      @client_readers ||= []
+    end
+
+    def client_reader_hash
+      @client_readers_hash ||= {}
+    end
+
+    def client_reader(*args)
+      # configuration.client_reader[:foo] = 12  initialize your own client value
+      # configuration.client_reader :foo, :bar  make previous setting readable on client
+      client_readers += [*args]
+      client_reader_hash
+    end
+  end
+end

data/lib/hyperstack/client_stubs.rb

@@ -0,0 +1,12 @@
+module Hyperstack
+  class << self
+    def import(*args)
+    end
+
+    def imports(*args)
+    end
+
+    def import_tree(*args)
+    end
+  end
+end

data/lib/hyperstack/config/version.rb

@@ -0,0 +1,5 @@
+module Hyperstack
+  module Config
+    VERSION = '0.1'
+  end
+end

data/lib/hyperstack/config_settings.rb

@@ -0,0 +1,49 @@
+module Hyperstack
+# configuration utility
+  class << self
+    def initialized_blocks
+      @initialized_blocks ||= []
+    end
+
+    def reset_blocks
+      @reset_blocks ||= []
+    end
+
+    def configuration
+      reset_blocks.each(&:call)
+      yield self
+      initialized_blocks.each(&:call)
+    end
+
+    def define_setting(name, default = nil, &block)
+      class_variable_set("@@#{name}", default)
+
+      define_class_method "#{name}=" do |value|
+        class_variable_set("@@#{name}", value)
+        block.call value if block
+        value
+      end
+
+      define_class_method name do
+        class_variable_get("@@#{name}")
+      end
+    end
+
+
+    def on_config_reset &block
+      reset_blocks << block
+    end
+
+    def on_config_initialized &block
+      initialized_blocks << block
+    end
+
+    private
+
+    def define_class_method(name, &block)
+      (class << self; self; end).instance_eval do
+        define_method name, &block
+      end
+    end
+  end
+end