capybara-async_runner 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e2d94d0d6867b6a67a5eb65b0436f8ad1e81cde
+  data.tar.gz: 7d47e6c4a489840d793272dfb23461f2a5f0d204
+SHA512:
+  metadata.gz: 2ba028e72e92957aebcba3509bbdc3d552937be71e1b954214ab2c0b03e9192a6922a7509b53807d9af1bc7de51b1f61d95a089ee3fb3805d44eaded7ca973aa
+  data.tar.gz: 26c9975d86b4e04c1c22034769f12cc1dce912bc179b0038b8497d3ebfc41c74c6fffc7143300fbebbe1603ce33722abf84a80da7d63965b5d44fe826f0c396b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version
+.ruby-gemset
+.rvmrc
+.rspec
+

data/.travis.yml

@@ -0,0 +1 @@
+before_install: gem install bundler -v 1.9.9

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capybara-async_runner.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ilya Bylich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# Capybara::AsyncRunner
+
+[![Build Status](https://travis-ci.org/iliabylich/capybara-async-runner.svg?branch=master)](https://travis-ci.org/iliabylich/capybara-async-runner)
+[![Code Climate](https://codeclimate.com/github/iliabylich/capybara-async-runner/badges/gpa.svg)](https://codeclimate.com/github/iliabylich/capybara-async-runner)
+[![Inline docs](http://inch-ci.org/github/iliabylich/capybara-async-runner.svg?branch=master)](http://inch-ci.org/github/iliabylich/capybara-async-runner)
+
+This is a ruby gem for running asynchronous JavaScript code synchronously with Capybara.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capybara-async_runner'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capybara-async_runner
+
+## Usage
+
+Read [this](http://ilyabylich.svbtle.com/capybara-and-asynchronous-stuff) blog post first.
+Then check out `examples` dir.
+
+## How to use
+
++ Setup a directory with command templates
+
+``` ruby
+Capybara::AsyncRunner.setup do |config|
+  config.commands_directory = Rails.root.join('directory/with/templates')
+end
+```
+
++ Create a command
+
+``` ruby
+class MyCommand < Capybara::AsyncRunner::Command
+  # specify the name
+  self.command_name = :my_command
+  # specify a path to template
+  self.template = 'template_name'
+  # specify a response
+  response :done
+end
+```
+
++ Create a template file
+
+``` javascript
+// directory/with/templates/template_name.js.erb
+yourCode(function(data) {
+  <%= done(js[:data]) %>
+})
+```
+
++ Call the command
+
+``` ruby
+Capybara::AsyncRunner.run(:my_command)
+# => data from your script
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/capybara-async_runner/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "capybara/async_runner"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/capybara-async_runner.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capybara/async_runner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capybara-async_runner"
+  spec.version       = Capybara::AsyncRunner::VERSION
+  spec.authors       = ["Ilya Bylich"]
+  spec.email         = ["ibylich@gmail.com"]
+
+  spec.summary       = %q{Gem for running ascynrhonous jobs in Capybara.}
+  spec.homepage      = "https://github.com/iliabylich/capybara-async-runner"
+  spec.license       = "MIT"
+
+  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.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~> 3.2.0'
+  spec.add_development_dependency 'rspec-its', '~> 1.2.0'
+  spec.add_development_dependency 'capybara'
+  spec.add_development_dependency 'poltergeist'
+  spec.add_development_dependency 'pry'
+end

data/examples/indexeddb/commands/insert.rb

@@ -0,0 +1,12 @@
+class IndexDB::Commands::Insert < Capybara::AsyncRunner::Command
+  FailedToInsertData = Class.new(StandardError)
+
+  self.command_name = 'indexeddb:insert'
+  self.file_to_run = 'commands/insert'
+
+  response :error do |response|
+    raise FailedToInsertData, response
+  end
+
+  response :success
+end

data/examples/indexeddb/commands/query.rb

@@ -0,0 +1,11 @@
+class IndexDB::Commands::Query < Capybara::AsyncRunner::Command
+  ErrorDuringQuerying = Class.new(StandardError)
+
+  self.command_name = 'indexeddb:query'
+  self.file_to_run = 'commands/query'
+
+  response :success
+  response :error do |response|
+    raise ErrorDuringQuerying, response
+  end
+end

data/examples/indexeddb/commands/wrapper_initializer.rb

@@ -0,0 +1,10 @@
+class IndexDB::WrapperInitializer < Capybara::AsyncRunner::Command
+  self.command_name = 'indexeddb:wrapper:initialize'
+  self.file_to_run = 'wrapper/initialize'
+
+  response :error do |response|
+    raise "Client error: #{response}"
+  end
+
+  response :success
+end

data/examples/indexeddb/commands/wrapper_loader.rb

@@ -0,0 +1,9 @@
+class IndexDB::WrapperLoader < Capybara::AsyncRunner::Command
+  self.command_name = 'indexeddb:wrapper:inject'
+  self.file_to_run = 'wrapper/inject'
+
+  response :success
+  response :error do
+    raise 'Failed to inject script'
+  end
+end

data/examples/indexeddb/indexdb.rb

@@ -0,0 +1,139 @@
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+$: << ROOT.join('lib')
+$: << EXAMPLE_ROOT = ROOT.join('examples/indexeddb')
+
+require 'capybara'
+require 'capybara/async_runner'
+require 'capybara/poltergeist'
+require 'pry'
+
+Capybara.run_server = false
+Capybara.default_driver = :poltergeist
+
+Capybara::AsyncRunner.setup do |config|
+  config.commands_directory = EXAMPLE_ROOT.join('templates')
+end
+
+module IndexDB
+  URL = "https://raw.githubusercontent.com/dfahlander/Dexie.js/master/src/Dexie.js"
+
+  require 'commands/wrapper_loader'
+  require 'commands/wrapper_initializer'
+
+  module Commands
+    require 'commands/insert'
+    require 'commands/query'
+  end
+end
+
+# We can't run indexeddb-related code in about:blank
+Capybara.current_session.visit('http://google.com')
+
+# Inject the script
+Capybara::AsyncRunner.run('indexeddb:wrapper:inject', url: IndexDB::URL)
+
+# Run some initialization
+Capybara::AsyncRunner.run('indexeddb:wrapper:initialize')
+
+# And do some stuff
+user_data = { name: 'Some Name' }
+
+user_id = Capybara::AsyncRunner.run('indexeddb:insert', store: 'users', data: user_data)
+p "User ID: #{user_id}"
+
+methods = [
+  { method: 'where', arguments: ['id']},
+  { method: 'equals', arguments: [user_id] },
+  { method: 'toArray', arguments: [] }
+]
+
+p Capybara::AsyncRunner.run('indexeddb:query', store: 'users', methods: methods)
+
+# And even write some small wrapper
+#
+#
+module IndexDB::DSL
+  def current_scope
+    @current_scope ||= []
+  end
+
+  IDB_METHODS = {
+    above: :above,
+    aboveOrEqual: :above_or_equal,
+    anyOf: :any_of,
+    below: :below,
+    belowOrEqual: :below_or_equal,
+    between: :between,
+    equals: :equals,
+    equalsIgnoreCase: :equals_ignore_case,
+    startsWith: :starts_with,
+    startsWithAnyOf: :starts_with_any_of,
+    startsWithIgnoreCase: :starts_with_ignore_case,
+    toArray: :to_a,
+    where: :where
+  }
+
+  IDB_METHODS.each do |js_method_name, ruby_method_name|
+    define_method ruby_method_name do |*arguments|
+      current_scope << { method: js_method_name, arguments: arguments }
+      self
+    end
+  end
+
+  module ModelSupport
+    IndexDB::DSL::IDB_METHODS.each do |_, method_name|
+      define_method method_name do |*arguments|
+        IndexDB::ChainedScope.new(self).send(method_name, *arguments)
+      end
+    end
+  end
+end
+
+class IndexDB::ChainedScope
+  include IndexDB::DSL
+
+  def initialize(model)
+    @model = model
+  end
+
+  def get
+    collection = Capybara::AsyncRunner.run('indexeddb:query', store: @model.store, methods: current_scope)
+    collection.map do |record|
+      @model.new(record)
+    end
+  end
+end
+
+class IndexDB::Model
+  extend IndexDB::DSL::ModelSupport
+  attr_accessor :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  class << self
+    attr_accessor :store
+
+    def all
+      where('id').above(0).to_a.get
+    end
+
+    def find(record_id)
+      where('id').equals(record_id).to_a.get.first
+    end
+
+    def count
+      all.count
+    end
+  end
+end
+
+class User < IndexDB::Model
+  self.store = :users
+end
+
+p User.all
+p User.find(8)
+p User.count

data/examples/indexeddb/templates/commands/insert.js.erb

@@ -0,0 +1,8 @@
+var store = window.db['<%= data[:store] %>'];
+var dataToInsert = JSON.parse(<%= data[:data].to_json.inspect %>);
+
+store.add(dataToInsert).then(function(user_id) {
+  <%= success(js[:user_id]) %>
+}).catch(function(err) {
+  <%= error(js[:err]) %>
+})

data/examples/indexeddb/templates/commands/query.js.erb

@@ -0,0 +1,15 @@
+var store = window.db['<%= data[:store] %>'];
+var methodsPayload = JSON.parse(<%= data[:methods].to_json.inspect %>);
+
+methodsPayload.forEach(function(methodPayload) {
+  var method = methodPayload['method'];
+  var arguments = methodPayload['arguments'];
+  console.log("Executing", method, "with", arguments);
+  store = store[method].apply(store, arguments);
+});
+
+store.then(function(data) {
+  <%= success(js[:data]) %>
+}).catch(function(err) {
+  <%= error(js[:err]) %>
+})

data/examples/indexeddb/templates/wrapper/initialize.js.erb

@@ -0,0 +1,18 @@
+window.errorHandler = function(err) {
+  <%= error(js[:err]) %>
+}
+
+if (typeof(Dexie) === 'undefined') {
+  errorHandler('No Dexie');
+} else {
+  window.db = new Dexie('demo91');
+  window.db.version(1).stores({
+    users: '++id,name'
+  });
+
+  window.db.open().catch(function(err) {
+    errorHandler('failed to open indexedDB ' + err);
+  }).then(function() {
+    <%= success %>
+  });
+}

data/examples/indexeddb/templates/wrapper/inject.js.erb

@@ -0,0 +1,29 @@
+function isWrapperReady() {
+  return (typeof(Dexie) !== 'undefined');
+}
+
+function injectScript(src) {
+  var fileref = document.createElement('script')
+  fileref.setAttribute("type","text/javascript")
+  fileref.setAttribute("src", src);
+  document.getElementsByTagName("head")[0].appendChild(fileref)
+}
+
+if (isWrapperReady()) {
+  <%= success %>
+} else {
+  injectScript("<%= data[:url] %>");
+
+  setInterval(function() {
+    if (isWrapperReady()) {
+      <%= success %>
+    }
+  }, 100);
+
+  setTimeout(function () {
+    if (typeof(Dexie) === 'undefined') {
+      <%= error %>
+    }
+  }, 3000);
+}
+

data/examples/simple/command.rb

@@ -0,0 +1,36 @@
+# Don't forget to run 'bundle install' before running this script
+#
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+$: << ROOT.join('lib')
+
+require 'capybara'
+require 'capybara/async_runner'
+
+# Base gem configuration
+Capybara::AsyncRunner.setup do |config|
+  config.commands_directory = ROOT.join('examples/simple')
+end
+
+# Defining a command
+class TestCommand < Capybara::AsyncRunner::Command
+  # global command name
+  self.command_name = :json_and_timeout
+
+  # .js.erb file in directory specified above
+  self.file_to_run = 'template'
+
+  response :parsed_json do |data|
+    JSON.parse(data)
+  end
+end
+
+# I'm using poltergeist as a webdriver here, but you can use whatever you want
+require 'capybara/poltergeist'
+
+# My command is totally abstract, so I'm running it in context of 'about:blank' page
+Capybara.run_server = false
+Capybara.default_driver = :poltergeist
+
+p Capybara::AsyncRunner.run(:json_and_timeout)
+# or TestCommand.new.invoke

data/examples/simple/template.js.erb

@@ -0,0 +1,4 @@
+setTimeout(function() {
+  var json = JSON.stringify([1,2,3]);
+  <%= parsed_json(js[:json]) %>
+})

data/lib/capybara/async_runner.rb

@@ -0,0 +1,49 @@
+require "capybara/async_runner/version"
+
+module Capybara
+  module AsyncRunner
+    FailedToFetchResult = Class.new(StandardError)
+
+    autoload :Configuration, 'capybara/async_runner/configuration'
+    autoload :Command, 'capybara/async_runner/command'
+    autoload :Env, 'capybara/async_runner/env'
+    autoload :JsBuilder, 'capybara/async_runner/js_builder'
+    autoload :WaitHelper, 'capybara/async_runner/wait_helper'
+    autoload :Registry, 'capybara/async_runner/registry'
+
+    # Returns current gem configuration.
+    #
+    # @return [Capybara::AsyncRunner::Configuration]
+    #
+    def self.config
+      @config ||= Configuration.new
+    end
+
+    # Yields current configuration
+    #
+    # @yield [Capybara::AsyncRunner::Configuration]
+    #
+    # @example
+    #   Capybara::AsyncRunner.setup do |config|
+    #     config.commands_directory = Rails.root.join('spec/support/async_runner')
+    #   end
+    #
+    def self.setup
+      yield config
+    end
+
+    # Runs command that has provided +command_name+ and passes provided +data+
+    #
+    # @example
+    #   class MyCoolCommand < Capybara::AsyncRunner::Command
+    #     self.command_name = 'cool_command'
+    #     self.file_to_run = 'path/to/cool/command'
+    #   end
+    #
+    #   Capybara::AsyncRunner.run(:cool_command)
+    #
+    def self.run(command_name, data = {})
+      Registry[command_name].new(data).invoke
+    end
+  end
+end

data/lib/capybara/async_runner/command.rb

@@ -0,0 +1,59 @@
+require 'securerandom'
+require 'capybara/async_runner/commands/configuration'
+require 'capybara/async_runner/commands/responders'
+require 'capybara/async_runner/commands/templates'
+
+# A common class for defining your commands
+#
+# Every command MUST have a name and a .js.erb file
+#
+# @example
+#   # spec/support/async_runner/commands/some_command.rb
+#   #
+#   class SomeCommand < Capybara::AsyncRunner::Command
+#     self.command_name = :some_command_name
+#     self.file_to_run = 'your/path/to/file/without/extension'
+#
+#     response :done
+#     response :fail do |data|
+#       JSON.parse(data)
+#     end
+#   end
+#
+#   SomeCommand.new({}).invoke
+#   # => result
+#
+class Capybara::AsyncRunner::Command
+  include Capybara::AsyncRunner::Commands::Configuration
+  include Capybara::AsyncRunner::Commands::Responders
+  include Capybara::AsyncRunner::Commands::Templates
+
+  # @param data [Hash] data is available in template through <%= data %>
+  #
+  def initialize(data = {})
+    @uuid = SecureRandom.uuid
+    @env = Capybara::AsyncRunner::Env.new(uuid, data, responders)
+  end
+
+  attr_reader :uuid, :env
+
+  # Invokes the command and returns its result
+  #
+  # @see Capybara::AsyncRunner::JsBuilder
+  # @see Capybara::AsyncRunner::Env
+  #
+  def invoke
+    js_builder.result
+  end
+
+  private
+
+  def js_builder
+    @js_builder ||= Capybara::AsyncRunner::JsBuilder.new(@env, erb)
+  end
+
+  def self.inherited(klass)
+    super
+    Capybara::AsyncRunner::Registry << klass
+  end
+end

data/lib/capybara/async_runner/commands/configuration.rb

@@ -0,0 +1,74 @@
+# Module for confoiguring your commands
+#
+# @example
+#   class SomeCommand < Capybara::AsyncRunner::Command
+#     self.command_name = 'my_command_name'
+#     # (use underscores, your can later call them by passing symbols)
+#     self.file_to_run = 'path/to/your/file'
+#   end
+#
+module Capybara::AsyncRunner::Commands
+  module Configuration
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Returns configured command name or raises error
+      #
+      # @return [String, Symbol]
+      #
+      # @raise NotImplementedError
+      #
+      def command_name
+        store[:command_name] or
+          raise NotImplementedError, "You need to define self.command_name = ... in #{self}"
+      end
+
+      # Saves provided +command_name+
+      #
+      # @param command_name [String]
+      #
+      def command_name=(command_name)
+        store[:command_name] = command_name
+      end
+
+      # Returns configured filepath or raises error
+      #
+      # @return [String, Symbol]
+      #
+      # @raise NotImplementedError
+      #
+      def file_to_run
+        store[:file_to_run] or
+          raise NotImplementedError, "You need to define self.file_to_run = ... in #{self}"
+      end
+
+      # Stores provided relative +file_to_run+ (don't include directory and extension)
+      #
+      # @param file_to_run [String]
+      #
+      def file_to_run=(file_to_run)
+        store[:file_to_run] = file_to_run
+      end
+
+      # @private
+      #
+      # Inherits all configuration from parent
+      #
+      def inherited(klass)
+        super
+        return if self == Capybara::AsyncRunner::Command
+        klass.command_name = self.command_name
+        klass.file_to_run = self.file_to_run
+      end
+
+      private
+
+      # @private
+      def store
+        @store ||= {}
+      end
+    end
+  end
+end

data/lib/capybara/async_runner/commands/responders.rb

@@ -0,0 +1,62 @@
+# Module for defining your responders
+#
+# Responder is a method that you should call in you .js code
+#
+# @example
+#   class MyCommand < Capybara::AsyncRunner::Commands
+#     response :done
+#     response :fail, as: :callback
+#     response :parsed_json do |data|
+#       JSON.parse(data)
+#     end
+#
+#   # template
+#   if (done) {
+#     <%= done %>
+#   } else if (fail) {
+#     afterFail(<%= fail %>)
+#   } eles if (returnedJSON) {
+#     <%= parsed_json(js[:returnedJSON]) %>
+#   }
+#
+# Only one responder can be executed for 1 script during 1 invokation
+#
+module Capybara::AsyncRunner::Commands
+  module Responders
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module InstanceMethods
+      def responders
+        self.class.responders
+      end
+    end
+
+    module ClassMethods
+      def responders
+        store[:responders] ||= {}
+      end
+
+      BLANK_PROXY = proc { |value| value }
+
+      # Defines a responder for script
+      #
+      # @param method_name [String, Symbols]
+      # @param options [Hash]
+      # @option options [Symbol] :as can be :callback
+      # @yield raw_data from script
+      #
+      # raw_data will be returned if no block provided
+      #
+      def response(method_name, options = {}, &block)
+        mapping = {
+          options: options,
+          processor: block || BLANK_PROXY
+        }
+        responders[method_name] = mapping
+      end
+    end
+  end
+end

data/lib/capybara/async_runner/commands/templates.rb

@@ -0,0 +1,11 @@
+# Just a module for reading erb files
+#
+module Capybara::AsyncRunner::Commands
+  module Templates
+    def erb
+      fullname = self.class.file_to_run + '.js.erb'
+      filepath = Capybara::AsyncRunner.config.commands_directory.join(fullname)
+      File.read(filepath)
+    end
+  end
+end

data/lib/capybara/async_runner/configuration.rb

@@ -0,0 +1,37 @@
+# Class for configuring a gem
+#
+# @example
+#   config = Capybara::AsyncRunner::Configuration
+#   config.commands_directory = 'some/dir'
+#
+class Capybara::AsyncRunner::Configuration
+  def initialize
+    @data = {}
+  end
+
+  # A DSL for defining accessors with default values
+  #
+  # @example
+  #   config_accessor :access_name # no default value
+  #   config_accessor :timeout, 12
+  #
+  def self.config_accessor(attribute_name, default = nil)
+    define_method attribute_name do
+      @data[attribute_name] || default
+    end
+
+    define_method "#{attribute_name}=" do |value|
+      @data[attribute_name] = value
+    end
+  end
+
+  # Returns directory that contains all command files
+  #
+  config_accessor :commands_directory
+
+  # Drops all configured values
+  #
+  def reset!
+    @data = {}
+  end
+end

data/lib/capybara/async_runner/env.rb

@@ -0,0 +1,78 @@
+# Internal class for building environment for rendering .js.erb code
+#
+class Capybara::AsyncRunner::Env
+  # @param uuid [String] just a uuid of running command
+  # @param data [Hash] data that is available in .erb through <%= data[:something] %>
+  # @param responders [Hash<Symbol, Hash>] mapping method_name => options
+  #
+  # For responders:
+  # @see Capybara::AsyncRunner::Commands::Responders
+  #
+  def initialize(uuid, data, responders)
+    @uuid = uuid
+    @data = data
+    @responders = responders
+  end
+  attr_reader :data, :responders, :uuid
+
+  # Returns a js environment that can be used for fetching data from the code on-the-fly
+  #
+  # @example
+  #   # spec/support/async_runner/templates/command1.js.erb
+  #   var jsLocal = 123;
+  #   <%= done(js[:jsLocal] %>
+  #
+  def js_environment
+    Hash.new do |h, k|
+      k.to_s
+    end
+  end
+  alias_method :js, :js_environment
+
+  # Delegates a method to responder
+  #
+  # @example
+  #   <%= responder1(js[:var1]) %>
+  #
+  # @see Capybara::AsyncRunner::Commands::Responders
+  #
+  def method_missing(method_name, *args)
+    if responders.include?(method_name)
+      response_method_for(method_name, *args)
+    else
+      super
+    end
+  end
+
+  # @private
+  def respond_to_missing?(method_name, include_private = false)
+    super || responders.include?(method_name)
+  end
+
+  # Returns local binding that is used for rendering (ERB.new(template).result(binding))
+  #
+  # @return [Binding]
+  #
+  def local_binding
+    binding
+  end
+
+  attr_reader :responders
+
+  private
+
+  def response_method_for(method_name, *args)
+    options = responders[method_name][:options]
+    if options[:as] == :callback
+      <<-JS
+      function() {
+        var args = Array.prototype.slice.call(arguments, 0);
+        window.Capybara[#{uuid.inspect}] = { from: #{method_name.to_s.inspect}, data: args };
+      }
+      JS
+    else
+      formatted_args = "[#{args.join(', ')}]"
+      "window.Capybara[#{uuid.inspect}] = { from: #{method_name.to_s.inspect}, data: #{formatted_args} };"
+    end
+  end
+end

data/lib/capybara/async_runner/js_builder.rb

@@ -0,0 +1,80 @@
+require 'erb'
+
+# Internal class for executing javascript code.
+#  Don't use directly
+#
+class Capybara::AsyncRunner::JsBuilder
+  # @param env [Capybara::AsyncRunner::Env] context of erb
+  # @param erb [String] erb template with js code
+  #
+  def initialize(env, erb)
+    @env = env
+    @erb = erb
+  end
+
+  attr_reader :env, :erb
+
+  # Executes provided code and returns its result
+  #
+  # @return [Object]
+  #
+  # @raise [Capybara::AsyncRunner::FailedToFetchResult] when javascript VM doesn't have any response after timeout
+  #
+  def result
+    Capybara.current_session.evaluate_script(calculation_code)
+
+    ResponseProcessor.new(raw_result, env.responders).result
+  end
+
+  private
+
+  def raw_result
+    RawResult.new(env.uuid).fetch or
+      raise Capybara::AsyncRunner::FailedToFetchResult, "No response for command with uuid = #{env.uuid}"
+  end
+
+  RawResult = Struct.new(:uuid) do
+    def fetch
+      Capybara::AsyncRunner::WaitHelper.wait_until(2) do
+        Capybara.current_session.evaluate_script(result_code)
+      end
+    end
+
+    def result_code
+      "window.Capybara[#{uuid.inspect}]"
+    end
+  end
+
+  ResponseProcessor = Struct.new(:raw_result, :responders) do
+    def method_name
+      raw_result['from'].to_sym
+    end
+
+    def data
+      raw_result['data'][0]
+    end
+
+    def responder
+      responders[method_name][:processor]
+    end
+
+    def result
+      responder.call(data)
+    end
+  end
+
+  def calculation_code
+    <<-JS
+    function() {
+      if (typeof(window.Capybara) === 'undefined') {
+        window.Capybara = {};
+      }
+      #{dynamic_code}
+    }()
+    JS
+  end
+
+  def dynamic_code
+    ERB.new(erb).result(env.local_binding)
+  end
+end

data/lib/capybara/async_runner/registry.rb

@@ -0,0 +1,32 @@
+# Module for storing all defined commands
+#
+# @example
+#   Capybara::AsyncRunner::Registry << SomeKlass
+#   Capybara::AsyncRunner::Registry[:some_name]
+#   # => SomeKlass
+#
+# You don't need to use this class directly, the gme does everything for you
+#
+module Capybara::AsyncRunner::Registry
+  # Stores provided +command_klass+ internally
+  #
+  # @param command_klass [Capybara::AsyncRunner::Command]
+  #
+  def self.<<(command_klass)
+    all << command_klass
+  end
+
+  # Returns first stored command that has provided +command_name+
+  #
+  # @paran command_name [String, Symbol]
+  #
+  def self.[](command_name)
+    all.detect { |klass| klass.command_name.to_s == command_name.to_s }
+  end
+
+  private
+
+  def self.all
+    @all ||= []
+  end
+end

data/lib/capybara/async_runner/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module AsyncRunner
+    VERSION = "1.0.0"
+  end
+end

data/lib/capybara/async_runner/wait_helper.rb

@@ -0,0 +1,40 @@
+# This module allows to run a code periodically
+#  and check for its returning value
+#
+module Capybara::AsyncRunner::WaitHelper
+  extend self
+
+  # Calls provided +block+ every 100ms
+  #   and stops when it returns false
+  #
+  # @param timeout [Fixnum]
+  # @yield block for execution
+  #
+  # @example
+  #   current_time = Time.now
+  #   Capybara::AsyncRunner::WaitHelper.wait_until(3) do
+  #     Time.now - current_time > 2
+  #   end
+  #
+  #   # 2 seconds later ...
+  #   # => true
+  #
+  #   current_time = Time.now
+  #   Capybara::AsyncRunner::WaitHelper.wait_until(3) do
+  #     Time.now - current_time > 10
+  #   end
+  #
+  #   # 3 seconds later (after timeout)
+  #   # => false
+  #
+  def wait_until(timeout, &block)
+    begin
+      Timeout.timeout(timeout) do
+        sleep(0.1) until value = block.call
+        value
+      end
+    rescue TimeoutError
+      false
+    end
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: capybara-async_runner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ilya Bylich
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: poltergeist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ibylich@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- capybara-async_runner.gemspec
+- examples/indexeddb/commands/insert.rb
+- examples/indexeddb/commands/query.rb
+- examples/indexeddb/commands/wrapper_initializer.rb
+- examples/indexeddb/commands/wrapper_loader.rb
+- examples/indexeddb/indexdb.rb
+- examples/indexeddb/templates/commands/insert.js.erb
+- examples/indexeddb/templates/commands/query.js.erb
+- examples/indexeddb/templates/wrapper/initialize.js.erb
+- examples/indexeddb/templates/wrapper/inject.js.erb
+- examples/simple/command.rb
+- examples/simple/template.js.erb
+- lib/capybara/async_runner.rb
+- lib/capybara/async_runner/command.rb
+- lib/capybara/async_runner/commands/configuration.rb
+- lib/capybara/async_runner/commands/responders.rb
+- lib/capybara/async_runner/commands/templates.rb
+- lib/capybara/async_runner/configuration.rb
+- lib/capybara/async_runner/env.rb
+- lib/capybara/async_runner/js_builder.rb
+- lib/capybara/async_runner/registry.rb
+- lib/capybara/async_runner/version.rb
+- lib/capybara/async_runner/wait_helper.rb
+homepage: https://github.com/iliabylich/capybara-async-runner
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Gem for running ascynrhonous jobs in Capybara.
+test_files: []