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

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

@@ -1,50 +0,0 @@
-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/internal/window_sizing.rb

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

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

data/lib/sources/top_level_rails_component.rb

@@ -1,103 +0,0 @@
-module Hyperstack
-  module Internal
-    module Component
-      class TopLevelRailsComponent
-
-        # original class declares these params:
-        # param :component_name
-        # param :controller
-        # param :render_params
-
-        class << self
-          attr_accessor :event_history
-
-          def callback_history_for(proc_name)
-            event_history[proc_name]
-          end
-
-          def last_callback_for(proc_name)
-            event_history[proc_name].last
-          end
-
-          def clear_callback_history_for(proc_name)
-            event_history[proc_name] = []
-          end
-
-          def event_history_for(event_name)
-            event_history["on_#{event_name}"]
-          end
-
-          def last_event_for(event_name)
-            event_history["on_#{event_name}"].last
-          end
-
-          def clear_event_history_for(event_name)
-            event_history["on_#{event_name}"] = []
-          end
-        end
-
-        def component
-          return @component if @component
-          paths_searched = []
-          component = nil
-          if @ComponentName.start_with?('::')
-            # if absolute path of component is given, look it up and fail if not found
-            paths_searched << @ComponentName
-            component = begin
-                          Object.const_get(@ComponentName)
-                        rescue NameError
-                          nil
-                        end
-          else
-            # if relative path is given, look it up like this
-            # 1) we check each path + controller-name + component-name
-            # 2) if we can't find it there we check each path + component-name
-            # if we can't find it we just try const_get
-            # so (assuming controller name is Home)
-            # ::Foo::Bar will only resolve to some component named ::Foo::Bar
-            # but Foo::Bar will check (in this order) ::Home::Foo::Bar, ::Components::Home::Foo::Bar, ::Foo::Bar, ::Components::Foo::Bar
-            self.class.search_path.each do |scope|
-              paths_searched << "#{scope.name}::#{@Controller}::#{@ComponentName}"
-              component = begin
-                            scope.const_get(@Controller, false).const_get(@ComponentName, false)
-                          rescue NameError
-                            nil
-                          end
-              break if component != nil
-            end
-            unless component
-              self.class.search_path.each do |scope|
-                paths_searched << "#{scope.name}::#{@ComponentName}"
-                component = begin
-                              scope.const_get(@ComponentName, false)
-                            rescue NameError
-                              nil
-                            end
-                break if component != nil
-              end
-            end
-          end
-          @component = component
-          return @component if @component && @component.method_defined?(:render)
-          raise "Could not find component class '#{@ComponentName}' for @Controller '#{@Controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
-        end
-
-        before_mount do
-          TopLevelRailsComponent.event_history = Hash.new { |h, k| h[k] = [] }
-          component.validator.rules.each do |name, rules|
-            next unless rules[:type] == Proc
-
-            TopLevelRailsComponent.event_history[name] = []
-            @RenderParams[name] = lambda do |*args|
-              TopLevelRailsComponent.event_history[name] << args
-            end
-          end
-        end
-
-        def render
-          Hyperstack::Internal::Component::RenderingContext.render(component, @RenderParams)
-        end
-      end
-    end
-  end
-end

data/multi_level_how_it_works.md

@@ -1,49 +0,0 @@
-each level copies instance variables from outer levels
-there (seems) to be no way to create a config.before(:all) that works for each level of describe
-but it could be done like this:
-
-```ruby
-RSpec.configure do |config|
-  config.before(:each) do |example|
-    puts "#{example} - client_loaded: #{example.example_group.metadata[:client_loaded?]}"
-    unless example.example_group.metadata[:client_loaded?]
-      example.example_group.metadata[:client_loaded?] = true
-      # do whatever needs to be done once per context
-    end
-  end
-end
-```
-
-```ruby
-describe "outer describe" do
-  before(:all) do
-    # mount, before_mount, on_client, insert_html, etc all queue up
-  end
-  it "spec 1" do
-    # outer describe before(:all) client stuff executed here
-    puts "spec 1"
-  end
-  describe "inner describe 1" do
-    before(:all) do
-      # reload <- will restore client context to state at end of parent before(:all)
-    end
-    it "spec 1.1" do
-      puts "spec 1.1"
-    end
-    it "spec 1.2" do
-      puts "spec 1.2"
-    end
-  end
-  describe "inner describe 2" do
-    it "spec 2.1" do
-      puts "spec 2.1"
-    end
-    it "spec 1.2" do
-      puts "spec 2.2"
-    end
-  end
-  it "spec 2" do
-    puts "spec 2"
-  end
-end
-```