guard-depend 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 821b438dfe03bb7111eaa0cf6b45f088659ceb78
-  data.tar.gz: 746b749a2995ef1d31011f7d40d127115852eed0
+  metadata.gz: 00df09e4254c38c259d76557dbd1f65970974f79
+  data.tar.gz: 8e7ba194f05a6fc527f0e533ff7a2e1c2033b76d
 SHA512:
-  metadata.gz: af2e9a246d265125720e9bc2e2a7cbd5509709cc0a2685ee4b37d10f449964fa73dd39238b436d93fa6ec38b2b15c65dc3bc803de090f5b9295df621e886edfb
-  data.tar.gz: 31fd55091e2c023b51fa54792d2d3c43e3741162127689217cb20872f45670be703674d6760af524c5beb8837b716687f8f373deff740cb4447d70abfcb9e74c
+  metadata.gz: 904eeeb984854f8773af7e76b2b99b2d90ee498e88eed335769de5d13465dd8bc525f54f4c45a26557385e758502a7d562e0b7fc6a666ca3cf9f37b5ab6e70fe
+  data.tar.gz: 3f8f1782b9540837b47a7bfe6d8a60e088dbd620b83aede903cb94561ac5ba2b7d3ee2c56f7b5f38a61b4aba6b0f583ab66ec891fd239d59d7477014350bd3ad

data/guard-depend.gemspec

@@ -5,7 +5,7 @@ require 'guard/depend/version'
 
 Gem::Specification.new do |s|
   s.name        = 'guard-depend'
-  s.version     = Guard::Depend::VERSION
+  s.version     = Guard::DependVersion::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Alexander Groß']
   s.email       = ['agross@therightstuff.de']

data/lib/guard/depend.rb

@@ -3,17 +3,26 @@ require 'guard/plugin'
 
 module Guard
   class Depend < Plugin
-    require 'guard/depend/options'
+    require 'guard/depend/detect'
     require 'guard/depend/runner'
 
+    DEFAULTS = {
+      run_on_start: false,
+      output_paths: [],
+      cmd: nil
+    }
+
+    attr_reader :options, :runner, :detect
+
     def initialize(options = {})
       super
-      @options = Options.with_defaults(options)
+      @options = DEFAULTS.merge(options)
       @runner = Runner.new
+      @detect = Detect.new(@options[:output_paths])
     end
 
     def start
-      UI.info 'Guard::Depend is running'
+      UI.info "#{self.class} is running"
       run_all if @options[:run_on_start]
     end
 
@@ -33,42 +42,7 @@ module Guard
 
     private
     def run_if_outdated(paths = [])
-      return false if paths.empty?
-
-      outdated = out_of_date?(paths, @options[:output_paths])
-      unless outdated
-        UI.debug("Output is not outdated with regard to #{paths}")
-        return
-      end
-
-      @runner.run(@options[:cmd])
-    end
-
-    def out_of_date?(input, output)
-      output = output.call if output.respond_to?(:call)
-
-      return true if input.nil? || input.empty? || output.nil? || output.empty?
-
-      input = input.max_by {|f| input_mtime(f) }
-      output = output.min_by {|f| output_mtime(f) }
-
-      input_time = input_mtime(input)
-      output_time = output_mtime(output)
-
-      UI.debug("Newest input file:  #{input_time} #{input}")
-      UI.debug("Oldest output file: #{output_time} #{output}")
-
-      return input_time > output_time
-    end
-
-    def input_mtime(file)
-      return Time.new(9999, 12, 31) unless File.readable?(file)
-      File.mtime(file)
-    end
-
-    def output_mtime(file)
-      return Time.new(0, 1, 1) unless File.readable?(file)
-      File.mtime(file)
+      @runner.run(@options[:cmd]) if detect.out_of_date?(paths)
     end
   end
 end

data/lib/guard/depend/detect.rb

@@ -0,0 +1,52 @@
+module Guard
+  class Depend
+    class Detect
+      attr_reader :output_paths
+
+      def initialize(output_paths = nil)
+        @output_paths = output_paths
+      end
+
+      def out_of_date?(paths = [])
+        paths = paths || []
+        return false if paths.empty?
+
+        outdated = check(paths, output)
+        UI.debug("#{output.join(', ')} is not outdated with regard to #{paths.join(', ')}") unless outdated
+
+        outdated
+      end
+
+      private
+      def output
+        paths = output_paths
+        paths = output_paths.call if output_paths.respond_to?(:call)
+
+        [paths].flatten.reject(&:nil?)
+      end
+
+      def check(input, output)
+        input = input.max_by { |f| input_mtime(f) }
+        output = output.min_by { |f| output_mtime(f) }
+
+        input_mtime = input_mtime(input)
+        output_mtime = output_mtime(output)
+
+        UI.debug("Newest input file:  #{input_mtime} #{input}")
+        UI.debug("Oldest output file: #{output_mtime} #{output}")
+
+        return input_mtime > output_mtime
+      end
+
+      def input_mtime(file)
+        return Time.new(9999, 12, 31) unless File.readable?(file)
+        File.mtime(file)
+      end
+
+      def output_mtime(file)
+        return Time.new(0, 1, 1) unless File.readable?(file)
+        File.mtime(file)
+      end
+    end
+  end
+end

data/lib/guard/depend/runner.rb

@@ -4,6 +4,8 @@ module Guard
   class Depend
     class Runner
       def run(cmd)
+        return unless cmd
+
         cmd = [cmd].flatten
         command = cmd.join(' ')
 

data/lib/guard/depend/version.rb

@@ -1,5 +1,5 @@
 module Guard
-  module Depend
-    VERSION = '0.0.1'
+  module DependVersion
+    VERSION = '0.1.0'
   end
 end

data/spec/guard/depend/detect_spec.rb

@@ -0,0 +1,188 @@
+require 'guard'
+require 'guard/depend'
+
+describe Guard::Depend::Detect do
+  before {
+    Guard::UI.stub(:info)
+    Guard::UI.stub(:debug)
+  }
+
+  describe 'defaults' do
+    its(:output_paths) { should be_nil }
+  end
+
+  describe 'overriding defaults' do
+    subject { described_class.new(1) }
+
+    its(:output_paths) { should == 1 }
+  end
+
+  context 'nil changed paths' do
+    it 'should not be out of date' do
+      subject.out_of_date?(nil).should == false
+    end
+  end
+
+  context 'omitted changed paths' do
+    it 'should not be out of date' do
+      subject.out_of_date?.should == false
+    end
+  end
+
+  context 'no changed paths' do
+    it 'should not be out of date' do
+      subject.out_of_date?([]).should == false
+    end
+  end
+
+  shared_examples :reports_files do
+    it 'should report newest input' do
+      expect(Guard::UI).to have_received(:debug).with(/^Newest input file/)
+    end
+
+    it 'should report oldest output' do
+      expect(Guard::UI).to have_received(:debug).with(/^Oldest output file/)
+    end
+  end
+
+  shared_examples :outdated do
+    it 'should be out of date' do
+      @outdated.should == true
+    end
+
+    it 'should not report non-outdatedness' do
+      expect(Guard::UI).to_not have_received(:debug).with(/is not outdated with regard to/)
+    end
+  end
+
+  shared_examples :not_outdated do
+    it 'should not be out of date' do
+      @outdated.should == false
+    end
+
+    it 'should report non-outdatedness' do
+      expect(Guard::UI).to have_received(:debug).with('output is not outdated with regard to input')
+    end
+  end
+
+  context '#out_of_date?' do
+    describe 'single input and output' do
+      let(:input_mtime) {}
+      let(:output_mtime) {}
+
+      before {
+        File.stub(:readable?).and_return(false)
+
+        if input_mtime
+          File.stub(:readable?).with('input').and_return(true)
+          File.stub(:mtime).with('input').and_return(input_mtime)
+        end
+
+        if output_mtime
+          File.stub(:readable?).with('output').and_return(true)
+          File.stub(:mtime).with('output').and_return(output_mtime)
+        end
+      }
+
+      subject { described_class.new('output') }
+
+      before { @outdated = subject.out_of_date?(%w(input)) }
+
+      context 'output was deleted' do
+        let(:input_mtime) { Time.now }
+
+        it_behaves_like :reports_files
+        it_behaves_like :outdated
+      end
+
+      context 'input was deleted' do
+        let(:output_mtime) { Time.now }
+
+        it_behaves_like :reports_files
+        it_behaves_like :outdated
+      end
+
+      context 'input is newer than output' do
+        let(:input_mtime) { Time.at(1) }
+        let(:output_mtime) { Time.at(0) }
+
+        it_behaves_like :reports_files
+        it_behaves_like :outdated
+      end
+
+      context 'input is older than output' do
+        let(:input_mtime) { Time.at(0) }
+        let(:output_mtime) { Time.at(1) }
+
+        it_behaves_like :reports_files
+        it_behaves_like :not_outdated
+      end
+
+      context 'input has the same mtime as output' do
+        let(:input_mtime) { Time.at(0) }
+        let(:output_mtime) { Time.at(0) }
+
+        it_behaves_like :reports_files
+        it_behaves_like :not_outdated
+      end
+
+      context 'output is callable' do
+        let(:output_mtime) { Time.at(0) }
+
+        subject { described_class.new(Proc.new { 'output' }) }
+
+        it 'should call' do
+          expect(File).to have_received(:mtime).with('output').at_least(:once)
+        end
+      end
+
+      context 'output is nil' do
+        subject { described_class.new(nil) }
+
+        it_behaves_like :outdated
+      end
+
+      context 'output is empty' do
+        subject { described_class.new([]) }
+
+        it_behaves_like :outdated
+      end
+    end
+
+    describe 'multiple inputs' do
+      before {
+        File.stub(:readable?).and_return(true)
+
+        File.stub(:mtime).with('input old').and_return(Time.at(0))
+        File.stub(:mtime).with('input new').and_return(Time.at(1))
+        File.stub(:mtime).with('output').and_return(Time.at(0))
+      }
+
+      subject { described_class.new(['output']) }
+
+      before { @outdated = subject.out_of_date?(['input old', 'input new']) }
+
+      it 'should use newest input' do
+        expect(Guard::UI).to have_received(:debug).with(/^Newest input.+input new$/)
+      end
+    end
+
+    describe 'multiple outputs' do
+      before {
+        File.stub(:readable?).and_return(true)
+
+        File.stub(:mtime).with('input').and_return(Time.at(0))
+        File.stub(:mtime).with('output old').and_return(Time.at(0))
+        File.stub(:mtime).with('output new').and_return(Time.at(1))
+      }
+
+      subject { described_class.new(['output new', 'output old']) }
+
+      before { @outdated = subject.out_of_date?(%w(input)) }
+
+      it 'should use oldest output' do
+        expect(Guard::UI).to have_received(:debug).with(/^Oldest output.+output old$/)
+      end
+    end
+  end
+end

data/spec/guard/depend/runner_spec.rb

@@ -0,0 +1,87 @@
+require 'guard'
+require 'guard/depend'
+
+describe Guard::Depend::Runner do
+  before {
+    Guard::UI.stub(:info)
+    Guard::UI.stub(:error)
+    Guard::UI.stub(:debug)
+
+    Guard::Notifier.stub(:notify)
+  }
+
+  let(:error) { nil }
+
+  before {
+    next subject.stub(:sh).and_raise(error) if error
+    subject.stub(:sh)
+  }
+
+  describe 'command execution' do
+    context 'no command' do
+      before { subject.run(nil) }
+
+      it 'should not run' do
+        expect(subject).to_not have_received(:sh)
+      end
+    end
+
+    context 'command without parameters' do
+      before { subject.run('command') }
+
+      it 'should run using #sh' do
+        expect(subject).to have_received(:sh).with('command')
+      end
+    end
+
+    context 'command with parameters' do
+      before { subject.run(%w(command arg)) }
+
+      it 'should run using #sh' do
+        expect(subject).to have_received(:sh).with('command', 'arg')
+      end
+    end
+  end
+
+  describe 'reporting' do
+    before { subject.run(%w(command arg)) }
+
+    context 'success' do
+      it 'should report command running info' do
+        expect(Guard::UI).to have_received(:info).with("Running 'command arg'")
+      end
+
+      it 'should notify running' do
+        expect(Guard::Notifier).to have_received(:notify).with('command arg', title: 'Running', image: :success)
+      end
+
+      it 'should notify success' do
+        expect(Guard::Notifier).to have_received(:notify).with('command arg succeeded', title: 'Success', image: :success)
+      end
+    end
+
+    context 'failure' do
+      let(:error) { StandardError.new('something bad happened') }
+
+      it 'should report command running info' do
+        expect(Guard::UI).to have_received(:info).with("Running 'command arg'")
+      end
+
+      it 'should report command failure error' do
+        expect(Guard::UI).to have_received(:error).with("Failed to run 'command arg'. Exception was: StandardError: something bad happened")
+      end
+
+      it 'should report command failure backtrace' do
+        expect(Guard::UI).to have_received(:debug)
+      end
+
+      it 'should notify running' do
+        expect(Guard::Notifier).to have_received(:notify).with('command arg', title: 'Running', image: :success)
+      end
+
+      it 'should notify failure' do
+        expect(Guard::Notifier).to have_received(:notify).with('command arg failed with something bad happened', title: 'Failed', image: :failed)
+      end
+    end
+  end
+end

data/spec/guard/depend_spec.rb

@@ -0,0 +1,99 @@
+require 'guard'
+require 'guard/depend'
+
+describe Guard::Depend do
+  let(:command) {}
+  let(:output_paths) { [] }
+  let(:run_on_start) { false }
+
+  subject { described_class.new(cmd: command, output_paths: output_paths, run_on_start: run_on_start) }
+
+  before { subject.runner.stub(:run) }
+
+  before { Guard::UI.stub(:info) }
+
+  describe 'defaults' do
+    subject { described_class.new }
+
+    its(:options) { should include(cmd: nil) }
+    its(:options) { should include(output_paths: []) }
+    its(:options) { should include(run_on_start: false) }
+    its(:runner) { should be_an_instance_of(Guard::Depend::Runner) }
+    its(:detect) { should be_an_instance_of(Guard::Depend::Detect) }
+  end
+
+  describe 'overriding defaults' do
+    let(:command) { 'command' }
+    let(:output_paths) { '1' }
+    let(:run_on_start) { true }
+
+    its(:options) { should include(cmd: 'command') }
+    its(:options) { should include(output_paths: '1') }
+    its(:options) { should include(run_on_start: true) }
+    its(:runner) { should be_an_instance_of(Guard::Depend::Runner) }
+    its(:detect) { should be_an_instance_of(Guard::Depend::Detect) }
+  end
+
+  describe '#start' do
+    before { subject.stub(:run_all) }
+    before { subject.start }
+
+    it 'should write info' do
+      expect(Guard::UI).to have_received(:info).with("#{described_class} is running")
+    end
+
+    context 'run_on_start enabled' do
+      let(:run_on_start) { true }
+
+      it 'should run' do
+        expect(subject).to have_received(:run_all)
+      end
+    end
+
+    context 'run_on_start disabled' do
+      let(:run_on_start) { false }
+
+      it 'should not run' do
+        expect(subject).to_not have_received(:run_all)
+      end
+    end
+  end
+
+  describe '#run_all' do
+    let(:command) { 'command' }
+
+    before { subject.runner.stub(:run) }
+
+    before { subject.run_all }
+
+    it 'should run command' do
+      expect(subject.runner).to have_received(:run).with('command')
+    end
+  end
+
+  describe '#run_on_changes' do
+    let(:command) { 'command' }
+
+    context 'outdated' do
+      before {
+        subject.detect.stub(:out_of_date?).and_return(true)
+        subject.run_on_changes
+      }
+
+      it 'should run command' do
+        expect(subject.runner).to have_received(:run).with('command')
+      end
+    end
+
+    context 'not outdated' do
+      before {
+        subject.detect.stub(:out_of_date?).and_return(false)
+        subject.run_on_changes
+      }
+
+      it 'should not run command' do
+        expect(subject.runner).to_not have_received(:run)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-depend
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Alexander Groß
@@ -14,112 +14,112 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rspec
   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: guard-bundler
   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: guard-rspec
   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: ruby_gntp
   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: wdm
   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: Run commands only if build output is not up to date.
@@ -129,7 +129,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .gitignore
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -137,10 +137,13 @@ files:
 - Rakefile
 - guard-depend.gemspec
 - lib/guard/depend.rb
-- lib/guard/depend/options.rb
+- lib/guard/depend/detect.rb
 - lib/guard/depend/runner.rb
 - lib/guard/depend/templates/Guardfile
 - lib/guard/depend/version.rb
+- spec/guard/depend/detect_spec.rb
+- spec/guard/depend/runner_spec.rb
+- spec/guard/depend_spec.rb
 - spec/spec_helper.rb
 homepage: http://grossweber.com
 licenses:
@@ -152,12 +155,12 @@ 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: []
@@ -169,4 +172,7 @@ summary: guard-depend is useful for projects that produce build output like bina
   guard-depend will only run the command you sify if the build output does not exists
   or is not up to date with regard to the watched files.
 test_files:
+- spec/guard/depend/detect_spec.rb
+- spec/guard/depend/runner_spec.rb
+- spec/guard/depend_spec.rb
 - spec/spec_helper.rb

data/lib/guard/depend/options.rb

@@ -1,28 +0,0 @@
-module Guard
-  class Depend
-    module Options
-      DEFAULTS = {
-          run_on_start:    false,
-          output_paths:    [],
-          cmd:             nil
-      }
-
-      class << self
-        def with_defaults(options = {})
-          _deep_merge(DEFAULTS, options)
-        end
-
-        private
-        def _deep_merge(hash1, hash2)
-          hash1.merge(hash2) do |key, oldval, newval|
-            if oldval.instance_of?(Hash) && newval.instance_of?(Hash)
-              _deep_merge(oldval, newval)
-            else
-              newval
-            end
-          end
-        end
-      end
-    end
-  end
-end