hyper-spec 1.0.alpha1.8 → 1.0.0.lap28

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

@@ -1,94 +0,0 @@
-module HyperSpec
-  module Internal
-    module ClientExecution
-      def internal_evaluate_ruby(*args, &block)
-        insure_page_loaded
-        add_promise_execute_and_wait(*process_params(*args, &block))
-      end
-
-      private
-
-      def add_opal_block(str, block)
-        return str unless block
-
-        source = block.source
-        ast = Parser::CurrentRuby.parse(source)
-        ast = find_block(ast)
-        raise "could not find block within source: #{block.source}" unless ast
-
-        "#{add_locals(str, block)}\n#{Unparser.unparse ast.children.last}"
-      end
-
-      def add_promise_execute_and_wait(str, opts)
-        js = opal_compile(add_promise_wrapper(str))
-        page.execute_script("window.hyper_spec_promise_result = false; #{js}")
-        Timeout.timeout(Capybara.default_max_wait_time) do
-          loop do
-            break if page.evaluate_script('!!window.hyper_spec_promise_result')
-            page.evaluate_script('!!window.hyper_spec_promise_failed && Opal.Opal.$raise(window.hyper_spec_promise_failed)')
-
-            sleep 0.25
-          end
-        end
-        JSON.parse(page.evaluate_script('window.hyper_spec_promise_result.$to_json()'), opts).first
-      end
-
-      def add_promise_wrapper(str)
-        <<~RUBY
-          (#{str}).tap do |r|
-            if defined?(Promise) && r.is_a?(Promise)
-              r.then { |args| `window.hyper_spec_promise_result = [args]` }
-               .fail { |e| `window.hyper_spec_promise_failed = e` }
-            else
-              #after(0) do
-                #puts "setting window.hyper_spec_promise_result = [\#{r}]"
-                `window.hyper_spec_promise_result = [r]`
-              #end
-            end
-          end
-        RUBY
-      end
-
-      def find_block(node)
-        # find a block with the ast tree.
-
-        return false unless node.class == Parser::AST::Node
-        return node if the_node_you_are_looking_for?(node)
-
-        node.children.each do |child|
-          found = find_block(child)
-          return found if found
-        end
-        false
-      end
-
-      def process_params(*args, &block)
-        args = ['', *args] if args[0].is_a? Hash
-        args = [args[0], {}, args[1] || {}] if args.length < 3
-        str, opts, vars = args
-        vars.each do |name, value|
-          str = "#{name} = #{value.inspect}\n#{str}"
-        end
-        [add_opal_block(str, block), opts]
-      end
-
-      def the_node_you_are_looking_for?(node)
-        # we could also check that the block is going to the right method
-        #   respond_to?(node.children.first.children[1]) &&
-        #   method(node.children.first.children[1]) == method(:evaluate_ruby)
-        # however that does not work for expect { ... }.on_client_to ...
-        # because now the block is being sent to expect... so we could
-        # check the above OR node.children.first.children[1] == :expect
-        # but what if there are two blocks? on and on...
-        node.type == :block &&
-          node.children.first.class == Parser::AST::Node &&
-          node.children.first.type == :send
-      end
-
-
-      def opal_compile(str)
-        Opal.hyperspec_compile(str, arity_check: client_options[:arity_check])
-      end
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-module HyperSpec
-  module Internal
-    module ComponentMount
-      private
-
-      TEST_CODE_KEY = 'hyper_spec_prerender_test_code.js'.freeze
-
-      # rubocop:disable Metrics/MethodLength
-      def add_block_with_helpers(component_name, opts, block)
-        return unless block || @_hyperspec_private_client_code || component_name.nil?
-
-        block_with_helpers = <<-RUBY
-          module ComponentHelpers
-            def self.js_eval(s)
-              `eval(s)`
-            end
-            def self.dasherize(s)
-              res = %x{
-                s.replace(/[-_\\s]+/g, '-')
-                .replace(/([A-Z\\d]+)([A-Z][a-z])/g, '$1-$2')
-                .replace(/([a-z\\d])([A-Z])/g, '$1-$2')
-                .toLowerCase()
-              }
-              res
-            end
-            def self.add_class(class_name, styles={})
-              style = styles.collect { |attr, value| "\#{dasherize(attr)}:\#{value}" }.join("; ")
-              cs = class_name.to_s
-              %x{
-                var style_el = document.createElement("style");
-                var css = "." + cs + " { " + style + " }";
-                style_el.type = "text/css";
-                if (style_el.styleSheet){
-                  style_el.styleSheet.cssText = css;
-                } else {
-                  style_el.appendChild(document.createTextNode(css));
-                }
-                document.head.appendChild(style_el);
-              }
-            end
-          end
-          #{test_dummy}
-          #{@_hyperspec_private_client_code}
-          #{"#{add_locals('', block)}\n#{Unparser.unparse(Parser::CurrentRuby.parse(block.source).children.last)}" if block}
-        RUBY
-        @_hyperspec_private_client_code = nil
-        opts[:code] = opal_compile(block_with_helpers)
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def build_test_url_for(controller = nil, ping = nil)
-        id = ping ? 'ping' : Controller.test_id
-        "/#{route_root_for(controller)}/#{id}"
-      end
-
-      def insure_page_loaded(only_if_code_or_html_exists = nil)
-        return if only_if_code_or_html_exists && !@_hyperspec_private_client_code && !@_hyperspec_private_html_block
-
-        # if we are not resetting between examples, or think its mounted
-        # then look for Opal, but if we can't find it, then ping to clear and try again
-        if !HyperSpec.reset_between_examples? || page.instance_variable_get('@hyper_spec_mounted')
-          r = evaluate_script('Opal && true') rescue nil
-          return if r
-
-          page.visit build_test_url_for(nil, true) rescue nil
-        end
-        load_page
-      end
-
-      def internal_mount(component_name, params, opts, &block)
-        # TODO:  refactor this
-        test_url = build_test_url_for(opts.delete(:controller))
-        add_block_with_helpers(component_name, opts, block)
-        send_params_to_controller_via_cache(test_url, component_name, params, opts)
-        setup_prerendering(opts)
-        page.instance_variable_set('@hyper_spec_mounted', false)
-        visit test_url
-        wait_for_ajax unless opts[:no_wait]
-        page.instance_variable_set('@hyper_spec_mounted', true)
-        Lolex.init(self, client_options[:time_zone], client_options[:clock_resolution])
-      end
-
-      def prerendering?(opts)
-        %i[both server_only].include?(opts[:render_on])
-      end
-
-      def send_params_to_controller_via_cache(test_url, component_name, params, opts)
-        component_name ||= 'Hyperstack::Internal::Component::TestDummy' if test_dummy
-        Controller.cache_write(
-          test_url,
-          [component_name, params, @_hyperspec_private_html_block, opts]
-        )
-        @_hyperspec_private_html_block = nil
-      end
-
-      # test_code_key = "hyper_spec_prerender_test_code.js"
-      # if defined? ::Hyperstack::Component
-      #   @@original_server_render_files ||= ::Rails.configuration.react.server_renderer_options[:files]
-      #   if opts[:render_on] == :both || opts[:render_on] == :server_only
-      #     unless opts[:code].blank?
-      #       ComponentTestHelpers.cache_write(test_code_key, opts[:code])
-      #       ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files + [test_code_key]
-      #       ::React::ServerRendering.reset_pool # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher doesnt look for cache changes
-      #     else
-      #       ComponentTestHelpers.cache_delete(test_code_key)
-      #       ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files
-      #       ::React::ServerRendering.reset_pool # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher doesnt look for cache changes
-      #     end
-      #   end
-      # end
-
-      def setup_prerendering(opts)
-        return unless defined?(::Hyperstack::Component) && prerendering?(opts)
-
-        @@original_server_render_files ||= ::Rails.configuration.react.server_renderer_options[:files]
-        ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files
-        if opts[:code].blank?
-          Controller.cache_delete(TEST_CODE_KEY)
-        else
-          Controller.cache_write(TEST_CODE_KEY, opts[:code])
-          ::Rails.configuration.react.server_renderer_options[:files] += [TEST_CODE_KEY]
-        end
-        ::React::ServerRendering.reset_pool
-        # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher
-        # doesnt look for cache changes
-      end
-
-      def test_dummy
-        return unless defined? ::Hyperstack::Component
-
-        <<-RUBY
-          class Hyperstack::Internal::Component::TestDummy
-            include Hyperstack::Component
-            render {}
-          end
-        RUBY
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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