guard-jest_runner 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1847de557f71cf8d145bdf4f0b19054c01481070f0e8c1ecca65d0cdb8191fc
+  data.tar.gz: a580e164831f24e9a8c865aa9e5aa2bcc8902d78cab70ae2e56e39f3761b8dc0
+SHA512:
+  metadata.gz: 1829c01972e0bda7e10bfb1813b85dd0b355942723a026cf146d9755f79c7c5df7423a198c782f9bf0ec02b505fe5610c01688755a3b3002cb4f851fe32e677e
+  data.tar.gz: 8d5dd3199ec048465e64c5d837d139f223ff05726f383f52f72d42c681d9d86fdc771c83bfe3330c533d1567157f6ea223d1c273b79893507d3f18845c99ca45

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,27 @@
+require: rubocop-rspec
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  Exclude:
+    - bin/**/*
+    - db/**/*
+    - vendor/**/*
+    - Guardfile
+Rails:
+  Enabled: true
+Metrics/LineLength:
+  Max: 100
+Style/Documentation:
+  Enabled: false
+Style/NumericLiterals:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+MethodLength:
+  Max: 15
+  Enabled: false
+  Enabled: false
+RegexpLiteral:
+  Exclude:
+    - '**/*.gemspec'
+    - '**/Guardfile'

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/README.md

@@ -0,0 +1,75 @@
+# Guard::JestRunner
+
+Guard::JestRunner allows you to automatically run jest when you change a Javascript/ES6 file.
+
+Unlike [guard-jest](https://rubygems.org/gems/guard-jest), this guard runs just as directed by your Guardfile, which allows you to use it in a group and use a Red-Green-Refactor process.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'guard-jest_runner'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guard-jest_runner
+
+## Usage
+
+Please read [Guard usage doc](https://github.com/guard/guard#readme).
+
+## Guardfile
+
+For a typical Rails app with webpack:
+
+``` ruby
+guard :jest do
+  watch(%r{app/javascript/(.+)\.js$}) { |m| "spec/javascript/#{m[1]}.test.js" }
+  watch(%r{spec/javascript/.+\.js$})
+end
+```
+
+(**Recommended**) pair up with guard-eslint to get a Red-Green-Refactor process:
+
+```ruby
+group :red_green_refactor_js, halt_on_fail: true do
+  guard :jest_runner do
+    watch(%r{app/javascript/(.+)\.js$}) { |m| "spec/javascript/#{m[1]}.test.js" }
+    watch(%r{spec/javascript/.+\.js$})
+  end
+
+  guard :eslint, formatter: 'codeframe' do
+    watch(%r{app/javascript/(.+)\.js$}) { |m| ""}
+    watch(%r{spec/javascript/(.+)\.js$})
+  end
+end
+```
+
+### List of available options:
+
+``` ruby
+all_on_start: false                    # Run all specs after changed specs pass.
+keep_failed: true                      # Keep failed files until they pass (add them to new ones)
+notification: true                     # Display notification always when jest completes.
+                                       # If you want to notify only on failure, set to :failure.
+cli: nil                               # Additional command-line options to pass to jest.
+                                       # Don't use the '-f' or '--format' option here.
+command: 'jest'                        # Specify a custom path to the jest command.
+default_paths: ['**/*.js', '**/*.es6'] # The default paths that will be used for "all_on_start".
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/RobinDaugherty/guard-jest_runner.
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well-tested.
+* Update the README to reflect your changes.
+* Please **do not change** the version number.
+* Open a 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 "guard/jest"
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/guard-jest_runner.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guard/jest_runner/version'
+
+Gem::Specification.new do |s|
+  s.name          = "guard-jest_runner"
+  s.version       = Guard::JestRunnerVersion.to_s
+  s.authors       = %w[RobinDaugherty]
+  s.email         = %w[robin@robindaugherty.net]
+
+  s.description   = %q{Allows you to add jest to your Guard toolchain, so that jest is run.}
+  s.summary       = %q{Guard to run jest.}
+  s.homepage      = "https://github.com/RobinDaugherty/guard-jest_runner"
+  s.license       = "MIT"
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri'] = 'https://github.com/RobinDaugherty/guard-jest_runner/releases'
+    s.metadata['source_code_uri'] = 'https://github.com/RobinDaugherty/guard-jest_runner'
+    s.metadata['bug_tracker_uri'] = 'https://github.com/RobinDaugherty/guard-jest_runner/issues'
+  else
+    puts "Your RubyGems does not support metadata. Update if you'd like to make a release."
+  end
+
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 2.0.0"
+
+  s.add_dependency 'guard', "~> 2.1"
+  s.add_dependency 'guard-compat', "~> 1.1"
+
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/guard/jest_runner/runner.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Guard
+  class JestRunner
+    # This class runs `jest` command, retrieves result and notifies.
+    # An instance of this class is intended to invoke `jest` only once in its lifetime.
+    class Runner
+      def initialize(options)
+        @options = options
+      end
+
+      attr_reader :options
+
+      def run(paths)
+        paths = options[:default_paths] unless paths
+
+        command = command_for_check(paths)
+        passed = system(*command)
+        case options[:notification]
+        when :failed
+          notify(passed) unless passed
+        when true
+          notify(passed)
+        end
+
+        passed
+      end
+
+      def command_for_check(paths)
+        command = [options[:command]]
+
+        command.concat(args_specified_by_user)
+        command.concat(['--json', "--outputFile=#{json_file_path}"])
+        command.concat(paths)
+      end
+
+      def args_specified_by_user
+        @args_specified_by_user ||= begin
+          args = options[:cli]
+          case args
+          when Array    then args
+          when String   then args.shellsplit
+          when NilClass then []
+          else fail ':cli option must be either an array or string'
+          end
+        end
+      end
+
+      def json_file_path
+        @json_file_path ||= begin
+          json_file.close
+          json_file.path
+        end
+      end
+
+      ##
+      # Keep the Tempfile instance around so it isn't garbage-collected and therefore deleted.
+      def json_file
+        @json_file ||= begin
+          # Just generate random tempfile path.
+          basename = self.class.name.downcase.gsub('::', '_')
+          Tempfile.new(basename)
+        end
+      end
+
+      def result
+        @result ||= begin
+          File.open(json_file_path) do |file|
+            # Rubinius 2.0.0.rc1 does not support `JSON.load` with 3 args.
+            JSON.parse(file.read, symbolize_names: true)
+          end
+        end
+      end
+
+      def notify(passed)
+        image = passed ? :success : :failed
+        Notifier.notify(summary_text, title: 'Jest results', image: image)
+      end
+
+      def summary_text
+        summary = {
+          tests_run: result[:numTotalTests],
+          passed: result[:numPassedTests],
+          pending: result[:numPendingTests],
+          failed: result[:numFailedTests],
+        }
+
+        String.new.tap do |text|
+          if summary[:failed] > 0
+            text << pluralize(summary[:failed], 'example')
+            text << " failed"
+            text << " (#{summary[:passed]} passed"
+            text << ", #{summary[:pending]} pending" if summary[:pending] > 0
+            text << ")."
+          else
+            text << "#{summary[:passed]} passed"
+            text << " (#{summary[:pending]} pending)" if summary[:pending] > 0
+            text << "."
+          end
+        end
+      end
+
+      def failed_paths
+        result[:testResults].select { |f| f[:status] == "failed" }.map { |f| f[:name] }.uniq
+      end
+
+      def pluralize(number, thing, options = {})
+        text = String.new
+
+        if number == 0 && options[:no_for_zero]
+          text = 'no'
+        else
+          text << number.to_s
+        end
+
+        text << " #{thing}"
+        text << 's' unless number == 1
+
+        text
+      end
+    end
+  end
+end

data/lib/guard/jest_runner/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Guard
+  # A workaround for some superclass BS
+  # where Jest < Guard has to exist?
+  module JestRunnerVersion
+    # http://semver.org/
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/lib/guard/jest_runner.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'guard/compat/plugin'
+
+module Guard
+  class JestRunner < Plugin
+    autoload :Runner, 'guard/jest_runner/runner'
+
+    # Initializes a Guard plugin.
+    # Don't do any work here, especially as Guard plugins get initialized
+    #   even if they are not in an active group!
+    #
+    # @param [Hash] options the custom Guard plugin options
+    # @option options [Array<Guard::Watcher>] watchers the Guard plugin file watchers
+    # @option options [Symbol] group the group this Guard plugin belongs to
+    # @option options [Boolean] any_return allow any object to be returned from a watcher
+    #
+    def initialize(options = {})
+      super
+
+      @options = {
+        all_on_start: false,
+        keep_failed: true,
+        notification: true,
+        cli: nil,
+        command: 'jest',
+        default_paths: ['**/*.js', '**/*.es6'],
+      }.merge(options)
+
+      @failed_paths = []
+    end
+
+    # Called once when Guard starts. Please override initialize method to init stuff.
+    #
+    # @raise [:task_has_failed] when start has failed
+    # @return [Object] the task result
+    #
+    def start
+      Compat::UI.info 'Guard::JestRunner is running'
+      run_all if options[:all_on_start]
+    end
+
+    # Called when `reload|r|z + enter` is pressed.
+    # This method should be mainly used for "reload" (really!) actions like reloading
+    #   passenger/spork/bundler/...
+    #
+    # @raise [:task_has_failed] when reload has failed
+    # @return [Object] the task result
+    #
+    def reload
+      runner.reload
+    end
+
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all specs/tests/...
+    #
+    # @raise [:task_has_failed] when run_all has failed
+    # @return [Object] the task result
+    #
+    def run_all
+      Compat::UI.info 'Running jest for all Javascript files'
+      inspect_with_jest
+    end
+
+    # Called on file(s) additions that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_additions has failed
+    # @return [Object] the task result
+    #
+    def run_on_additions(paths)
+      run_partially(paths)
+    end
+
+    # Called on file(s) modifications that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_modifications has failed
+    # @return [Object] the task result
+    #
+    def run_on_modifications(paths)
+      run_partially(paths)
+    end
+
+    private
+
+    def inspect_with_jest(paths = [])
+      runner = Runner.new(@options)
+      passed = runner.run(paths)
+      @failed_paths = runner.failed_paths
+      throw :task_has_failed unless passed
+    rescue => error
+      Compat::UI.error 'The following exception occurred while running guard-jest_runner: ' \
+                       "#{error.backtrace.first} #{error.message} (#{error.class.name})"
+    end
+
+    def run_partially(paths)
+      paths += @failed_paths if @options[:keep_failed]
+      paths = clean_paths(paths)
+
+      return if paths.empty?
+
+      displayed_paths = paths.map { |path| smart_path(path) }
+      Compat::UI.info "Running jest: #{displayed_paths.join(' ')}"
+
+      inspect_with_jest(paths)
+    end
+
+    def clean_paths(paths)
+      paths = paths.dup
+      paths.map! { |path| File.expand_path(path) }
+      paths.uniq!
+      paths.reject! do |path|
+        next true unless File.exist?(path)
+        included_in_other_path?(path, paths)
+      end
+      paths
+    end
+
+    def included_in_other_path?(target_path, other_paths)
+      dir_paths = other_paths.select { |path| File.directory?(path) }
+      dir_paths.delete(target_path)
+      dir_paths.any? do |dir_path|
+        target_path.start_with?(dir_path)
+      end
+    end
+
+    def smart_path(path)
+      if path.start_with?(Dir.pwd)
+        Pathname.new(path).relative_path_from(Pathname.getwd).to_s
+      else
+        path
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: guard-jest_runner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- RobinDaugherty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-compat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Allows you to add jest to your Guard toolchain, so that jest is run.
+email:
+- robin@robindaugherty.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- guard-jest_runner.gemspec
+- lib/guard/jest_runner.rb
+- lib/guard/jest_runner/runner.rb
+- lib/guard/jest_runner/version.rb
+homepage: https://github.com/RobinDaugherty/guard-jest_runner
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/RobinDaugherty/guard-jest_runner/releases
+  source_code_uri: https://github.com/RobinDaugherty/guard-jest_runner
+  bug_tracker_uri: https://github.com/RobinDaugherty/guard-jest_runner/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Guard to run jest.
+test_files: []