listen 2.8.1 → 2.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 564ec4894c98d82d45f5fe13552779dc82a99aef
-  data.tar.gz: 564f4150846dd6a22741af85af7576b474f878b1
+  metadata.gz: 82833c1dcd0ed421fcb93115f1c764492148b1f4
+  data.tar.gz: 407619ca1bdba240ae918e4e3e73e237f129f132
 SHA512:
-  metadata.gz: 69319e63efa594a612acae069cba16a0df900e2ba92ba0c110ef088833929d82197b0c7ff03f549c4b27d9db211093f2278a02e56ee57b5f541f53ebad926985
-  data.tar.gz: 645d9ed317278c3abee4df7f2ded2810d46f9bacb42514fe8deeb37b9898b294aaf59975e786cb16b0832b94dd7a5560a664603d9243f20bdb83a66c75a54c0e
+  metadata.gz: 03f0ba222830c725718adf106e479a559b183d663009c7482c35bf252c9c41799d3d824692ac30716ddf62ada053610400391b67c3d8caa82eb9a715ad3d16d7
+  data.tar.gz: eaa55b1eaae113d97e621f6de5fb657186f584f0d1c6cd1051c17368702867e6b816047d9868114863118addbc73f413f7850b040d49c2631eb0699ae6b84763

data/Rakefile

@@ -10,3 +10,142 @@ if ENV["CI"] != "true"
 else
   task default: [:spec]
 end
+
+class Releaser
+  def initialize(options = {})
+    @project_name = options.delete(:project_name) do
+      fail "project_name is needed!"
+    end
+
+    @gem_name = options.delete(:gem_name) do
+      fail "gem_name is needed!"
+    end
+
+    @github_repo = options.delete(:github_repo) do
+      fail "github_repo is needed!"
+    end
+
+    @version = options.delete(:version) do
+      fail "version is needed!"
+    end
+  end
+
+  def full
+    rubygems
+    github
+  end
+
+  def rubygems
+    begin
+      STDOUT.puts "Release #{@project_name} #{@version} to RubyGems? (y/n)"
+      input = STDIN.gets.chomp.downcase
+    end while !%w(y n).include?(input)
+
+    exit if input == "n"
+
+    Rake::Task["release"].invoke
+  end
+
+  def github
+    tag_name = "v#{@version}"
+
+    require "gems"
+
+    _verify_released
+    _verify_tag_pushed
+
+    require "octokit"
+    gh_client = Octokit::Client.new(netrc: true)
+
+    gh_release = _detect_gh_release(gh_client, tag_name, true)
+    return unless gh_release
+
+    STDOUT.puts "Draft release for #{tag_name}:\n"
+    STDOUT.puts gh_release.body
+    STDOUT.puts "\n-------------------------\n\n"
+
+    _confirm_publish
+
+    return unless _update_release(gh_client, gh_release, tag_name)
+
+    gh_release = _detect_gh_release(gh_client, tag_name, false)
+
+    _success_summary(gh_release, tag_name)
+  end
+
+  private
+
+  def _verify_released
+    if @version != Gems.info(@gem_name)["version"]
+      STDOUT.puts "#{@project_name} #{@version} is not yet released."
+      STDOUT.puts "Please release it first with: rake release:gem"
+      exit
+    end
+  end
+
+  def _verify_tag_pushed
+    tags = `git ls-remote --tags origin`.split("\n")
+    return if tags.detect { |tag| tag =~ /v#{@version}$/ }
+
+    STDOUT.puts "The tag v#{@version} has not yet been pushed."
+    STDOUT.puts "Please push it first with: rake release:gem"
+    exit
+  end
+
+  def _success_summary(gh_release, tag_name)
+    href = gh_release.rels[:html].href
+    STDOUT.puts "GitHub release #{tag_name} has been published!"
+    STDOUT.puts "\nPlease enjoy and spread the word!"
+    STDOUT.puts "Lack of inspiration? Here's a tweet you could improve:\n\n"
+    STDOUT.puts "Just released #{@project_name} #{@version}! #{href}"
+  end
+
+  def _detect_gh_release(gh_client, tag_name, draft)
+    gh_releases = gh_client.releases(@github_repo)
+    gh_releases.detect { |r| r.tag_name == tag_name && r.draft == draft }
+  end
+
+  def _confirm_publish
+    begin
+      STDOUT.puts "Would you like to publish this GitHub release now? (y/n)"
+      input = STDIN.gets.chomp.downcase
+    end while !%w(y n).include?(input)
+
+    exit if input == "n"
+  end
+
+  def _update_release(gh_client, gh_release, tag_name)
+    result = gh_client.update_release(gh_release.rels[:self].href, draft: false)
+    return true if result
+    STDOUT.puts "GitHub release #{tag_name} couldn't be published!"
+    false
+  end
+end
+
+PROJECT_NAME = "Listen"
+CURRENT_VERSION = Listen::VERSION
+
+def releaser
+  $releaser ||= Releaser.new(
+    project_name: PROJECT_NAME,
+    gem_name: "guard",
+    github_repo: "guard/guard",
+    version: CURRENT_VERSION)
+end
+
+namespace :release do
+  desc "Push #{PROJECT_NAME} #{CURRENT_VERSION} to RubyGems and publish"\
+    " its GitHub release"
+
+  task full: ["release:gem", "release:github"]
+
+  desc "Push #{PROJECT_NAME} #{CURRENT_VERSION} to RubyGems"
+  task :gem do
+    releaser.rubygems
+  end
+
+  desc "Publish #{PROJECT_NAME} #{CURRENT_VERSION} GitHub release"
+  task :github do
+    releaser.github
+  end
+end

data/lib/listen/record.rb

@@ -115,12 +115,12 @@ module Listen
 
     def _fast_build_dir(remaining, symlink_detector)
       entry = remaining.pop
-      entry.children.each { |child| remaining << child }
       symlink_detector.verify_unwatched!(entry)
+      entry.children.each { |child| remaining << child }
       add_dir(entry.root, entry.record_dir_key)
     rescue Errno::ENOTDIR
       _fast_try_file(entry)
-    rescue SystemCallError
+    rescue SystemCallError, SymlinkDetector::Error
       _fast_unset_path(entry.root, entry.relative, entry.name)
     end
 

data/lib/listen/record/symlink_detector.rb

@@ -4,43 +4,21 @@ module Listen
   # @private api
   class Record
     class SymlinkDetector
-      SYMLINK_LOOP_ERROR = <<-EOS
-        ** ERROR: Listen detected a duplicate directory being watched! **
-
-        (This may be due to multiple symlinks pointing to already watched dirs).
-
-        Duplicate: %s
-
-        which already is added as: %s
-
-        Listen is refusing to continue, because it may cause an infinite loop,
-        a crash or confusing results.
-
-        Suggestions:
+      WIKI = 'https://github.com/guard/listen/wiki/Duplicate-directory-errors'
 
-          1) (best option) watch only directories you care about (e.g.
-          either symlinked folders or folders with the real directories,
-          but not both).
-
-          IMPORTANT: The `:ignore` options DO NOT HELP here
-          (see: https://github.com/guard/listen/issues/274)
-
-          NOTE: If you are using Listen through some other application
-          (like Guard, Compass, Jekyll, Vagrant), check the documentation on
-          selecting watched directories (e.g. Guard has a `-w` option, Compass
-          allows you to specify multiple input/output directories, etc.)
+      SYMLINK_LOOP_ERROR = <<-EOS
+        ** ERROR: directory is already being watched! **
 
-          2) reorganize your project so that watched directories do not
-          contain symlinked directories
+        Directory: %s
 
-          3) submit patches so that Listen can reliably and quickly (!)
-          detect symlinks to already watched read directories, skip
-          them, and then reasonably choose which symlinked paths to
-          report as changed (if any)
+        is already begin watched through: %s
 
-        Issue: https://github.com/guard/listen/issues/259
+        MORE INFO: #{WIKI}
       EOS
 
+      class Error < RuntimeError
+      end
+
       def initialize
         @real_dirs = Set.new
       end
@@ -54,9 +32,7 @@ module Listen
 
       def _fail(symlinked, real_path)
         STDERR.puts format(SYMLINK_LOOP_ERROR, symlinked, real_path)
-
-        # Note Celluloid eats up abort message anyway
-        fail 'Failed due to looped symlinks'
+        fail Error, 'Failed due to looped symlinks'
       end
     end
   end

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.8.1'
+  VERSION = '2.8.2'
 end

data/spec/lib/listen/record_spec.rb

@@ -232,6 +232,10 @@ describe Listen::Record do
 
         allow(::File).to receive(:realpath).with('/dir1').and_return('/dir1')
         allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
+        allow(::File).to receive(:realpath).with('/dir1/foo').
+          and_return('/dir1/foo')
+        allow(::File).to receive(:realpath).with('/dir1/bar').
+          and_return('/dir1/bar')
       end
 
       it 'builds record' do
@@ -256,6 +260,8 @@ describe Listen::Record do
         allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
         allow(::File).to receive(:realpath).with('/dir1/foo').
           and_return('/dir1/foo')
+        allow(::File).to receive(:realpath).with('/dir1/foo/bar').
+          and_return('/dir1/foo/bar')
       end
 
       it 'builds record'  do
@@ -295,15 +301,19 @@ describe Listen::Record do
       before do
         allow(::Dir).to receive(:entries).with('/dir1') { %w(foo) }
         allow(::Dir).to receive(:entries).with('/dir1/foo') { %w(foo) }
+        allow(::Dir).to receive(:entries).with('/dir2') { [] }
         allow(::File).to receive(:realpath).with('/dir1').and_return('/bar')
         allow(::File).to receive(:realpath).with('/dir1/foo').and_return('/bar')
+        allow(::File).to receive(:realpath).with('/dir2').and_return('/dir2')
       end
 
       it 'shows message and aborts with error' do
-        expect(STDERR).to receive(:puts).with(/detected a duplicate directory/)
+        expect(STDERR).to receive(:puts).
+          with(/directory is already being watched/)
 
-        expect { record.build }.to raise_error(RuntimeError,
-                                               /Failed due to looped symlinks/)
+        record.build
+        # expect { record.build }.
+        # to raise_error(RuntimeError, /Failed due to looped symlinks/)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: listen
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.8.2
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-24 00:00:00.000000000 Z
+date: 2014-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid