hyper-spec 1.0.alpha1.3 → 1.0.alpha1.8

data/lib/hyper-spec/internal/controller.rb

@@ -0,0 +1,70 @@
+module HyperSpec
+  module Internal
+    module Controller
+      class << self
+        attr_accessor :current_example
+        attr_accessor :description_displayed
+
+        def test_id
+          @_hyperspec_private_test_id ||= 0
+          @_hyperspec_private_test_id += 1
+        end
+
+        include ActionView::Helpers::JavaScriptHelper
+
+        def current_example_description!
+          title = "#{title}...continued." if description_displayed
+          self.description_displayed = true
+          "#{escape_javascript(current_example.description)}#{title}"
+        end
+
+        def file_cache
+          @file_cache ||= FileCache.new('cache', '/tmp/hyper-spec-caches', 30, 3)
+        end
+
+        def cache_read(key)
+          file_cache.get(key)
+        end
+
+        def cache_write(key, value)
+          file_cache.set(key, value)
+        end
+
+        def cache_delete(key)
+          file_cache.delete(key)
+        rescue StandardError
+          nil
+        end
+      end
+
+      # By default we assume we are operating in a Rails environment and will
+      # hook in using a rails controller.  To override this define the
+      # HyperSpecController class in your spec helper.  See the rack.rb file
+      # for an example of how to do this.
+
+      def hyper_spec_test_controller
+        return ::HyperSpecTestController if defined?(::HyperSpecTestController)
+
+        base = if defined? ApplicationController
+                 Class.new ApplicationController
+               elsif defined? ::ActionController::Base
+                 Class.new ::ActionController::Base
+               else
+                 raise "Unless using Rails you must define the HyperSpecTestController\n"\
+                       'For rack apps try requiring hyper-spec/rack.'
+               end
+        Object.const_set('HyperSpecTestController', base)
+      end
+
+      # First insure we have a controller, then make sure it responds to the test method
+      # if not, then add the rails specific controller methods.  The RailsControllerHelpers
+      # module will automatically add a top level route back to the controller.
+
+      def route_root_for(controller)
+        controller ||= hyper_spec_test_controller
+        controller.include RailsControllerHelpers unless controller.method_defined?(:test)
+        controller.route_root
+      end
+    end
+  end
+end

data/lib/hyper-spec/internal/copy_locals.rb

@@ -0,0 +1,103 @@
+module HyperSpec
+  module Internal
+    module CopyLocals
+      private
+
+      def build_var_inclusion_lists
+        build_included_list
+        build_excluded_list
+      end
+
+      def build_included_list
+        @_hyperspec_private_included_vars = nil
+        return unless @_hyperspec_private_client_options.key? :include_vars
+
+        included = @_hyperspec_private_client_options[:include_vars]
+        if included.is_a? Symbol
+          @_hyperspec_private_included_vars = [included]
+        elsif included.is_a?(Array)
+          @_hyperspec_private_included_vars = included
+        elsif !included
+          @_hyperspec_private_included_vars = []
+        end
+      end
+
+      PRIVATE_VARIABLES = %i[
+        @__inspect_output @__memoized @example @_hyperspec_private_client_code
+        @_hyperspec_private_html_block @fixture_cache
+        @fixture_connections @connection_subscriber @loaded_fixtures
+        @_hyperspec_private_client_options
+        @_hyperspec_private_included_vars
+        @_hyperspec_private_excluded_vars
+        b __ _ _ex_ pry_instance _out_ _in_ _dir_ _file_
+      ]
+
+      def build_excluded_list
+        return unless @_hyperspec_private_client_options
+
+        excluded = @_hyperspec_private_client_options[:exclude_vars]
+        if excluded.is_a? Symbol
+          @_hyperspec_private_excluded_vars = [excluded]
+        elsif excluded.is_a?(Array)
+          @_hyperspec_private_excluded_vars = excluded
+        elsif excluded
+          @_hyperspec_private_included_vars = []
+        end
+      end
+
+      def var_excluded?(var, binding)
+        return true if PRIVATE_VARIABLES.include? var
+
+        excluded = binding.eval('instance_variable_get(:@_hyperspec_private_excluded_vars)')
+        return true if excluded&.include?(var)
+
+        included = binding.eval('instance_variable_get(:@_hyperspec_private_included_vars)')
+        included && !included.include?(var)
+      end
+
+      def add_locals(in_str, block)
+        b = block.binding
+        add_instance_vars(b, add_local_vars(b, add_memoized_vars(b, in_str)))
+      end
+
+      def add_memoized_vars(binding, in_str)
+        memoized = binding.eval('__memoized').instance_variable_get(:@memoized)
+        return in_str unless memoized
+
+        memoized.inject(in_str) do |str, pair|
+          next str if var_excluded?(pair.first, binding)
+
+          "#{str}\n#{set_local_var(pair.first, pair.last)}"
+        end
+      end
+
+      def add_local_vars(binding, in_str)
+        binding.local_variables.inject(in_str) do |str, var|
+          next str if var_excluded?(var, binding)
+
+          "#{str}\n#{set_local_var(var, binding.local_variable_get(var))}"
+        end
+      end
+
+      def add_instance_vars(binding, in_str)
+        binding.eval('instance_variables').inject(in_str) do |str, var|
+          next str if var_excluded?(var, binding)
+
+          "#{str}\n#{set_local_var(var, binding.eval("instance_variable_get('#{var}')"))}"
+        end
+      end
+
+      def set_local_var(name, object)
+        serialized = object.opal_serialize
+        if serialized
+          "#{name} = #{serialized}"
+        else
+          "self.class.define_method(:#{name}) "\
+          "{ raise 'Attempt to access the variable #{name} "\
+          'that was defined in the spec, but its value could not be serialized '\
+          "so it is undefined on the client.' }"
+        end
+      end
+    end
+  end
+end

data/lib/hyper-spec/internal/patches.rb

@@ -0,0 +1,86 @@
+module Opal
+  # strips off stuff that confuses things when transmitting to the client
+  # and prints offending code if it can't be compiled
+  def self.hyperspec_compile(str, opts = {})
+    compile(str, opts).gsub("// Prepare super implicit arguments\n", '')
+                .delete("\n").gsub('(Opal);', '(Opal)')
+  # rubocop:disable Lint/RescueException
+  # we are going to reraise it anyway, so its fine to catch EVERYTHING!
+  rescue Exception => e
+    puts "puts could not compile: \n\n#{str}\n\n"
+    raise e
+  end
+  # rubocop:enable Lint/RescueException
+end
+
+module Unparser
+  class Emitter
+    # Emitter for send
+    class Send < self
+      def local_variable_clash?
+        selector =~ /^[A-Z]/ ||
+          local_variable_scope.local_variable_defined_for_node?(node, selector)
+      end
+    end
+  end
+end
+
+module MethodSource
+  class << self
+    alias original_lines_for_before_hyper_spec lines_for
+    alias original_source_helper_before_hyper_spec source_helper
+
+    def source_helper(source_location, name = nil)
+      source_location[1] = 1 if source_location[0] == '(pry)'
+      original_source_helper_before_hyper_spec source_location, name
+    end
+
+    def lines_for(file_name, name = nil)
+      if file_name == '(pry)'
+        HyperSpec.current_pry_code_block
+      else
+        original_lines_for_before_hyper_spec file_name, name
+      end
+    end
+  end
+end
+
+class Object
+  def opal_serialize
+    nil
+  end
+end
+
+class Hash
+  def opal_serialize
+    "{#{collect { |k, v| "#{k.opal_serialize} => #{v.opal_serialize}" }.join(', ')}}"
+  end
+end
+
+class Array
+  def opal_serialize
+    "[#{collect { |v| v.opal_serialize }.join(', ')}]"
+  end
+end
+
+[FalseClass, Float, Integer, NilClass, String, Symbol, TrueClass].each do |klass|
+  klass.send(:define_method, :opal_serialize) do
+    inspect
+  end
+end
+
+# rubocop:disable Lint/UnifiedInteger - patch for ruby prior to 2.4
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4.0')
+  [Bignum, Fixnum].each do |klass|
+    klass.send(:define_method, :opal_serialize) do
+      inspect
+    end
+  end
+end
+# rubocop:enable Lint/UnifiedInteger
+
+class Time
+  def to_opal_expression
+    "Time.parse('#{inspect}')"
+  end
+end

data/lib/hyper-spec/internal/rails_controller_helpers.rb

@@ -0,0 +1,50 @@
+module HyperSpec
+  module Internal
+    module RailsControllerHelpers
+      def self.included(base)
+        base.include ControllerHelpers
+        base.include Helpers
+        routes = ::Rails.application.routes
+        routes.disable_clear_and_finalize = true
+        routes.clear!
+        routes.draw { get "/#{base.route_root}/:id", to: "#{base.route_root}#test" }
+        ::Rails.application.routes_reloader.paths.each { |path| load(path) }
+        routes.finalize!
+        ActiveSupport.on_load(:action_controller) { routes.finalize! }
+      ensure
+        routes.disable_clear_and_finalize = false
+      end
+
+      module Helpers
+        def ping!
+          head(:no_content)
+          nil
+        end
+
+        def mount_component!
+          @page << '<%= react_component @component_name, @component_params, '\
+                   "{ prerender: #{@render_on != :client_only} } %>"
+        end
+
+        def application!(file)
+          @page << "<%= javascript_include_tag '#{file}' %>"
+        end
+
+        def style_sheet!(file)
+          @page << "<%= stylesheet_link_tag '#{file}' %>"
+        end
+
+        def deliver!
+          @render_params[:inline] = @page
+          response.headers['Cache-Control'] = 'max-age=120'
+          response.headers['X-Tracking-ID'] = '123456'
+          render @render_params
+        end
+
+        def server_only?
+          @render_on == :server_only
+        end
+      end
+    end
+  end
+end

data/lib/hyper-spec/{time_cop.rb → internal/time_cop.rb}

@@ -59,6 +59,10 @@ if RUBY_ENGINE == 'opal'
         ticker
       end
 
+      def init(scale: 1, resolution: 10)
+        update_lolex(Time.now, scale, resolution)
+      end
+
       def update_lolex(time, scale, resolution)
         `#{@lolex}.uninstall()` && return if scale.nil?
         @mock_start_time = time.to_f * 1000
@@ -80,6 +84,14 @@ if RUBY_ENGINE == 'opal'
     end
   end
 
+  # create an alias for Lolex.init so we can say Timecop.init on the client
+
+  class Timecop
+    def self.init(*args)
+      Lolex.init(*args)
+    end
+  end
+
 else
   require 'timecop'
 
@@ -136,7 +148,7 @@ else
 
       def evaluate_ruby(&block)
         if @capybara_page
-          @capybara_page.evaluate_ruby(yield)
+          @capybara_page.internal_evaluate_ruby(yield)
         else
           pending_evaluations << block
         end
@@ -144,7 +156,7 @@ else
 
       def run_pending_evaluations
         return if pending_evaluations.empty?
-        @capybara_page.evaluate_ruby(pending_evaluations.collect(&:call).join("\n"))
+        @capybara_page.internal_evaluate_ruby(pending_evaluations.collect(&:call).join("\n"))
         @pending_evaluations ||= []
       end
     end

data/lib/hyper-spec/internal/window_sizing.rb

@@ -0,0 +1,73 @@
+module HyperSpec
+  module Internal
+    module WindowSizing
+      private
+
+      STD_SIZES = {
+        small: [480, 320],
+        mobile: [640, 480],
+        tablet: [960, 640],
+        large: [1920, 6000],
+        default: [1024, 768]
+      }
+
+      def determine_size(width, height)
+        width, height = [height, width] if width == :portrait
+        width, height = width if width.is_a? Array
+        portrait = true if height == :portrait
+        width ||= :default
+        width, height = STD_SIZES[width] if STD_SIZES[width]
+        width, height = [height, width] if portrait
+        [width + debugger_width, height]
+      end
+
+      def debugger_width
+        RSpec.configuration.debugger_width ||= begin
+          hs_internal_resize_to(1000, 500) do
+            sleep RSpec.configuration.wait_for_initialization_time
+          end
+          inner_width = evaluate_script('window.innerWidth')
+          1000 - inner_width
+        end
+        RSpec.configuration.debugger_width
+      end
+
+      def hs_internal_resize_to(width, height)
+        Capybara.current_session.current_window.resize_to(width, height)
+        yield if block_given?
+        wait_for_size(width, height)
+      end
+
+      def wait_for_size(width, height)
+        @start_time = Capybara::Helpers.monotonic_time
+        @stable_count_w = @stable_count_h = 0
+        prev_size = [0, 0]
+        loop do
+          sleep 0.05
+          curr_size = evaluate_script('[window.innerWidth, window.innerHeight]')
+
+          return true if curr_size == [width, height] || stalled?(prev_size, curr_size)
+
+          prev_size = curr_size
+          check_time!
+        end
+      end
+
+      def check_time!
+        if (Capybara::Helpers.monotonic_time - @start_time) >
+           Capybara.current_session.config.default_max_wait_time
+          raise Capybara::WindowError,
+                'Window size not stable within '\
+                "#{Capybara.current_session.config.default_max_wait_time} seconds."
+        end
+      end
+
+      def stalled?(prev_size, curr_size)
+        # some maximum or minimum is reached and size doesn't change anymore
+        @stable_count_w += 1 if prev_size[0] == curr_size[0]
+        @stable_count_h += 1 if prev_size[1] == curr_size[1]
+        @stable_count_w > 4 || @stable_count_h > 4
+      end
+    end
+  end
+end

data/lib/hyper-spec/rack.rb

@@ -0,0 +1,67 @@
+require 'hyper-spec'
+
+class HyperSpecTestController < SimpleDelegator
+  include HyperSpec::ControllerHelpers
+
+  class << self
+    attr_reader :sprocket_server
+    attr_reader :asset_path
+
+    def wrap(app:, append_path: 'app', asset_path: '/assets')
+      @sprocket_server = Opal::Sprockets::Server.new do |s|
+        s.append_path append_path
+      end
+
+      @asset_path = asset_path
+
+      ::Rack::Builder.app(app) do
+        map "/#{HyperSpecTestController.route_root}" do
+          use HyperSpecTestController
+        end
+      end
+    end
+  end
+
+  def sprocket_server
+    self.class.sprocket_server
+  end
+
+  def asset_path
+    self.class.asset_path
+  end
+
+  def ping!
+    [204, {}, []]
+  end
+
+  def application!(file)
+    @page << Opal::Sprockets.javascript_include_tag(
+      file,
+      debug: true,
+      sprockets: sprocket_server.sprockets,
+      prefix: asset_path
+    )
+  end
+
+  def json!
+    @page << Opal::Sprockets.javascript_include_tag(
+      'json',
+      debug: true,
+      sprockets: sprocket_server.sprockets,
+      prefix: asset_path
+    )
+  end
+
+
+  def style_sheet!(_file_); end
+
+  def deliver!
+    [200, { 'Content-Type' => 'text/html' }, [@page]]
+  end
+
+  def call(env)
+    __setobj__(Rack::Request.new(env))
+    params[:id] = path.split('/').last
+    test
+  end
+end