nite-owl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98012eb7fa0d83d070a5ea27e9a802124506d3f8
+  data.tar.gz: 68149cdad3bcb5156e72318ad43b0354be15f63f
+SHA512:
+  metadata.gz: cbba57bfcd8f61d35a1bacb5d80c4cb2b520af292688d01e2f6def2a6d10095b4eb3b8b9f41b92abdb5d98760ca09251550190b252a53ad95b1ee4e7a8491414
+  data.tar.gz: 1ec829878b577acc16a501a0d75a494223bb1a71c69aa380b5b8a6268e0ad8a26871ab0d8767ab8a3b1177dc3dbc356575faff35b12fae7f671f928e06489d07

data/.gitignore

@@ -0,0 +1,12 @@
+*.lock
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nite-owl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 troydm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Niteowl

@@ -0,0 +1,14 @@
+whenever(/.*rb/)
+  .changes
+  .after(5.seconds)
+  .if_not {
+    false
+  }
+  .run do |n,f|
+    puts "Hello World"
+    cancel
+    shell "ls -lh"
+  end
+  .also.run do |n,f|
+    puts "Change detected "+n.to_s+" "+f.to_s
+  end

data/README.md

@@ -0,0 +1,29 @@
+# Nite::Owl [![Gem Version](https://badge.fury.io/rb/nite-owl.svg)](https://badge.fury.io/rb/nite-owl) [![Build Status](https://travis-ci.org/troydm/nite-owl.png?branch=master)](https://travis-ci.org/troydm/nite-owl)
+
+Nite Owl watches over your files and executes commands if anything happens to them, it's like [guard](https://github.com/guard/guard) on a super diet!
+Supports linux and macos only and depends only on rb-fsevent and rb-inotify.
+
+## Installation
+
+To install just run this command:
+
+    $ gem install nite-owl
+
+## Usage
+
+Create Niteowl configuration file inside a directory you want to watch over and the run nite-owl.
+See example Niteowl configuration file.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/troydm/nite-owl.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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 "nite/owl"
+
+# 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(__FILE__)

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/exe/nite-owl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require "nite/owl"
+
+if ARGV.empty?
+  Nite::Owl::NiteOwl.instance.watch(Dir.pwd)
+else
+  Nite::Owl::NiteOwl.instance.watch(ARGV[0])
+end
+
+Nite::Owl::NiteOwl.instance.start

data/lib/nite/owl.rb

@@ -0,0 +1,2 @@
+require "nite/owl/version"
+require "nite/owl/niteowl"

data/lib/nite/owl/niteowl.rb

@@ -0,0 +1,564 @@
+require 'open3'
+
+# Nite Owl DSL
+def quote(path)
+  if path.include? " "
+    "\"#{path}\""
+  else
+    path
+  end
+end
+
+def cd(dir)
+  Dir.chdir quote(dir)
+  puts "cd #{dir}"
+end
+
+def pwd
+  d = Dir.pwd
+  puts "pwd: #{d}"
+  d
+end
+
+def whenever(files)
+  if files.is_a?(String) or files.is_a?(Regexp)
+    files = [files]
+  end
+  Nite::Owl::NiteOwl.instance.whenever(files)
+end
+
+def action
+  Nite::Owl::NiteOwl.instance.current_action()
+end
+
+def delay(time)
+  action.delay(time)
+end
+
+def cancel
+  action.cancel
+end
+
+# Run command in shell and redirect it's output to stdout and stderr
+def shell(command,options={:verbose => false,:silent => false,:stdin => nil})
+  stdout = ""
+  stderr = ""
+  verbose = options[:verbose]
+  silent = options[:silent]
+  stdin = options[:stdin]
+  if verbose
+    puts "Executing: #{command}"
+  end
+  Open3.popen3(command) do |i,o,e,t|
+    stdin_i = 0
+    stdin_open = stdin != nil
+    stdout_buffer = ""
+    stderr_buffer = ""
+    stdout_open = true
+    stderr_open = true
+    stdout_ch = nil
+    stderr_ch = nil
+    while stdout_open or stderr_open or stdin_open
+      if stdin_open
+        begin
+          p stdin
+          i.write(stdin)
+          i.close_write
+          stdin_open = false
+          #c = i.write_nonblock(stdin[stdin_i])
+          #if c > 0
+          #  stdin_i += 1
+          #  if stdin_i == stdin.size
+          #    i.close_write
+          #    stdin_open = false
+          #  end
+          #end
+        rescue IO::WaitWritable
+          IO.select([i])
+          puts "retry writeable"
+          retry
+        rescue EOFError
+          stdin_open = false
+        end
+      end
+      if stdout_open
+        begin
+          stdout_ch = o.read_nonblock(1)
+        rescue IO::WaitReadable
+          IO.select([o])
+          retry
+        rescue EOFError
+          stdout_open = false
+        end
+      end
+      if stderr_open
+        begin
+          stderr_ch = e.read_nonblock(1)
+        rescue IO::WaitReadable
+          IO.select([e])
+          retry
+        rescue EOFError
+          stderr_open = false
+        end
+      end
+      if stdout_ch == "\n" then
+        stdout += stdout_buffer+"\n"
+        unless silent
+          puts stdout_buffer
+        end
+        stdout_buffer = ""
+      elsif stdout_ch != nil
+        stdout_buffer << stdout_ch
+      end
+      stdout_ch = nil
+      if stderr_ch == "\n" then
+        stderr += stderr_buffer+"\n"
+        unless silent
+          STDERR.puts stderr_buffer
+        end
+        stderr_buffer = ""
+      elsif stderr_ch != nil
+        stderr_buffer << stderr_ch
+      end
+      stderr_ch = nil
+    end
+  end
+  if stderr != ""
+    return stdout, stderr
+  else
+    return stdout
+  end
+end
+
+# get process pid(s)
+def process(name,full=true)
+  if full
+    full = '-f '
+  else
+    full = ''
+  end
+  out,_ = Open3.capture2("/usr/bin/pgrep #{full}#{name}")
+  if out == ''
+    nil
+  else
+    pids = []
+    out.lines.each do |pid|
+      pids << pid.to_i
+    end
+    if pids.size == 1
+      pids[0]
+    else
+      pids
+    end
+  end
+end
+
+# kill process
+def kill(pids,signal=15)
+  if pids.is_a?(Array)
+    pids.each do |pid|
+      Process.kill(signal,pid)
+    end
+  else
+    Process.kill(signal,pids)
+  end
+end
+
+module Nite
+  module Owl
+    require 'singleton'
+    require 'time'
+
+    class ::Fixnum
+      def milliseconds
+        self/1000.0
+      end
+      def seconds
+        to_f
+      end
+      def minutes
+        self*60.0
+      end
+      def hours
+        self*3600.0
+      end
+    end
+
+    # special exception thrown by cancel method
+    class Cancel < Exception
+    end
+
+    # special exception thrown by delay method
+    class Delay < Exception
+      attr_accessor :time
+      def initialize(time)
+        @time = time
+      end
+    end
+
+    $current_action = nil
+    $deferred_actions = {}
+
+    class Action
+      attr_accessor :parent
+      def initialize
+        @actions = []
+        @parent=nil
+        @delay=nil
+      end
+      def current_action
+        $current_action
+      end
+      def cancel
+        raise Cancel.new
+      end
+      def defer(name,flags)
+        unless $deferred_actions.has_key?(self)
+          $deferred_actions[self] = [name,flags] 
+        end
+      end
+      def undefer
+        $deferred_actions.delete(self)
+      end
+      def self.call_all_deferred_actions
+        unless $deferred_actions.empty?
+          $deferred_actions.dup.each do |a,event|
+            a.call(event[0],event[1])
+          end
+        end
+      end
+      def root
+        r = self
+        while r.parent.parent
+          r = r.parent
+        end
+        r
+      end
+      def also
+        root
+      end
+      def add(a)
+        @actions << a
+        if a.is_a?(Action)
+          a.parent = self
+        end
+        a
+      end
+      def contains?(a)
+        @actions.find { |b| a == b or (b.is_a?(Action) and b.contains?(a)) }
+      end
+      def remove(a)
+        @actions.delete_if { |b| a == b }
+        @actions.each { |b| b.is_a?(Action) and b.remove(a) }
+        a
+      end
+      def run(&block)
+        add(block)
+        self
+      end
+      def call(name,flags)
+        $current_action = self
+        @actions.each do |n|
+          begin
+            n.call(name,flags)
+          rescue Cancel => c
+            undefer()
+          rescue Delay => d
+            handle_delay(d)
+            defer(name,flags)
+          rescue Exception => e
+            STDERR.puts e.message
+            STDERR.puts e.backtrace
+          end
+        end
+      end
+      def delay(time)
+        if @delay
+          if Time.now >= @delay
+            @delay = nil
+          else
+            raise Delay.new(0)
+          end
+        else
+          raise Delay.new(time)
+        end
+      end
+      def handle_delay(d)
+        unless @delay
+          @delay = Time.now + d.time
+        end
+      end
+      def only_once
+        run { root.parent.remove(self) }
+      end
+      def ignore(files)
+        add(NameIsNot.new(files))
+      end
+      def after(delay)
+        add(After.new(delay))
+      end
+      def created
+        add(HasFlags.new([:create]))
+      end
+      def modified
+        add(HasFlags.new([:modify]))
+      end
+      def deleted
+        add(HasFlags.new([:delete]))
+      end
+      def renamed
+        add(HasFlags.new([:rename]))
+      end
+      def changes
+        add(HasFlags.new([:create,:delete,:modify,:rename]))
+      end
+      def only_if(&block)
+        add(OnlyIf.new(block))
+      end
+      def if_not(&block)
+        add(IfNot.new(block))
+      end
+    end
+
+    class PredicateAction < Action
+      def initialize
+        super()
+        @time = nil
+        @expires = nil
+      end
+      def predicate?(name,flags)
+        true
+      end
+      def expired?
+        @expires and @time and (@time+@expires) >= Time.now.to_f
+      end
+      def expires(delay)
+        @expires = delay.to_f
+        self
+      end
+      def call(name,flags)
+        $current_action = self
+        begin
+          unless @time
+            @time = Time.now.to_f
+          end
+          if expired?
+            cancel
+          elsif predicate?(name,flags)
+            super(name,flags)
+            cancel
+          else
+            defer(name,flags)
+          end
+        rescue Cancel => c
+          undefer()
+          @time = nil
+        rescue Delay => d
+          handle_delay(d)
+          defer(name,flags)
+        rescue Exception => e
+          STDERR.puts e.message
+          STDERR.puts e.backtrace
+        end
+      end
+    end
+
+    class After < PredicateAction
+      def initialize(delay)
+        super()
+        @delay = delay.to_f
+        @time = nil
+      end
+      def predicate?(name,flags)
+        Time.now.to_f >= @time+@delay
+      end
+    end
+
+    class OnlyIf < PredicateAction
+      def initialize(block)
+        super()
+        @predicate = block
+      end
+      def predicate?(name,flags)
+        @predicate.call(name,flags)
+      end
+    end
+
+    class IfNot < PredicateAction
+      def initialize(block)
+        super()
+        @predicate = block
+      end
+      def predicate?(name,flags)
+        not @predicate.call(name,flags)
+      end
+    end
+
+    class HasFlags < Action
+      def initialize(flags)
+        super()
+        @flags = flags
+      end
+      def match?(flags)
+        @flags.find { |f| flags.include?(f) }
+      end
+      def call(name,flags)
+        match?(flags) && super(name,flags)
+      end
+    end
+
+    class FilesAction < Action
+      def initialize(files)
+        super()
+        @files = files
+      end
+      def match?(file)
+        @files.find do |pattern|
+          if pattern.is_a?(Regexp)
+            pattern.match(file) != nil
+          else
+            File.fnmatch?(pattern,file)
+          end
+        end
+      end
+    end
+
+    class NameIs < FilesAction
+      def call(name,flags)
+        match?(name) && super(name,flags)
+      end
+    end
+
+    class NameIsNot < FilesAction
+      def call(name,flags)
+        not match?(name) && super(name,flags)
+      end
+    end
+
+    class NiteOwl < Action
+      include Singleton
+
+      def initialize
+        super()
+        @workers_thread = nil
+        @queue = Queue.new
+      end
+
+      def watch(dir)
+        Dir.chdir dir
+        if File.file?("Niteowl") && File.readable?("Niteowl")
+          load "Niteowl"
+        else
+          puts "No Niteowl file found in: #{dir}"
+        end
+        if @actions.empty?
+          puts "No actions configured"
+        end
+      end
+
+      def whenever(files)
+        add(NameIs.new(files))
+      end
+
+      def start
+        @workers_thread = Thread.new {
+          begin
+            interval = 0.1
+            event_interval = 0.5
+            last_event_time = nil
+            next_time = Time.now.to_f+interval
+            events = {}
+            while true
+              until @queue.empty?
+                event = @queue.pop(true) rescue nil
+                if event
+                  name = event[0]
+                  flags = event[1]
+                  if events[name]
+                    new_flags = events[name] + flags
+                    if new_flags == [:delete, :create, :modify]
+                      new_flags = [:modify]
+                    end
+                    events[name] = new_flags
+                  else
+                    events[name] = flags
+                  end
+                  last_event_time = Time.now.to_f
+                end
+              end
+              if last_event_time && Time.now.to_f >= (last_event_time+event_interval)
+                events.each do |name,flags|
+                  begin
+                    Nite::Owl::NiteOwl.instance.call(name,flags.uniq)
+                  rescue Exception => e
+                    puts e.message
+                    puts e.backtrace
+                  end
+                end
+                events.clear
+                last_event_time = nil
+              end
+              Action.call_all_deferred_actions()
+              delay = next_time - Time.now.to_f
+              if delay > 0
+                sleep(delay)
+              end
+              next_time = Time.now.to_f+interval
+            end
+          rescue Exception => e
+            puts e.message
+            puts e.backtrace
+          end
+        }
+        # start platform specific notifier
+        pwd = Dir.pwd
+        if RUBY_PLATFORM =~ /linux/
+          require 'rb-inotify'
+          puts "Nite Owl watching: #{pwd}"
+          notifier = INotify::Notifier.new
+          notifier.watch(pwd, :recursive, :modify, :create, :delete, :move) do |event|
+            name = event.absolute_name.slice(pwd.size+1,event.absolute_name.size-pwd.size)
+            flags = event.flags do |f|
+              if f == :moved_to or f == :moved_from
+                :rename
+              else
+                f
+              end
+            end
+            @queue << [name,flags]
+          end
+          begin
+            notifier.run
+          rescue Interrupt => e
+          end
+        elsif RUBY_PLATFORM =~ /darwin/
+          require 'rb-fsevent'
+          puts "Nite Owl watching: #{pwd}"
+          fsevent = FSEvent.new
+          fsevent.watch pwd,{:file_events => true} do |paths, event_meta|
+            event_meta['events'].each do |event|
+              name = event['path']
+              name = name.slice(pwd.size+1,name.size-pwd.size)
+              flags = event['flags'].map do |f|
+                if f == 'ItemCreated'
+                  :create
+                elsif f == 'ItemModified'
+                  :modify
+                elsif f == 'ItemRemoved'
+                  :delete
+                elsif f == 'ItemRenamed'
+                  :rename
+                end
+              end.keep_if {|f| f}
+              @queue << [name,flags]
+            end
+          end
+          fsevent.run
+        else
+          puts "Platform unsupported"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/nite/owl/version.rb

@@ -0,0 +1,5 @@
+module Nite
+  module Owl
+    VERSION = "0.1.0"
+  end
+end

data/nite-owl.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nite/owl/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nite-owl"
+  spec.version       = Nite::Owl::VERSION
+  spec.authors       = ["Dmitry Geurkov"]
+  spec.email         = ["d.geurkov@gmail.com"]
+
+  spec.summary       = %q{Linux/OSX File System Events Watcher.}
+  spec.description   = %q{Linux/OSX File System Events Watcher.}
+  spec.homepage      = "https://github.com/troydm/nite-owl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rb-fsevent", "~> 0.10", ">= 0.10.2"
+  spec.add_dependency "rb-inotify", "~> 0.9", ">= 0.9.10"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: nite-owl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmitry Geurkov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !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: Linux/OSX File System Events Watcher.
+email:
+- d.geurkov@gmail.com
+executables:
+- nite-owl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- Niteowl
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/nite-owl
+- lib/nite/owl.rb
+- lib/nite/owl/niteowl.rb
+- lib/nite/owl/version.rb
+- nite-owl.gemspec
+homepage: https://github.com/troydm/nite-owl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Linux/OSX File System Events Watcher.
+test_files: []