loft-harmony 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 357be3211af77da5e3cd8a20d084446311bf1743
+  data.tar.gz: 526c22da20b924a191a59e51005e5eaa8ba13e36
+SHA512:
+  metadata.gz: 63b4cba6a29257c401496a11adc42ec9e485b8e8d2db027d01b0f9415b299bf12f17509fe2518d8070b22ceb381ac6b73c9d49564449a3586669d7043904a40d
+  data.tar.gz: f508d0854a236ea048c6444d6fae9389a9d2bbfdd6ccc6cd80442cee14df4b43350f302e3862dc5bd845311f78dee2a8374ab53659959630348d0dccc1a2f6b1

data/bin/harmony

@@ -0,0 +1,644 @@
+#!/usr/bin/env ruby
+require 'net/ftp'
+require 'terrun'
+require 'timeout'
+
+class Harmony < TerminalRunner
+  name "Harmony"
+
+  param "server", "The FTP server to connect to"
+  param "user", "The FTP user to use."
+  param "password", "Password for the given user."
+  param "directory", "The directory to watch."
+
+  option "--help", 0, "", "Show this help document."
+  option "--remote", 1, "path", "Remote path to use."
+  option "--timeout", 1, "seconds", "Length of time to allow files to transfer. (default 2)"
+  option "--coffee", 1, "target", "Automatically compile saved coffeescript files to the given directory."
+  option "--eco", 2, "target identifier", "Automatically compile saved eco files to the given directory."
+  option "--auto", 0, "", "Start up auto mode automatically."
+
+  help ""
+
+  def self.run
+    if @@options.include? "--help"
+      show_usage
+      exit
+    end
+
+    @modified = []
+    @active = false
+
+    @server = @@params["server"]
+    @user = @@params["user"]
+    @password = @@params["password"]
+    @directory = Dir.new(@@params["directory"])
+    @remote_path = @@options.include?("--remote") ? @@options["--remote"][0] : ""
+    @timeout = @@options.include?("--timeout") ? @@options["--timeout"][0].to_i : 2
+    @compile_coffeescript = @@options.include?("--coffee") ? @@options["--coffee"][0] : nil
+    @ignored = []
+
+    @compile_eco = nil
+    if @@options.include?("--eco")
+      @compile_eco = @@options["--eco"][0]
+      @eco_ident = @@options["--eco"][1]
+    end
+
+    @watcher = Dir::DirectoryWatcher.new(@directory)
+
+    @modified_proc = Proc.new do |file, info|
+      unless @ignored.include?(file.path)
+        @modified << file.path
+        if @active
+          if file.path.end_with?(".coffee") && @compile_coffeescript
+            `coffee -o #{@compile_coffeescript} -c #{file.path}`
+          end
+          if file.path.end_with?(".eco") && @compile_eco
+            `eco -i #{@eco_ident} -o #{@compile_eco} #{file.path}`
+          end
+        end
+      end
+    end
+
+    @watcher.on_add = @modified_proc
+    @watcher.on_modify = @modified_proc
+    #@watcher.on_remove = @modified_proc
+
+    @watcher.scan_now
+    self.clear
+    @active = true
+
+    puts " ## Harmony is now running".red
+
+    if File.exist?(".harmonyignore")
+      puts " ## Loading .harmonyignore".pink
+      File.readlines('.harmonyignore').each do |line|
+        @ignored << line[0..-2]
+        puts "X  Ignoring #{line}".pink
+      end
+    end
+
+    self.start_auto if @@options.include?("--auto")
+
+    begin
+      while true
+        break if self.get_command
+      end
+    rescue => e
+      puts e.to_s.red
+      puts " ## FATAL ERROR OCCURRED. SHUTTING DOWN.".red
+    end
+    @thread.kill if @thread
+    self.close_connection
+  end
+
+  def self.get_command
+    print "Harmony:: ".yellow
+    command, arg = gets.chomp.split(' ')
+    return true if command == "exit" || command == "quit"
+    self.show_help if command == "help"
+    self.send_to_remote if command == "send" || command == "s"
+    self.clear if command == "clear"
+    self.show_status if command == "status" || command == "st"
+    self.deploy if command == "deploy"
+    self.start_auto if command == "auto"
+    self.stop_auto if command == "stop"
+    @modified_proc.call(File.new(arg), nil) if command == "mark"
+    self.ftp if command == "ftp"
+    false
+  end
+
+  def self.ftp
+    `ftp ftp://#{@user}:#{@password}@#{@server}`
+  end
+
+  def self.start_auto
+    puts " ## Auto upload has been started. Type 'stop' to kill the thread.".red
+    @thread = Thread.new do
+      begin
+        while true
+          self.send_to_remote
+          sleep 2
+        end
+      rescue => e
+        puts e.to_s.red
+        puts " ## FATAL ERROR OCCURRED IN AUTO THREAD. SHUTTING DOWN.".red
+        self.stop_auto
+      end
+    end
+  end
+
+  def self.stop_auto
+    return unless @thread
+    @thread.kill
+    puts " ## Auto upload thread has been killed.".red
+  end
+
+  def self.deploy
+    @watcher.add_all
+    self.send_to_remote
+  end
+
+  def self.send_to_remote
+    @watcher.scan_now
+    return if @modified.empty?
+    failed = !self.open_connection
+    unless failed
+      @modified.each do |file|
+        next if file.end_with? "~"
+        begin
+          Timeout::timeout(@timeout) do
+            rpath = self.remote_path_for(file)
+
+            if @ftp.mkdir_p rpath
+              puts " ## Created new directory #{rpath}".pink
+            end
+
+            @ftp.chdir rpath
+
+            if file.end_with? ".png", ".gif", ".jpg", ".bmp", ".svg", ".tiff", ".raw"
+              @ftp.putbinaryfile(file)
+            else
+              @ftp.puttextfile(file)
+            end
+            puts " ## [SUCCESS] #{file} => #{rpath}".green
+          end
+        rescue Timeout::Error
+          failed = true
+          puts " ## [ FAIL  ] #{file} timed out while syncing".red
+        rescue Net::FTPError => e
+          failed = true
+          puts " ## [ FAIL  ] #{file} failed to sync".red
+          puts e.message
+        end
+      end
+    end
+
+    if failed
+      puts " ## Some files failed to transfer. The dirty list has not been cleared.".pink
+    else
+      self.clear
+    end
+  end
+
+  def self.remote_path_for(file)
+    extra_path = file.sub(@directory.path, "")
+    @remote_path + extra_path[0, extra_path.rindex("/")]
+  end
+
+  def self.clear
+    @modified = []
+  end
+
+  def self.show_status
+    @watcher.scan_now
+
+    return puts " ## Directory is in sync".green if @modified.count == 0
+
+    puts " ## Files to be uploaded".red
+    @modified.each do |file|
+      puts "+   #{file}".pink
+    end
+  end
+
+  def self.show_help
+    puts " ## Harmony Help".red
+    puts "help - Show this help file"
+    puts "exit (quit) - Quit Harmony"
+    puts "status (st) - Show a list of files that will be transfered"
+    puts "clear - Mark all files as synced"
+    puts "send (s) - Send all new and modified files to the remote server"
+    puts "deploy - Send all files, regardless of their state"
+    puts "mark [file] - Mark the specified file as changed (use format ./directory/file)"
+    puts "auto - Automatically run 'send' every 2 seconds"
+    puts "stop - reverses the 'auto' command"
+  end
+
+  def self.open_connection
+    Timeout.timeout(@timeout) do
+      if @ftp
+        begin
+          @ftp.list
+        rescue Net::FTPError
+          puts " ## Connection was closed by server".pink
+          @ftp.close
+        end
+      end
+
+      if @ftp.nil? || @ftp.closed?
+        puts " ## Connection opening".red
+        @ftp = BetterFTP.new(@server, @user, @password)
+      end
+    end
+    true
+  rescue SocketError
+    puts " ## [FAIL] Unable to open connection to server.".red
+    false
+  rescue Timeout::Error
+    puts " ## [TIMEOUT] Failed to connect to server.".red
+    @ftp.close
+    @ftp = nil
+    false
+  end
+
+  def self.close_connection
+    if @ftp
+      puts " ## Connection closing".red
+      @ftp.close
+    end
+  end
+
+end
+
+
+# Monkey patching the string class for easy colors (you mad?)
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def pink
+    colorize(35)
+  end
+end
+
+require 'net/ftp'
+
+class BetterFTP < Net::FTP
+
+  attr_accessor :port
+  attr_accessor :public_ip
+  alias_method  :cd, :chdir
+  attr_reader :home
+
+  def initialize(host = nil, user = nil, passwd = nil, acct = nil)
+    super
+    @host = host
+    @user = user
+    @passwd = passwd
+    @acct = acct
+    @home = self.pwd
+    initialize_caches
+  end
+
+  def initialize_caches
+    @created_paths_cache = []
+    @deleted_paths_cache = []
+  end
+
+  def connect(host, port = nil)
+    port ||= @port || FTP_PORT
+    if @debug_mode
+      print "connect: ", host, ", ", port, "\n"
+    end
+    synchronize do
+      initialize_caches
+      @sock = open_socket(host, port)
+      voidresp
+    end
+  end
+
+  def reconnect!
+    if @host
+      connect(@host)
+      if @user
+        login(@user, @passwd, @acct)
+      end
+    end
+  end
+
+  def directory?(path)
+    chdir(path)
+
+    return true
+  rescue Net::FTPPermError
+    return false
+  end
+
+  def file?(path)
+    chdir(File.dirname(path))
+
+    begin
+      size(path)
+      return true
+    rescue Net::FTPPermError
+      return false
+    end
+  end
+
+  def mkdir_p(dir)
+    made_path = false
+
+    parts = dir.split("/")
+    if parts.first == "~"
+      growing_path = ""
+    else
+      growing_path = "/"
+    end
+    for part in parts
+      next if part == ""
+      if growing_path == ""
+        growing_path = part
+      else
+        growing_path = File.join(growing_path, part)
+      end
+      unless @created_paths_cache.include?(growing_path)
+        begin
+          mkdir(growing_path)
+          chdir(growing_path)
+          made_path = true
+        rescue Net::FTPPermError, Net::FTPTempError
+        end
+        @created_paths_cache << growing_path
+      else
+      end
+    end
+
+    made_path
+  end
+
+  def rm_r(path)
+    return if @deleted_paths_cache.include?(path)
+    @deleted_paths_cache << path
+    if directory?(path)
+      chdir path
+
+      begin
+        files = nlst
+        files.each {|file| rm_r "#{path}/#{file}"}
+      rescue Net::FTPTempError
+        # maybe all files were deleted already
+      end
+
+      rmdir path
+    else
+      rm(path)
+    end
+  end
+
+  def rm(path)
+    chdir File.dirname(path)
+    delete File.basename(path)
+  end
+
+private
+
+  def makeport
+    sock = TCPServer.open(@sock.addr[3], 0)
+    port = sock.addr[1]
+    host = @public_ip || sock.addr[3]
+    sendport(host, port)
+    return sock
+  end
+
+end
+
+
+# *** This code is copyright 2004 by Gavin Kistner
+# *** It is covered under the license viewable at http://phrogz.net/JS/_ReuseLicense.txt
+class Dir
+
+# The DirectoryWatcher class keeps an eye on all files in a directory, and calls
+# methods of your making when files are added to, modified in, and/or removed from
+# that directory.
+#
+# The +on_add+, +on_modify+ and +on_remove+ callbacks should be Proc instances
+# that should be called when a file is added to, modified in, or removed from 
+# the watched directory.
+#
+# The +on_add+ and +on_modify+ Procs will be passed a File instance pointing to
+# the file added/changed, as well as a Hash instance. The hash contains some
+# saved statistics about the file (modification date (<tt>:date</tt>),
+# file size (<tt>:size</tt>), and original path (<tt>:path</tt>)) and may also
+# be used to store additional information about the file.
+#
+# The +on_remove+ Proc will only be passed the hash that was passed to +on_add+
+# and +on_modify+ (since the file no longer exists in a way that the watcher
+# knows about it). By storing your own information in the hash, you may do
+# something intelligent when the file disappears.
+#
+# The first time the directory is scanned, the +on_add+ callback will be invoked
+# for each file in the directory (since it's the first time they've been seen).
+#
+# Use the +onmodify_checks+ and +onmodify_requiresall+ properties to control
+# what is required for the +on_modify+ callback to occur.
+#
+# If you do not set a Proc for any one of these callbacks; they'll simply
+# be ignored.
+#
+# Use the +autoscan_delay+ property to set how frequently the directory is
+# automatically checked, or use the #scan_now method to force it to look
+# for changes.
+#
+# <b>You must call the #start_watching method after you create a DirectoryWatcher
+# instance</b> (and after you have set the necessary callbacks) <b>to start the
+# automatic scanning.</b>
+#
+# The DirectoryWatcher does not process sub-directories of the watched
+# directory. Any item in the directory which returns +false+ for <tt>File.file?</tt>
+# is ignored.
+#
+# Example:
+#
+#    device_manager = Dir::DirectoryWatcher.new( 'plugins/devices', 2 )
+#    device_manager.name_regexp = /^[^.].*\.rb$/
+#    
+#    device_manager.on_add = Proc.new{ |the_file, stats_hash|
+#       puts "Hey, just found #{the_file.inspect}!"
+#
+#       # Store something custom
+#       stats_hash[:blorgle] = the_file.foo 
+#    }
+#    
+#    device_manager.on_modify = Proc.new{ |the_file, stats_hash|
+#       puts "Hey, #{the_file.inspect} just changed."
+#    }
+#    
+#    device_manager.on_remove = Proc.new{ |stats_hash|
+#       puts "Whoa, the following file just disappeared:"
+#       stats_hash.each_pair{ |k,v|
+#          puts "#{k} : #{v}"
+#       }
+#    }
+#    
+#    device_manager.start_watching
+class DirectoryWatcher
+   # How long (in seconds) to wait between checks of the directory for changes.
+   attr_accessor :autoscan_delay
+   
+   # The Dir instance or path to the directory to watch.
+   attr_accessor :directory
+   def directory=( dir ) #:nodoc:
+      @directory = dir.is_a?(Dir) ? dir : Dir.new( dir )
+   end
+
+   # Proc to call when files are added to the watched directory.
+   attr_accessor :on_add
+   
+   # Proc to call when files are modified in the watched directory
+   # (see +onmodify_checks+).
+   attr_accessor :on_modify
+   
+   # Proc to call when files are removed from the watched directory.
+   attr_accessor :on_remove
+   
+   # Array of symbols which specify which attribute(s) to check for changes.
+   # Valid symbols are <tt>:date</tt> and <tt>:size</tt>.
+   # Defaults to <tt>:date</tt> only.
+   attr_accessor :onmodify_checks
+   
+   # If more than one symbol is specified for +onmodify_checks+, should
+   # +on_modify+ be called only when *all* specified values change
+   # (value of +true+), or when any *one* value changes (value of +false+)?
+   # Defaults to +false+.
+   attr_accessor :onmodify_requiresall
+   
+   # Should files which exist in the directory fire the +on_add+ callback
+   # the first time the directory is scanned? Defaults to +true+.
+   attr_accessor :onadd_for_existing
+   
+   # Regular expression to match against file names. If +nil+, all files
+   # will be included, otherwise only those whose name match the regexp
+   # will be passed to the +on_add+/+on_modify+/+on_remove+ callbacks.
+   # Defaults to <tt>/^[^.].*$/</tt> (files which do not begin with a period).
+   attr_accessor :name_regexp
+   
+   # Creates a new directory watcher.
+   #
+   # _dir_::    The path (relative to the current working directory) of the
+   #            directory to watch, or a Dir instance.
+   # _delay_::  The +autoscan_delay+ value to use; defaults to 10 seconds.
+   def initialize( dir, delay = 10 )
+      self.directory = dir
+      @autoscan_delay = delay
+      @known_file_stats = {}
+      @onmodify_checks = [ :date ]
+      @onmodify_requiresall = false
+      @onadd_for_existing = true
+      @scanned_once = false
+      @name_regexp = /^[^.].*$/
+   end 
+
+   # Starts the automatic scanning of the directory for changes,
+   # repeatedly calling #scan_now and then waiting +autoscan_delay+
+   # seconds before calling it again.
+   #
+   # Automatic scanning is *not* turned on when you create a new
+   # DirectoryWatcher; you must invoke this method (after setting
+   # the +on_add+/+on_modify+/+on_remove+ callbacks).
+   def start_watching
+      @thread = Thread.new{ 
+         while true
+            self.scan_now
+            sleep @autoscan_delay
+         end
+      }
+   end
+
+   # Stops the automatic scanning of the directory for changes.
+   def stop_watching
+      @thread.kill
+   end
+
+   # Scans the directory for additions/modifications/removals,
+   # calling the +on_add+/+on_modify+/+on_remove+ callbacks as
+   # appropriate.
+   def scan_now
+      #Check for add/modify
+      scan_dir(@directory)
+      
+      # Check for removed files
+      if @on_remove.respond_to?( :call )
+         @known_file_stats.each_pair{ |path,stats|
+            next if File.file?( path )
+            stats[:path] = path
+            @on_remove.call( stats )
+            @known_file_stats.delete(path)
+         }
+      end
+      
+      @scanned_once = true
+   end
+
+   def add_all
+     scan_dir(@directory, true)
+   end
+
+   def scan_dir(directory, override = false)
+    # Setup the checks
+    # ToDo: CRC
+    checks = {
+       :date => {
+          :use=>false,
+          :proc=>Proc.new{ |file,stats| stats.mtime }
+       },
+       :size => {
+          :use=>false,
+          :proc=>Proc.new{ |file,stats| stats.size }
+       },
+       :crc => {
+          :use=>false,
+          :proc=>Proc.new{ |file,stats| 1 }
+       }
+    }
+    checks.each_pair{ |check_name,check|
+       check[:use] = (@onmodify_checks == check_name) || ( @onmodify_checks.respond_to?( :include? ) && @onmodify_checks.include?( check_name ) )
+    }
+      
+    directory.rewind
+    directory.each{ |fname|
+       next if fname.start_with? '.'
+       file_path = "#{directory.path}/#{fname}"
+       scan_dir(Dir.new(file_path), override) unless fname == "." || fname == ".." || File.file?(file_path)
+       next if (@name_regexp.respond_to?( :match ) && !@name_regexp.match( fname )) || !File.file?( file_path )
+       the_file = File.new( file_path )
+       file_stats = File.stat( file_path )
+       
+       saved_stats = @known_file_stats[file_path]
+       new_stats = {}
+       checks.each_pair{ |check_name,check|
+          new_stats[check_name] = check[:proc].call( the_file, file_stats )
+       }
+       
+       @on_add.call(the_file, new_stats) if override
+       if saved_stats
+          if @on_modify.respond_to?( :call )
+             sufficiently_modified = @onmodify_requiresall
+             saved_stats = @known_file_stats[file_path]
+             checks.each_pair{ |check_name,check|
+                stat_changed = check[:use] && ( saved_stats[check_name] != new_stats[check_name] )
+                if @onmodify_requiresall
+                   sufficiently_modified &&= stat_changed
+                else
+                   sufficiently_modified ||= stat_changed
+                end
+                saved_stats[check_name] = new_stats[check_name]
+             }
+             @on_modify.call( the_file, saved_stats ) if sufficiently_modified 
+          end
+       elsif @on_add.respond_to?( :call ) && (@scanned_once || @onadd_for_existing)
+          @known_file_stats[file_path] = new_stats
+          @on_add.call( the_file, new_stats )
+       end
+       
+       the_file.close
+    }
+   end
+
+end
+
+end
+
+Harmony.start(ARGV)

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: loft-harmony
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Caleb Simpson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies: []
+description: Watches a directory for changes to upload to a server via FTP
+email: caleb@simpson.center
+executables:
+- harmony
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/harmony
+homepage: 
+licenses: []
+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.2.3
+signing_key: 
+specification_version: 4
+summary: Watches a directory for changes to upload to a server via FTP
+test_files: []