crane 0.1.9

data/lib/crane/crane.rb

@@ -0,0 +1,118 @@
+require "net/ftp"
+require "crane/config"
+require File.expand_path("../../shell/shell.rb", __FILE__)
+
+module Crane
+  
+  class Engine < Shell::Run
+    
+    include Config
+    # @argv
+    # @command
+    # options
+    
+    def initialize argv = []
+      return true if defined? TESTING
+      require File.expand_path("../ftp.rb", __FILE__)
+      
+      super argv
+      @ftp = nil
+      @config = Config.load_config
+      @ignored_files = get_ignored_files
+      @local_files = []
+      
+      @errors = []
+      @connection = nil
+      
+      (help; exit) if ["help", "h"].any? { |e| true if Shell::Parser.get_options(@argv).include? e }
+      (version; exit) if ["version", "v"].any? { |e| true if Shell::Parser.get_options(@argv).include? e }
+      
+      begin
+        run unless defined? TESTING
+      rescue Interrupt
+        puts "\n"
+      rescue
+        
+      end
+    end
+    
+    # return an instance of a FTP connection
+    def connect_ftp
+      require "net/ftp"
+      require 'timeout'
+      result = true
+      
+      if @connection.nil? then
+        host = @config['ftp']['host_address']
+        username = @config['ftp']['username']
+        password = @config['ftp']['password']
+        @connection = Net::FTP.new
+        @connection.passive = true
+        begin
+          Timeout.timeout(7) do
+            @connection.connect host, 21
+          end
+        rescue
+          @connection_error = "couldn't connect to host"
+          result = false
+        end
+        
+        begin
+          Timeout.timeout(4) do
+            @connection.login username, password
+          end
+        rescue
+          @connection_error = "invalid username/password"
+          result = false
+        end
+      end
+      
+      if result == false
+        @connection = false
+      end
+        
+      @connection
+      
+    end # connect_ftp
+    
+    # if there was typed any argument on ARGV starting with either -- or -
+    def is_option option
+      Shell::Parser.is_option option, @argv
+    end
+    
+    def get_ignored_files
+      require File.expand_path("../config.rb", __FILE__);
+      Config.get_ignored_files || []
+    end
+    
+    def no_command
+      help
+    end
+        
+    def version
+      require "crane/version"
+      print "Crane v" + Crane::VERSION + "\n"
+    end
+    
+    def help
+      print "Usage:\n"
+      print "\s\scrane COMMAND [options]"
+      print "\n\n"
+      print "Commands available:"
+      print "\n"
+      print "\s\spush\t\tSend files to a remote server"
+      print "\n\n"
+      print "Examples:"
+      print "\n"
+      print "\s\scrane push 1h"
+      print "\n"
+      print "\t\tPushes all files modified in the last hour.\n"
+      print "\n"
+      print "For more information, try:\n"
+      print "\s\scrane COMMAND -h"
+      print "\n"
+    end
+    
+  end
+  
+end

data/lib/crane/ftp.rb

@@ -0,0 +1,142 @@
+require "net/ftp"
+require 'timeout'
+
+module Crane
+
+  class Ftp
+    
+    attr_accessor :connection, :connection_error
+    
+    def initialize c = false
+      @connection = nil
+      @existent_dirs = []
+      @nlst = {}
+      unless c
+        config = Config.load_config
+        unless config.empty?
+          c = {}
+          c[:ftp] = config[:ftp] unless config[:ftp].empty?
+        end
+      end
+      connect(c) if c
+      self
+    end
+    
+    def connect c = {}
+      port = c[:port] || 21
+      c = c[:ftp] if c.include? :ftp
+      
+      return false unless c.has_key? :host
+
+      @connection = Net::FTP.new
+      @connection_error = false
+      @connection.passive = true
+      begin
+        Timeout.timeout(10) do
+          @connection.connect c[:host], port
+        end
+      rescue Timeout::Error
+        @connection_error = "Timeout on connection"
+      rescue
+        @connection_error = "Error on connection FTP"
+      end
+      
+      begin
+        Timeout.timeout(20) do
+          @connection.login c[:username], c[:password]
+        end
+      rescue Timeout::Error
+        @connection_error = "Timeout on authentication (20 seconds)"
+      rescue Net::FTPPermError
+        @connection_error = "Invalid username/password"
+      rescue 
+        @connection_error = "Unknown error related to username/password"
+      end
+
+      return false if @connection_error
+      true  
+    end
+
+    def remote_dir_exists? remote_dir = false
+      return nil if Config.load_config.empty?
+      connect(Config.CONFIG[:ftp]) if @connection.nil?
+      
+      begin
+        Timeout.timeout(10) do
+          @connection.chdir(remote_dir || Config.CONFIG[:ftp][:remote_root_dir])
+        end
+      rescue 
+        return false
+      end
+      @connection.close
+      true
+    end
+    
+    def close
+      @connection.close
+    end
+    
+    def putbinaryfile f, f2
+      @connection.putbinaryfile f, f2
+    end
+    
+    def chdir var
+      @connection.chdir var
+    end
+    
+    # Accepts deep directories as parameter
+    def mkdir dir
+      each_dir = dir.split("/")
+      return false if dir.empty?
+      last_dir = ""
+      
+      each_dir.each { |d|
+        next if ["", ".", ".."].include? d
+      
+        slashed_d = "/" + d if d[0,1] != "/"
+        current_dir = last_dir + slashed_d
+
+        if @existent_dirs.include? current_dir
+          last_dir << slashed_d
+          next
+        else
+          @connection.chdir last_dir unless last_dir.empty?
+          
+          if @nlst.include? last_dir
+            nlst = @nlst[last_dir]
+          else
+            nlst = @connection.nlst
+          end
+          @nlst[last_dir] = nlst
+          if nlst.include? d
+            @existent_dirs << current_dir
+            last_dir << slashed_d
+            next
+          else
+            @connection.mkdir d
+            @connection.chdir current_dir
+            last_dir << slashed_d
+            @existent_dirs << current_dir
+          end
+        end
+      }
+      @connection.chdir pwd
+    end
+    
+    def pwd
+      @connection.pwd
+    end
+    
+    private
+    def map_args args
+      result = {}
+      args.each { |k,v|
+        result[k] = v
+      }
+      result
+    end #map_args
+    
+  end
+
+
+end

data/lib/crane/shell_initializer.rb

@@ -0,0 +1,55 @@
+require "shell/shell"
+require "crane"
+require "crane/crane"
+
+module Shell
+  class Initializer
+
+    attr_accessor :command
+    
+    def initialize argv
+      @args = argv
+      get_command
+      run
+    end
+    
+    def run
+      if @command
+        if command_exist?
+          require get_command_file
+          return run_command @command
+        end
+      end
+      inexistent_command
+    end
+    
+    def should_exit?
+      return false || true unless @command
+    end
+    
+    def get_command
+      @command = Shell::Parser::get_command @args
+    end
+
+    def command_exist? command = false
+      File.exists? get_command_file(command)
+    end
+    
+    def get_command_file command = false
+      command = @command unless command
+      File.expand_path("../commands/" + command + ".rb", __FILE__)
+    end
+    
+    def run_command command, args = []
+      command = @command unless command
+      return inexistent_command unless command_exist?(command)
+      require get_command_file(command) 
+      command = command.capitalize
+      @command_obj = Crane::Commands.const_get(command).new(@args)
+    end
+    
+    def inexistent_command
+      @command_obj = Crane::Engine.new(@args)
+    end
+  end
+end

data/lib/crane/version.rb

@@ -0,0 +1,3 @@
+module Crane
+  VERSION = "0.1.9"
+end

data/lib/shell/shell.rb

@@ -0,0 +1,125 @@
+module Shell
+  
+  class Run
+    
+    # all arguments passed
+    @argv
+    
+    def initialize argv
+      @argv = argv
+      
+      @options = Shell::Parser.get_options @argv
+      @command = Shell::Parser.get_command @argv
+      @arguments = Shell::Parser.get_arguments @argv
+    end
+    
+  end
+  
+  class Input
+    
+    def self.text
+      STDOUT.flush
+      STDIN.gets.strip
+    end
+    
+    def self.yesno message
+      STDOUT.flush
+      has_result = false
+      while has_result == false
+        print message.strip + " "
+        input = STDIN.gets.strip
+        
+        if input == "yes" or input == "y" then
+          final_input = "yes"
+        elsif input == "no" or input == "n" then
+          final_input = "no"
+        end
+        
+        if ( final_input == "yes" or final_input == "no" )
+          has_result = true
+        end
+      end
+      
+      if final_input == "yes"
+        result = true
+      else
+        result = false
+      end
+      result
+    end
+    
+  end
+  
+  class Parser
+    
+    # ARGV has a command, options and arguments. The design is:
+    #
+    #   $ bin_file command argument1 argument2 -option1 -option2
+    #
+    # get_options() and get_arguments() return Array. get_command()
+    # returns String.
+    
+    def self.get_command argv = []
+      command = String.new
+      
+      argv.each {
+        |e|
+        e_length = e.length
+        if (e[0,2] != "--" and e[0,1] != "-") then
+            command = e
+            break
+        end
+      }
+      return false if command.empty?
+      command
+    end
+    
+    def self.get_options argv
+      return [] if argv.nil?
+      @options = []
+      @sanitized_options = []
+      
+      argv.each {
+        |e|
+        e_length = e.length
+        if e[0,2] == "--" 
+          @options.push e[2,e_length]
+        elsif e[0,1] == "-"
+            @options.push e[1,e_length]
+        end
+      }
+      unless @options.empty?
+        @options.each { |e|
+          next if @sanitized_options.include?(e)
+          @sanitized_options << e
+        }
+      end
+      
+      @sanitized_options
+    end
+    
+    def self.get_arguments argv
+      @arguments = []
+      i = 0
+      argv.each {
+        |e|
+        
+        i+= 1
+        next if i == 1
+        
+        e_length = e.length
+        if e[0,2] != "--" and e[0,1] != "-"
+          @arguments.push e[0,e_length]
+        end
+      }
+      @arguments
+    end
+    
+    def self.is_option option, argv = []
+      argv_options = self.get_options argv
+      argv_options.include?(option)
+    end
+    
+  end
+  
+end