filewatcher 1.1.1 → 2.0.0.beta5

data/lib/filewatcher/env.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require_relative '../filewatcher'
-
-class Filewatcher
-  # Class for building ENV variables for executable
-  class Env
-    def initialize(filename, event)
-      @filename = filename
-      @event = event
-      @path = Pathname.new(@filename)
-      @realpath = @path.exist? ? @path.realpath : @path
-      @current_dir = Pathname.new(Dir.pwd)
-      # For safely `immediate` option with empty-strings arguments
-      @relative_path =
-        (@realpath.to_s.empty? ? @current_dir : @realpath)
-          .relative_path_from(@current_dir)
-    end
-
-    def to_h
-      {
-        'FILEPATH' => (@realpath.to_s if @event != :deleted),
-        'FILENAME' => @filename,
-        'BASENAME' => @path.basename.to_s,
-        'EVENT' => @event.to_s,
-        'DIRNAME' => @path.parent.realpath.to_s,
-        'ABSOLUTE_FILENAME' => @realpath.to_s,
-        'RELATIVE_FILENAME' => @relative_path.to_s
-      }
-    end
-  end
-end

data/lib/filewatcher/runner.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Filewatcher
-  ## Get runner command by filename
-  class Runner
-    ## Define runners for `--exec` option
-    RUNNERS = {
-      python: %w[py],
-      node:   %w[js],
-      ruby:   %w[rb],
-      perl:   %w[pl],
-      awk:    %w[awk],
-      php:    %w[php phtml php4 php3 php5 phps]
-    }.freeze
-
-    def initialize(filename)
-      @filename = filename
-      @ext = File.extname(filename).delete('.')
-    end
-
-    def command
-      "env #{runner} #{@filename}" if runner
-    end
-
-    private
-
-    def runner
-      return @runner if defined?(@runner)
-      @runner, _exts = RUNNERS.find { |_cmd, exts| exts.include? @ext }
-      @runner
-    end
-  end
-end

data/test/dumpers/env_dumper.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-dump_to_env_file(
-  %w[
-    FILENAME BASENAME EVENT DIRNAME ABSOLUTE_FILENAME
-    RELATIVE_FILENAME
-  ].map { |var| ENV[var] }.join(', ')
-)

data/test/dumpers/watched_dumper.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-dump_to_env_file 'watched'

data/test/filewatcher/test_env.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/filewatcher/env'
-
-describe Filewatcher::Env do
-  describe '#initialize' do
-    it 'should recieve filename and event' do
-      -> { Filewatcher::Env.new(__FILE__, :updated) }
-        .should.not.raise ArgumentError
-    end
-  end
-
-  describe '#to_h' do
-    before do
-      @init = proc do |file: __FILE__, event: :updated|
-        Filewatcher::Env.new(file, event).to_h
-      end
-      @env = @init.call
-    end
-
-    it 'should return Hash' do
-      @env.should.be.kind_of Hash
-    end
-
-    it 'should return Hash with FILEPATH key for created event' do
-      @init.call(event: :created)['FILEPATH']
-        .should.equal File.join(Dir.pwd, __FILE__)
-    end
-
-    it 'should return Hash with FILEPATH key for updated event' do
-      @init.call(event: :updated)['FILEPATH']
-        .should.equal File.join(Dir.pwd, __FILE__)
-    end
-
-    it 'should return Hash without FILEPATH key for deleted event' do
-      @init.call(event: :deleted)['FILEPATH']
-        .should.equal nil
-    end
-
-    it 'should return Hash with FILENAME key' do
-      @init.call(file: __FILE__)['FILENAME']
-        .should.equal __FILE__
-    end
-
-    it 'should return Hash with BASENAME key' do
-      @init.call(file: __FILE__)['BASENAME']
-        .should.equal File.basename(__FILE__)
-    end
-
-    it 'should return Hash with EVENT key' do
-      @init.call(event: :updated)['EVENT']
-        .should.equal 'updated'
-    end
-
-    it 'should return Hash with DIRNAME key' do
-      @init.call(file: __FILE__)['DIRNAME']
-        .should.equal File.dirname(File.join(Dir.pwd, __FILE__))
-    end
-
-    it 'should return Hash with ABSOLUTE_FILENAME key' do
-      @init.call(file: __FILE__)['ABSOLUTE_FILENAME']
-        .should.equal File.join(Dir.pwd, __FILE__)
-    end
-
-    it 'should return Hash with RELATIVE_FILENAME key' do
-      @init.call(file: __FILE__)['RELATIVE_FILENAME']
-        .should.equal __FILE__
-    end
-  end
-end

data/test/filewatcher/test_runner.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/filewatcher/runner'
-
-describe Filewatcher::Runner do
-  before do
-    @init = proc do |filename|
-      Filewatcher::Runner.new(filename)
-    end
-  end
-
-  describe '#initialize' do
-    it 'should recieve filename' do
-      -> { @init.call('file.txt') }
-        .should.not.raise ArgumentError
-    end
-  end
-
-  describe '#command' do
-    it 'should return correct command for file with .py extension' do
-      @init.call('file.py').command
-        .should.equal 'env python file.py'
-    end
-
-    it 'should return correct command for file with .js extension' do
-      @init.call('file.js').command
-        .should.equal 'env node file.js'
-    end
-
-    it 'should return correct command for file with .rb extension' do
-      @init.call('file.rb').command
-        .should.equal 'env ruby file.rb'
-    end
-
-    it 'should return correct command for file with .pl extension' do
-      @init.call('file.pl').command
-        .should.equal 'env perl file.pl'
-    end
-
-    it 'should return correct command for file with .awk extension' do
-      @init.call('file.awk').command
-        .should.equal 'env awk file.awk'
-    end
-
-    it 'should return correct command for file with .php extension' do
-      @init.call('file.php').command
-        .should.equal 'env php file.php'
-    end
-
-    it 'should return correct command for file with .phtml extension' do
-      @init.call('file.phtml').command
-        .should.equal 'env php file.phtml'
-    end
-
-    it 'should return correct command for file with .php4 extension' do
-      @init.call('file.php4').command
-        .should.equal 'env php file.php4'
-    end
-
-    it 'should return correct command for file with .php3 extension' do
-      @init.call('file.php3').command
-        .should.equal 'env php file.php3'
-    end
-
-    it 'should return correct command for file with .php5 extension' do
-      @init.call('file.php5').command
-        .should.equal 'env php file.php5'
-    end
-
-    it 'should return correct command for file with .phps extension' do
-      @init.call('file.phps').command
-        .should.equal 'env php file.phps'
-    end
-  end
-end

data/test/filewatcher/test_version.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/filewatcher/version'
-
-describe Filewatcher::VERSION do
-  it 'should exist as constant' do
-    Filewatcher.const_defined?(:VERSION).should.be.true
-  end
-
-  it 'should be an instance of String' do
-    Filewatcher::VERSION.class.should.equal String
-  end
-end

data/test/helper.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-require 'bacon'
-require 'bacon/custom_matchers_messages'
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-  nil
-end
-
-class WatchRun
-  TMP_DIR = File.join(__dir__, 'tmp')
-
-  attr_reader :filename
-
-  def initialize(
-    filename: 'tmp_file.txt',
-    directory: false,
-    action: :update
-  )
-    @filename =
-      filename =~ %r{^(/|~|[A-Z]:)} ? filename : File.join(TMP_DIR, filename)
-    @directory = directory
-    @action = action
-  end
-
-  def start
-    File.write(@filename, 'content1') unless @action == :create
-  end
-
-  def run
-    start
-
-    make_changes
-
-    stop
-  end
-
-  def stop
-    FileUtils.rm_r(@filename) if File.exist?(@filename)
-  end
-
-  private
-
-  def make_changes
-    if @action == :delete
-      FileUtils.remove(@filename)
-    elsif @directory
-      FileUtils.mkdir_p(@filename)
-    else
-      File.write(@filename, 'content2')
-    end
-  end
-end
-
-class RubyWatchRun < WatchRun
-  SLEEP_MULTIPLIER = Gem::Platform.local.os == 'darwin' ? 5 : 1
-
-  attr_reader :filewatcher, :thread, :watched, :processed
-
-  def initialize(
-    every: false,
-    filewatcher: Filewatcher.new(
-      File.join(TMP_DIR, '**', '*'), interval: 0.1, every: every
-    ),
-    **args
-  )
-    super(**args)
-    @filewatcher = filewatcher
-  end
-
-  def start
-    super
-    @thread = thread_initialize
-    # thread needs a chance to start
-    wait 12 do
-      filewatcher.keep_watching
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-  end
-
-  def stop
-    thread.exit
-
-    wait 12 do
-      thread.stop?
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-
-    super
-  end
-
-  private
-
-  def make_changes
-    super
-
-    # Some OS, filesystems and Ruby interpretators
-    # doesn't catch milliseconds of `File.mtime`
-    wait 12 do
-      processed.any?
-    end
-  end
-
-  def thread_initialize
-    @watched ||= 0
-    Thread.new(
-      @filewatcher, @processed = []
-    ) do |filewatcher, processed|
-      filewatcher.watch do |filename, event|
-        increment_watched
-        processed.push([filename, event])
-      end
-    end
-  end
-
-  def increment_watched
-    @watched += 1
-  end
-
-  def wait(seconds)
-    max_count = seconds / filewatcher.interval
-    count = 0
-    while count < max_count && !yield
-      sleep filewatcher.interval
-      count += 1
-    end
-  end
-end
-
-class ShellWatchRun < WatchRun
-  EXECUTABLE = "#{'ruby ' if Gem.win_platform?}" \
-    "#{File.realpath File.join(__dir__, '..', 'bin', 'filewatcher')}".freeze
-
-  SLEEP_MULTIPLIER = RUBY_PLATFORM == 'java' ? 5 : 1
-
-  ENV_FILE = File.join(TMP_DIR, 'env')
-
-  def initialize(
-    options: {},
-    dumper: :watched,
-    **args
-  )
-    super(**args)
-    @options = options
-    @options[:interval] ||= 0.1
-    @options_string =
-      @options.map { |key, value| "--#{key}=#{value}" }.join(' ')
-    @dumper = dumper
-  end
-
-  def start
-    super
-
-    @pid = spawn_filewatcher
-
-    Process.detach(@pid)
-
-    wait 12 do
-      pid_state == 'S' && (!@options[:immediate] || File.exist?(ENV_FILE))
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-  end
-
-  def stop
-    kill_filewatcher
-
-    wait 12 do
-      pid_state.empty?
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-
-    super
-  end
-
-  private
-
-  SPAWN_OPTIONS = Gem.win_platform? ? {} : { pgroup: true }
-
-  def spawn_filewatcher
-    spawn(
-      "#{EXECUTABLE} #{@options_string} \"#{@filename}\"" \
-        " \"ruby #{File.join(__dir__, "dumpers/#{@dumper}_dumper.rb")}\"",
-      **SPAWN_OPTIONS
-    )
-  end
-
-  def make_changes
-    super
-
-    wait 12 do
-      File.exist?(ENV_FILE)
-    end
-  end
-
-  def kill_filewatcher
-    if Gem.win_platform?
-      Process.kill('KILL', @pid)
-    else
-      ## Problems: https://github.com/thomasfl/filewatcher/pull/83
-      ## Solution: https://stackoverflow.com/a/45032252/2630849
-      Process.kill('TERM', -Process.getpgid(@pid))
-      Process.waitall
-    end
-  end
-
-  def pid_state
-    ## For macOS output:
-    ## https://travis-ci.org/thomasfl/filewatcher/jobs/304433538
-    `ps -ho state -p #{@pid}`.sub('STAT', '').strip
-  end
-
-  def wait(seconds)
-    max_count = seconds / @options[:interval]
-    count = 0
-    while count < max_count && !yield
-      sleep @options[:interval]
-      count += 1
-    end
-  end
-end
-
-custom_matcher :include_all_files do |obj, elements|
-  elements.all? { |element| obj.include? File.expand_path(element) }
-end
-
-def dump_to_env_file(content)
-  File.write File.join(ShellWatchRun::ENV_FILE), content
-end