divineflame-smurftp 0.5.1

data/README.mkdn

@@ -0,0 +1,59 @@
+# Smurftp
+ 
+Smurftp is a command-line utility written in Ruby that searches a specified directory and creates a queue of recently modified files for quickly uploading to a remote server over FTP.
+
+It was written for making web site edits where you might have a small group of files in multiple subdirectories that you want uploaded without having to manually go directory by directory.
+
+## Install
+
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install divineflame-smurftp
+
+## Usage
+
+Start Smurftp with this command:
+
+    $ smurftp <directory or configuration file>
+
+## Configuration
+
+Smurftp requires a configuration file in YAML format that defines your FTP server and login information, as well as a local directory ('document_root').
+
+When starting Smurftp, if you specify a directory, it looks for a 'smurftp_config.yaml' file in that directory. If the file is not found you'll be given the option for this file to be generated for you.
+
+Alternatively, if you specify an existing configuration file (it doesn't require the 'smurftp_config.yaml' name) Smurftp will start by loading this file. Because the 'document_root' setting is defined in the configuration file, you can store the configuration file separately from your project files if you choose.
+
+It's also possible to define multiple servers, sites, and login credentials in the same configuration file.
+
+## File List
+
+Smurftp will search the defined 'document_root' directory and list all files in all sub directories, ordered by modification date with newest files first. It skips any files defined in the configuration's 'exclusions' list.
+
+### Sample Output
+
+    [1] foo.php
+    [2] images/bar.jpg
+    [3] includes/header.php
+    [4] images/logo.png
+    [5] yada.php
+    ====================
+    smurftp>
+
+At the `smurftp>` prompt enter the number identifier of the files you want uploaded. You can also enter a list or range of files.
+
+### Example Commands
+
+    '1' uploads file [1]
+    '1-5' uploads files [1-5]
+    '1,2,4' uploads [1], [2], and [4]
+    '1-5,^4' uploads files [1-3], and [5], skipping file [4]
+    '1-5,!4' same as above
+    'all' uploads all listed files
+
+To quit type `quit` or `exit` at the prompt. `e` or `q` will also quit.
+
+## TODO
+
+* support relative paths for :document_root
+* add optional sftp
+* automatically refresh file list

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 5
+:patch: 1

data/bin/smurftp

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/smurftp'
+
+input = ARGV[0]
+site = ARGV[1]
+
+if !input
+  puts "Please specify a directory or configuration file to run smurftp from"
+  exit
+end
+
+config_file = ''
+
+if File.directory?(input)
+  directory = input
+  config_file = "#{input}/smurftp_config.yaml"
+  unless File.file?(config_file)
+    Smurftp::Configuration.generate_config_file(directory)
+    exit
+  end
+elsif File.file?(input)
+  config_file = input
+else
+  puts "Invalid directory or configuration file."
+  exit
+end
+
+smurftp = Smurftp::Shell.new(config_file, site)
+smurftp.run()

data/lib/smurftp.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+require 'find'
+require 'fileutils'
+require 'net/ftp'
+require 'readline'
+# require 'rubygems'
+# other dependencies
+
+# a bit of monkey patching
+
+class String
+  def to_regex!
+    return /#{self}/
+  end
+end
+
+
+class Hash
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    self.each do |key, value|
+      unless key.is_a?(Symbol)
+        self[key.to_sym] = self[key]
+        delete(key)
+      end
+      # recursively call this method on nested hashes
+      value.symbolize_keys! if value.class == Hash
+    end
+    self
+  end
+end
+
+%w(version configuration shell).each do |file|
+  require File.join(File.dirname(__FILE__), 'smurftp', file) 
+end

data/lib/smurftp/configuration.rb

@@ -0,0 +1,45 @@
+module Smurftp
+  class Configuration < Hash
+
+    def self.generate_config_file(dir)
+      # TODO ask before creating new file
+      # TODO fill out the config file by promption user for the info
+      templates_dir = File.dirname(__FILE__) + '/templates'
+      FileUtils.cp("#{templates_dir}/smurftp_config.yaml", "#{dir}/smurftp_config.yaml")
+      puts "No configuration file found. Creating new file."
+      puts "New configuration file created in #{dir}."
+      puts "Enter server and login info in this file and restart smurftp."
+    end
+
+
+    def initialize(file, site=nil)
+      load_config_file(file)
+      if site # merge config settings with current site
+        tmp = self[site]
+        self.clear.merge! tmp 
+      end
+      self.symbolize_keys!
+      validate
+      self[:exclusions] << file #exclude config file from upload if it's in the @base_dir
+      self[:queue_limit] ||= 15
+    end
+
+
+    def load_config_file(file)
+      self.merge! YAML::load(File.open(file))
+    end
+
+
+    def validate
+      %w[server server_root document_root login password].each do |setting|
+        unless self[setting.to_sym]
+          raise StandardError, "Error: \"#{setting}\" is missing from configuration file."
+        end
+      end
+      unless File.directory?(self[:document_root])
+        raise StandardError, "Error: \"#{self[:document_root]}\" specified in configuration file is not a valid directory."
+      end
+    end
+    
+  end
+end

data/lib/smurftp/shell.rb

@@ -0,0 +1,268 @@
+# Smurftp::Shell is used to create an interactive shell. It is invoked by the smurftp binary.
+module Smurftp
+  class Shell
+
+    attr_reader :upload_queue, :file_list
+
+    def initialize(config_file, site=nil)
+      #Readline.basic_word_break_characters = ""
+      #Readline.completion_append_character = nil
+      @configuration = Smurftp::Configuration.new(config_file, site)
+      @base_dir = @configuration[:document_root]
+      @file_list = []
+      @upload_queue = []
+      @last_upload = nil
+    end
+
+
+    # Run a single command.
+    def parse_command(cmd)
+      case cmd.downcase
+        when /^(a|all)$/
+          return lambda { upload_all }
+        when /\d+,/ # digit comma
+          files = parse_list(cmd)
+          command = lambda { upload }
+          return command, files
+        when /\d+(\.+|-)\d+/ 
+          files = parse_range(cmd)
+          command = lambda { upload }
+          return command, files
+        when /^\d+/
+          file = [cmd]
+          command = lambda { upload }
+          return command, file
+        # when /^(m|more)/: list_more_queued_files
+        when /^(r|refresh|l|ls|list)$/
+          command = lambda do
+            find_files
+            refresh_file_display
+          end
+          return command
+        else
+          return 'error'
+        # TODO needs error message as fallback
+      end
+    end
+    
+    
+    # Run the interactive shell using readline.
+    def run
+      find_files
+      refresh_file_display
+      loop do
+        cmd = Readline.readline('smurftp> ')
+        finish if cmd.nil? or cmd =~ /^(e|exit|q|quit)$/
+        next if cmd == ""
+        Readline::HISTORY.push(cmd)
+        command, files = parse_command(cmd)
+        if files
+          add_files_to_queue(files)
+        end
+        command.call
+      end
+    end
+    
+    
+    ##
+    # Adds single file to upload queue, ensuring
+    # no duplicate additions
+    
+    def add_file_to_queue(str)
+      str.gsub!(/[^\d]/, '') #strip non-digit characters
+      file = str.to_i-1
+      @upload_queue << file unless @upload_queue.include?(file)
+    end
+    
+    
+    def add_files_to_queue(files)
+      files.each {|f| add_file_to_queue(f)}
+    end
+    
+    
+    ##
+    # Extract a list of comma separated values from a string.
+    # Look for ranges and expand them, look for exceptions
+    # and remove them from the returned list.
+    
+    def parse_list(str)
+      file_list = []
+      exceptions = []
+      str.split(',').each do |s|
+        if s =~ /-/
+          file_list += parse_range(s)
+        elsif s =~ /(\^|!)\d/
+          s.gsub!(/[^\d]/, '') #strip non-digit characters
+          exceptions << s
+        else
+          file_list << s
+        end
+      end
+      return file_list - exceptions
+    end
+    
+    
+    ##
+    # Extract a range of numbers from a string.
+    # Expand the range into an array that represents files
+    # in the displayed list, and returns said array.
+    
+    def parse_range(str)
+      delimiters = str.split(/\.+|-+/)
+      r_start, r_end = delimiters[0], delimiters[1]
+      # TODO assumes even number pairs for creating a range
+      range = r_start.to_i..r_end.to_i
+      file_list = []
+      range.each do |n|
+        file_list << n.to_s
+      end
+      return file_list
+    end
+    
+    
+    def list_more_queued_files
+      # TODO
+      # not sure how this will work yet
+    end
+
+
+    ##
+    # Format the output of the file list display by looping over
+    # @file_list and numbering each file up to the predefined queue limit.
+    
+    def refresh_file_display
+      if @last_upload
+        puts 'Files changed since last upload:'
+      else
+        puts 'Recently modified files:'
+      end
+      
+      file_count = 1
+      @file_list.each do |f|
+        unless file_count > @configuration[:queue_limit]
+          spacer = ' ' unless file_count > 9 #add space to even the file numbering column
+          puts "#{spacer}[#{file_count}] #{f[:base_name]}"
+          file_count += 1
+        else
+          remaining_files = @file_list.length - file_count
+          puts "(plus #{remaining_files} more)"
+          break
+        end
+      end
+      puts '===================='
+    end
+
+
+    ##
+    # Find the files to process, ignoring temporary files, source
+    # configuration management files, etc., and add them to @file_list mapping
+    # filename to modification time.
+
+    def find_files
+      @file_list.clear
+      Find.find(@base_dir) do |f|
+        
+        @configuration[:exclusions].each do |e|
+          Find.prune if f =~ e.to_regex!
+          # if e.class == Regexp
+          #   Find.prune if f =~ e.to_regex!
+          # end
+        end
+
+        next if f =~ /(swp|~|rej|orig|bak|.git)$/ # temporary/patch files
+        next if f =~ /\/\.?#/            # Emacs autosave/cvs merge files
+        next if File.directory?(f) #skip directories
+        
+        #TODO loop through exclusions that are regex objects
+
+        file_name = f.sub(/^\.\//, '')
+        mtime = File.stat(file_name).mtime
+        base_name = file_name.sub("#{@base_dir}/", '')
+        
+        if @last_upload
+          if mtime > @last_upload
+            @file_list << {:name => file_name,
+                           :base_name => base_name,
+                           :mtime => mtime} rescue next
+          end
+        else #get all files, because we haven't uploaded yet
+          @file_list << {:name => file_name,
+                           :base_name => base_name,
+                           :mtime => mtime} rescue next
+        end
+      end
+      # sort list by mtime
+      @file_list.sort! { |x,y| y[:mtime] <=> x[:mtime] }
+    end
+
+
+    def upload
+      #TODO add timeout error handling
+      created_dirs = []
+      Net::FTP.open(@configuration[:server]) do |ftp|
+        ftp.login(@configuration[:login], @configuration[:password])
+        @upload_queue.each do |file_id|
+          file = @file_list[file_id]
+          
+          dirs = parse_file_for_sub_dirs(file[:base_name])
+          dirs.each do |dir|
+            unless created_dirs.include? dir
+              begin
+                ftp.mkdir "#{@configuration[:server_root]}/#{dir}"
+                puts "created #{dir}..."
+              rescue Net::FTPPermError; end #ignore errors for existing dirs
+              created_dirs << dir
+            end
+          end
+          
+          puts "uploading #{file[:base_name]}..."
+          ftp.put("#{file[:name]}", "#{@configuration[:server_root]}/#{file[:base_name]}")
+          # @file_list.delete_at file_id
+          # @upload_queue.delete file_id
+        end
+      end
+      @upload_queue.clear
+      puts "done"
+      @last_upload = Time.now
+    end
+
+
+    def upload_all
+      @file_list.length.times { |f| @upload_queue << f+1 }
+      upload
+    end
+    
+    
+    def parse_file_for_sub_dirs(file)
+      dirs = file.split(/\//)
+      return [] if dirs.length <= 1
+      dirs_expanded = []
+      
+      while dirs.length > 1
+        dirs.pop
+        dirs_expanded << dirs.join('/')
+      end
+
+      return dirs_expanded.reverse
+    end
+
+
+    ##
+    # Close the shell and exit the program with a cheesy message.
+    
+    def finish
+      messages = 
+      [
+        'Hasta La Vista, Baby!',
+        'Peace Out, Dawg!',
+        'Diggidy!',
+        'Up, up, and away!',
+        'Sally Forth Good Sir!'
+      ]
+      random_msg = messages[rand(messages.length)]
+      puts random_msg
+      exit
+    end
+    
+  end
+end

data/lib/smurftp/templates/smurftp_config.yaml

@@ -0,0 +1,10 @@
+# smurftp configuration
+server: 'ftp.yourserver.com'
+server_root: 'web/'
+document_root: '.'
+login: 'login'
+password: ''
+exclusions:
+  - '_notes'
+  - 'resources'
+  - '/regex/'

data/lib/smurftp/templates/smurftp_multisite_config.yaml

@@ -0,0 +1,41 @@
+# smurftp multisite configuration
+
+# multiple servers can be configured
+# and shared across site settings
+
+server1: &server1
+  server: ftp.yourserver.com
+  login: your_login
+  password: your_password
+
+global_exclusions: &exclusions 
+  exclusions:
+    - '_notes'
+    - 'resources'
+    - '/regex/'
+
+# define multiple sites which can
+# share server info and global_exclusions
+# in addition to defining their own
+
+site1:
+  <<: *server1
+  <<: *exclusions
+  server_root: 'web/'
+  document_root: '.'
+
+site2:
+  <<: *server1
+  exclusions:
+    - 'psd'
+    - 'src'
+  server_root: 'web/'
+  document_root: '.'
+
+site3:
+  server: ftp.anotherserver.com
+  login: site3_login
+  password: site3_password
+  server_root: 'web/'
+  document_root: '.'
+  <<: *exclusions

data/lib/smurftp/version.rb

@@ -0,0 +1,34 @@
+module Smurftp #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    URLIFIED = STRING.tr('.', '_')
+
+    # requirements_met? can take a hash with :major, :minor, :tiny set or
+    # a string in the format "major.minor.tiny"
+    def self.requirements_met?(minimum_version = {})
+      major = minor = tiny = 0
+      if minimum_version.is_a?(Hash)
+        major = minimum_version[:major].to_i if minimum_version.has_key?(:major)
+        minor = minimum_version[:minor].to_i if minimum_version.has_key?(:minor)
+        tiny = minimum_version[:tiny].to_i if minimum_version.has_key?(:tiny)
+      else
+        major, minor, tiny = minimum_version.to_s.split('.').collect { |v| v.to_i }
+      end
+      met = false
+      if Smurftp::VERSION::MAJOR > major
+        met = true
+      elsif Smurftp::VERSION::MAJOR == major
+        if Smurftp::VERSION::MINOR > minor
+          met = true
+        elsif Smurftp::VERSION::MINOR == minor
+          met = Smurftp::VERSION::TINY >= tiny
+        end
+      end
+      met
+    end
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/smurftp'
+
+class SmurftpConfigurationTest < Test::Unit::TestCase
+  def setup
+    @config_file = File.dirname(__FILE__) + '/../lib/smurftp/templates/smurftp_config.yaml'
+    @multisite_config_file = File.dirname(__FILE__) + '/../lib/smurftp/templates/smurftp_multisite_config.yaml'
+  end
+
+
+  def test_hash_symbolize_keys
+    assert_equal({:yada => 'yada'}, {'yada' => 'yada'}.symbolize_keys!)
+    expected = {:yada => {:yada => {:yada => 'yada'}}}
+    sample = {'yada' => {'yada' => {'yada' => 'yada'}}}
+    assert_equal expected, sample.symbolize_keys!
+  end
+
+
+  def test_configuration
+    config = Smurftp::Configuration.new(@config_file)
+  end
+
+
+  def test_multisite_configuration
+    config = Smurftp::Configuration.new(@multisite_config_file, 'site1')
+    puts config.inspect
+  end
+
+end

data/test/shell_test.rb

@@ -0,0 +1,91 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/smurftp'
+
+class SmurftpShellTest < Test::Unit::TestCase
+  def setup
+    @config = File.dirname(__FILE__) + '/../lib/smurftp/templates/smurftp_config.yaml'
+    @smurftp = Smurftp::Shell.new(@config)
+  end
+
+
+  def test_should_parse_list
+    lists = [
+      ['1,2,3',['1','2','3']],
+      ['1-4,^3',['1','2','4']],
+      ['1,2,3-6,^4',['1','2','3','5','6']],
+      ['1,2,3-6,!4',['1','2','3','5','6']],
+      ['^4,1-6',['1','2','3','5','6']]
+    ].each do |input, expected|
+      assert_equal expected, @smurftp.parse_list(input)
+    end
+  end
+
+
+  def test_should_parse_range
+    assert_equal ['1','2','3','4'], @smurftp.parse_range('1-4')
+  end
+  
+  
+  def test_should_parse_file_for_sub_dirs
+    file_paths = [
+      ['one/two/three/file.txt',['one','one/two','one/two/three']],
+      ['file.txt',[]]
+    ].each do |file,expanded|
+      assert_equal expanded, @smurftp.parse_file_for_sub_dirs(file)
+    end
+  end
+
+
+  def test_should_add_files_to_queue
+    @smurftp.add_files_to_queue(['1','2','3','4'])
+    assert_equal [0,1,2,3], @smurftp.upload_queue
+  end
+
+
+  def test_upload_queue_should_be_unique
+    @smurftp.add_files_to_queue(['1','2','3','4','2','3','1','1','1'])
+    assert_equal [0,1,2,3], @smurftp.upload_queue
+  end
+  
+  
+  def test_parse_command_should_parse_input
+    input = @smurftp.parse_command('all')
+    assert_equal Proc, input.class
+
+    input = @smurftp.parse_command('a')
+    assert_equal Proc, input.class
+    
+    input = @smurftp.parse_command('ardvark')
+    assert_equal 'error', input
+
+    input = @smurftp.parse_command('allin')
+    assert_equal 'error', input
+
+    cmd, files = @smurftp.parse_command('1')
+    assert_equal ['1'], files
+
+    cmd = @smurftp.parse_command(' 1 ')
+    assert_equal 'error', cmd
+    
+    cmd, files = @smurftp.parse_command('1,2,3,4')
+    assert_equal ['1','2','3','4'], files
+    
+    cmd, files = @smurftp.parse_command('1-4')
+    assert_equal ['1','2','3','4'], files
+    
+    cmd, files = @smurftp.parse_command('1-4,^3')
+    assert_equal ['1','2','4'], files
+    
+    cmd, files = @smurftp.parse_command('^3,1-4')
+    assert_equal ['1','2','4'], files
+  end
+
+
+  def test_hash_symbolize_keys
+    assert_equal({:yada => 'yada'}, {'yada' => 'yada'}.symbolize_keys!)
+    expected = {:yada => {:yada => {:yada => 'yada'}}}
+    sample = {'yada' => {'yada' => {'yada' => 'yada'}}}
+    assert_equal expected, sample.symbolize_keys!
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: divineflame-smurftp
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- Andrew Gruner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-05 00:00:00 -08:00
+default_executable: smurftp
+dependencies: []
+
+description: Smurftp is a command-line utility that searches a specified directory and creates a queue of recently modified files for quickly uploading to a remote server over FTP.
+email: andrew@divineflame.com
+executables: 
+- smurftp
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- README.mkdn
+- bin/smurftp
+- lib/smurftp
+- lib/smurftp/shell.rb
+- lib/smurftp/version.rb
+- lib/smurftp/templates
+- lib/smurftp/templates/smurftp_multisite_config.yaml
+- lib/smurftp/templates/smurftp_config.yaml
+- lib/smurftp/configuration.rb
+- lib/smurftp.rb
+- test/shell_test.rb
+- test/configuration_test.rb
+has_rdoc: true
+homepage: http://github.com/divineflame/smurftp
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Command-line utility for uploading recently modified files to a server
+test_files: []
+