guard-eslint 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13b6d5684ff42abb480cfebdefb8b9a2fb3c0ad7734f2f1e953d2e9aa2fd5d8f
+  data.tar.gz: a72c609367b38177a97af4e2635083fee57f0cd02f6e865fc95e429f8c0ed80d
+SHA512:
+  metadata.gz: 0eba44793949312b50b27c1fb1b4c151d9b5c3e10b0b907e80603741544a0bd56c8ee1091b3ed1ac4e30f64dc933512ec4b485f3d65e760abcf3ec12466d4f26
+  data.tar.gz: ec966b2a42890b48a643242223e9bc0aa01f1f61b3f39ed4af579c5858bb1538831b91dc736a3051353111f99bbe0110241ba38c69d9e633872f71371e6acbe8

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-eslint.gemspec
+gemspec

data/README.md

@@ -0,0 +1,59 @@
+# Guard::Eslint
+
+Guard::Eslint allows you to automatically run eslint when you change a Javascript/ES6 file.
+This is best when run after your Javascript tests pass.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'guard-eslint'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guard-eslint
+
+## Usage
+
+Please read [Guard usage doc](https://github.com/guard/guard#readme).
+
+## Guardfile
+
+For a typical Rails app with webpack:
+
+``` ruby
+guard :eslint, formatter: 'codeframe' do
+  watch(%r{^app/javascript/.+\.(js|es6)$})
+  watch(%r{^spec/javascript/.+\.(js|es6)$})
+end
+```
+
+### List of available options:
+
+``` ruby
+all_on_start: true                     # Run all specs after changed specs pass.
+keep_failed: false                     # Keep failed files until they pass (add them to new ones)
+notification: :failed                  # Display notification when eslint reports an issue.
+                                       # If you want to always notify, set to true.
+cli: nil                               # Additional command-line options to pass to eslint.
+                                       # Don't use the '-f' or '--format' option here.
+formatter: nil                         # Formatter to use for output to the console.
+command: 'eslint'                      # Specify a custom path to the eslint 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-eslint.
+
+* 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/eslint"
+
+# 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-eslint.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/eslint/version'
+
+Gem::Specification.new do |s|
+  s.name          = "guard-eslint"
+  s.version       = Guard::EslintVersion.to_s
+  s.authors       = %w[tadiou RobinDaugherty]
+  s.email         = %w[therearedemonsinsideofus@gmail.com robin@robindaugherty.net]
+
+  s.description   = %q{Allows you to add eslint to your Guard toolchain, so that eslint is run.}
+  s.summary       = %q{Guard to run eslint.}
+  s.homepage      = "https://github.com/RobinDaugherty/guard-eslint"
+  s.license       = "MIT"
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri'] = 'https://github.com/RobinDaugherty/guard-eslint/releases'
+    s.metadata['source_code_uri'] = 'https://github.com/RobinDaugherty/guard-eslint'
+    s.metadata['bug_tracker_uri'] = 'https://github.com/RobinDaugherty/guard-eslint/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/eslint.rb

@@ -0,0 +1,135 @@
+require 'guard/compat/plugin'
+
+module Guard
+  class Eslint < Plugin
+    autoload :Runner, 'guard/eslint/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: false,
+        notification: :failed,
+        cli: nil,
+        formatter: nil,
+        command: 'eslint',
+        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::ESLint 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 'Inspecting all Javascript files'
+      inspect_with_eslint
+    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_eslint(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-eslint: ' \
+                       "#{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 "Inspecting JS code style: #{displayed_paths.join(' ')}"
+
+      inspect_with_eslint(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

data/lib/guard/eslint/runner.rb

@@ -0,0 +1,131 @@
+# coding: utf-8
+
+require 'json'
+
+module Guard
+  class Eslint
+    # This class runs `eslint` command, retrieves result and notifies.
+    # An instance of this class is intended to invoke `eslint` 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
+
+        run_for_output(paths)
+
+        passed
+      end
+
+      ##
+      # Once eslint reports a failure, we have to run it again to show the results using the
+      # formatter that it uses for output.
+      # This because eslint doesn't support multiple formatters during the same run.
+      def run_for_output(paths)
+        command = [options[:command]]
+
+        command.concat(args_specified_by_user)
+        command.concat(['-f', options[:formatter]]) if options[:formatter]
+        command.concat(paths)
+        system(*command)
+      end
+
+      def command_for_check(paths)
+        command = [options[:command]]
+
+        command.concat(args_specified_by_user)
+        command.concat(['-f', 'json', '-o', 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
+          # Just generate random tempfile path.
+          basename = self.class.name.downcase.gsub('::', '_')
+          tempfile = Tempfile.new(basename)
+          tempfile.close
+          tempfile.path
+        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: 'ESLint results', image: image)
+      end
+
+      # rubocop:disable Metric/AbcSize
+      def summary_text
+        summary = {
+          files_inspected: result.count,
+          errors: result.map { |x| x[:errorCount] }.reduce(:+),
+          warnings: result.map { |x| x[:warningCount] }.reduce(:+)
+        }
+
+        text = pluralize(summary[:files_inspected], 'file')
+        text << ' inspected, '
+
+        errors_count = summary[:errors]
+        text << pluralize(errors_count, 'error', no_for_zero: true)
+        text << ' detected, '
+
+        warning_count = summary[:warnings]
+        text << pluralize(warning_count, 'warning', no_for_zero: true)
+        text << ' detected'
+      end
+      # rubocop:enable Metric/AbcSize
+
+      def failed_paths
+        result.reject { |f| f[:messages].empty? }.map { |f| f[:filePath] }
+      end
+
+      def pluralize(number, thing, options = {})
+        text = ''
+
+        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/eslint/version.rb

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

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: guard-eslint
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- tadiou
+- 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 eslint to your Guard toolchain, so that eslint is run.
+email:
+- therearedemonsinsideofus@gmail.com
+- robin@robindaugherty.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- guard-eslint.gemspec
+- lib/guard/eslint.rb
+- lib/guard/eslint/runner.rb
+- lib/guard/eslint/version.rb
+homepage: https://github.com/RobinDaugherty/guard-eslint
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/RobinDaugherty/guard-eslint/releases
+  source_code_uri: https://github.com/RobinDaugherty/guard-eslint
+  bug_tracker_uri: https://github.com/RobinDaugherty/guard-eslint/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 eslint.
+test_files: []