easy_downloader 0.0.2.alpha → 0.0.3.alpha

data/README.rdoc

@@ -1,9 +1,63 @@
 = easy_downloader
 
-Description goes here.
+This is a dead simple, one-method downloader, with friendly error messages.
+
+EasyDownloader reduces the amount of work required to setup and check for errors when downloading from another location. This
+is useful when, for example, a client wants to you to pick a file up from their FTP, SFTP, or regular website on a nightly basis.
+EasyDownloader gives you a one-method means of downloading those files, returns with a friendly error message if it fails
+(geared at cron job notifications), or returns an array of file names it downloaded.
+
+== Example
+
+First, add the following to your Gemfile:
+
+  gem 'easy_downloader'
+
+Then, in your application:
+
+  my_results = EasyDownloader.download(
+      :type           => :ftp,
+      :host           => '127.0.0.1',
+      :user           => 'app',
+      :password       => 'example'
+      :remote_path    => '/some/directory/IWantToChangeTo'
+      :remote_pattern => '.*\.txt'
+      :local_path     => Rails.root+'/my_downloaded_stuff/'
+      )
+
+  my_results.results
+    => "We found 1 file(s) to download with the following names:
+        #1. test_file.txt
+        Started downloading at Tue Dec 21 16:04:46 -0500 2010
+        Progress:
+        Starting to download test_file.txt
+        Finished downloading test_file.txt
+        Finished downloading at Tue Dec 21 16:04:46 -0500 2010
+        Downloaded 1 file(s)"
+
+  my_results.files
+    => ['test_file.txt']
+
+The returned object only has two attributes (did I mention this was dead simple):
+ 1. result
+ 2. files
+
+The available keys are:
+
+  :type =>  (required) The protocal used to download the file. One of :sftp, :ftp or :http.
+  :host =>  (required) the domain of the remote server (source)
+  :remote_path => a relative path to "cd" into when we first access the remote server
+  :remote_pattern => a glob pattern that will select only the files we want to download.%
+     see Ruby's core API if you are not familiar with this concept.
+
+     NOTE: for *ftp* downloads, this matches a regular expression to the name of files in the current directory.
+           for *Sftp* downloads, this uses the 'glob' pattern as mentioned above.
+
+  :user =>  a username or login used for authenticating on the server
+  :password =>  a password that, in combination with the user, will grant access to the remote server/host
 
 == Contributing to easy_downloader
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project

data/VERSION

@@ -1 +1 @@
-0.0.2.alpha
+0.0.3.alpha

data/easy_downloader.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{easy_downloader}
-  s.version = "0.0.2.alpha"
+  s.version = "0.0.3.alpha"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bernardo Telles"]
-  s.date = %q{2010-12-21}
+  s.date = %q{2010-12-22}
   s.description = %q{ EasyDownloader reduces the amount of work required to setup and check for errors when downloading from another location. This 
                       is useful when, for example, a client wants to you to pick a file up from their FTP, SFTP, or regular website on a nightly basis.
                       EasyDownloader gives you a one-method means of downloading those files, returns with a friendly error message if it fails
@@ -30,11 +30,15 @@ Gem::Specification.new do |s|
     "VERSION",
     "easy_downloader.gemspec",
     "lib/easy_downloader.rb",
-    "lib/easy_downloader/ftp_downloader.rb",
-    "lib/easy_downloader/http_downloader.rb",
+    "lib/easy_downloader/abstract_loader.rb",
+    "lib/easy_downloader/downloader.rb",
+    "lib/easy_downloader/ftp.rb",
+    "lib/easy_downloader/http.rb",
     "lib/easy_downloader/options.rb",
     "lib/easy_downloader/result.rb",
-    "lib/easy_downloader/sftp_downloader.rb",
+    "lib/easy_downloader/sftp.rb",
+    "lib/easy_downloader/uploader.rb",
+    "spec/easy_downloader/abstract_loader_spec.rb",
     "spec/easy_downloader/options_spec.rb",
     "spec/spec_helper.rb"
   ]
@@ -44,6 +48,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{A dead simple, one-method downloader, with friendly error messages}
   s.test_files = [
+    "spec/easy_downloader/abstract_loader_spec.rb",
     "spec/easy_downloader/options_spec.rb",
     "spec/spec_helper.rb"
   ]

data/lib/easy_downloader/abstract_loader.rb

@@ -0,0 +1,50 @@
+module EasyDownloader
+  class AbstractLoader
+
+    attr_reader :files, :result
+
+    include Sftp
+    include Ftp
+    include Http
+
+    def initialize(*options)
+      @options= Options.new(*options)
+    end
+
+    def execute
+      begin
+        @options.result.started
+        execute_load
+        @options.result.loaded(@options.load_count)
+        @options.result.finished
+      rescue Exception => e
+        @options.result.errors= error_message(@options, e)
+      end
+      @result = @options.result
+      @files  = @result.loaded
+      self
+    end
+
+    private
+
+    def execute_load
+      raise NotImplementedError.new("#{self.class.name} does not have an 'execute_load' method.")
+    end
+
+    def error_message(options, e)
+      raise NotImplementedError.new("#{self.class.name} does not have an 'error_message' method.")
+    end
+
+    def local_files_list(options)
+      if options.local_file
+        [options.local_file]
+      else
+        Dir[options.local_path, options.local_pattern]
+      end
+    end
+
+    def options
+      @options
+    end
+  end
+end

data/lib/easy_downloader/downloader.rb

@@ -0,0 +1,34 @@
+module EasyDownloader
+  class Downloader < AbstractLoader
+
+    private
+
+    def execute_load
+      case @options.type
+      when :ftp
+        ftp_download(@options)
+      when :http
+        http_download(@options)
+      when :sftp
+        sftp_download(@options)
+      end
+    end
+
+    def error_message(options, e)
+      message = <<-ERROR_MESSAGE
+        There was a problem downloading from #{options.host}.
+        The error we got was:
+            #{e.message}
+            #{e.backtrace.inspect}
+        We tried connecting with:
+        host: #{options.host}
+        user: #{options.user}
+        pass: [filtered]
+        directory_path: #{options.remote_path}
+        file_pattern: #{options.remote_pattern}
+        destination: #{options.local_path}
+              ERROR_MESSAGE
+      message
+    end
+  end
+end

data/lib/easy_downloader/ftp.rb

@@ -0,0 +1,76 @@
+require 'net/ftp'
+module EasyDownloader
+  module Ftp
+    def ftp_download(options)
+      open_ftp do |ftp|
+
+        change_remote_dir(ftp)
+
+        files = ftp.nlst.select {|file_name| options.remote_pattern == '*' || file_name =~ Regexp.new(options.remote_pattern) }
+        total = files.size
+        options.result.found(files.size, files)
+
+        files.each do |path|
+          options.result.starting_path(path)
+          ftp.get(path, "#{options.local_path}#{path}")
+          options.load_count = options.load_count + 1
+          options.result.finished_path(path)
+          options.result.files_loaded << "#{options.local_path}#{path}"
+        end
+      end
+    end
+
+    def ftp_upload(options)
+      open_ftp do |ftp|
+
+        change_remote_dir(ftp)
+
+        files = local_files_list(options)
+        options.result.found(files.size, files)
+
+        files.each do |path|
+          options.result.starting_path(path)
+          if options.remote_file
+            ftp.put(path, options.remote_file)
+            options.result.files_loaded << options.remote_file
+          else
+            ftp.put(path)
+            options.result.files_loaded << File.basename(path)
+          end
+          options.load_count= options.load_count + 1
+          options.result.finished_path(path)
+        end
+      end
+    end
+
+    def open_ftp(&block)
+      Net::FTP.open(options.host,
+                    options.user,
+                    ftp_password_option(options.password)) do |ftp|
+        yield(ftp)
+      end
+    end
+
+    def change_remote_dir(ftp)
+      if options.remote_path.present?
+        begin
+          ftp.chdir(options.remote_path)
+        rescue InvalidRemoteDirectory
+        end
+      end
+    end
+
+    def ftp_password_option(password)
+      password ? password : nil
+    end
+
+
+    def remote_files_list(options)
+      if options.remote_file
+        [options.remote_file]
+      else
+        Dir[options.remote_path, options.remote_pattern]
+      end
+    end
+  end
+end

data/lib/easy_downloader/http.rb

@@ -0,0 +1,32 @@
+module EasyDownloader
+  module Http
+    def http_download(options)
+      #result = options.result
+      #result.started
+      #Net::SFTP.start(options.host,
+      #                options.user,
+      #                password_option(options.password)) do |sftp|
+
+      #  files = sftp.dir.glob(options.remote_path, options.remote_pattern)
+      #  total = files.size
+      #  result.found(files.size, files.map(&:name))
+
+      #  files.map(&:name).each do |path|
+      #    result.starting_path(path)
+      #    download_count += 1 if sftp.download!("#{options.remote_path}#{path}", "#{options.destination_dir}#{path}")
+      #    result.finished_path(path)
+      #    files_downloaded << "#{options.destination_dir}#{path}"
+      #  end
+      #end
+
+      #result.downloaded(download_count)
+      #result.finished
+    end
+
+    def password_option(password)
+      password ?
+        {:password => password} :
+        Hash.new
+    end
+  end
+end

data/lib/easy_downloader/options.rb

@@ -1,15 +1,17 @@
 require 'active_support/core_ext/array/extract_options'
 module EasyDownloader
   class Options
-    attr_accessor :files, :successful, :result, :download_count,
-                  :type, :host, :user, :password, :local_path,
-                  :destination_dir, :remote_path, :remote_pattern
+    attr_accessor :files, :successful, :result, :load_count,
+                  :type, :host, :user, :password,
+                  :local_path, :remote_path,
+                  :local_pattern, :remote_pattern,
+                  :local_file, :remote_file
 
     def initialize(*options)
       @files = []
       @successful      = false
       @result          = Result.new
-      @download_count = 0
+      @load_count = 0
       @options = options
 
       options.extract_options!.each do |key, value|
@@ -21,10 +23,20 @@ module EasyDownloader
       @type.to_sym
     end
 
+    def remote_path
+      to_dir_path(@remote_path)
+    end
+
     def local_path
-      @local_path =~ /\/$/ ?
-        @local_path :
-        @local_path + '/'
+      to_dir_path(@local_path)
+    end
+
+    def to_dir_path(path)
+      if path
+        path =~ /\/$/ ?  path : path + '/'
+      else
+        ''
+      end
     end
   end
 end

data/lib/easy_downloader/result.rb

@@ -1,10 +1,10 @@
 module EasyDownloader
   class Result
-    attr_accessor :errors, :files_downloaded
+    attr_accessor :errors, :files_loaded
 
     def initialize
       @header, @started, @finished, @errors= ''
-      @files_downloaded = []
+      @files_loaded = []
       @progress = ["Progress:"]
     end
 
@@ -20,7 +20,7 @@ module EasyDownloader
 
     def found(total_found, file_names)
       @found = total_found
-      @header= "We found #{total_found} file(s) to download with the following names: \n"
+      @header= "We found #{total_found} file(s) to load with the following names: \n"
       @found_list = file_names
     end
 
@@ -28,21 +28,31 @@ module EasyDownloader
       @started= Time.now
     end
 
+    def started_at; @started; end
+
     def finished
       @finished= Time.now
     end
 
-    def downloaded(total)
-      @downloaded = total
-      @footer= "Downloaded #{total} file(s)"
+    def finished_at; @finished; end
+
+
+
+    def loaded(total = false)
+      if total
+        @loaded = total
+        @footer= "Loaded #{total} file(s)"
+      else
+        @loaded
+      end
     end
 
     def starting_path(path)
-      @progress << "Starting to download #{path}"
+      @progress << "Starting to load #{path}"
     end
 
     def finished_path(path)
-      @progress << "Finished downloading #{path}"
+      @progress << "Finished loading #{path}"
     end
 
     private 
@@ -60,11 +70,11 @@ module EasyDownloader
     end
 
     def started_string
-      "Started downloading at #{@started}"
+      "Started loading at #{@started}"
     end
 
     def finished_string
-      "Finished downloading at #{@finished}"
+      "Finished loading at #{@finished}"
     end
 
   end

data/lib/easy_downloader/{sftp_downloader.rb → sftp.rb}

@@ -1,27 +1,20 @@
 module EasyDownloader
-  module SftpDownloader
+  module Sftp
     def sftp_download(options)
-      result = options.result
-      result.started
-
       Net::SFTP.start(options.host,
                       options.user,
                       sftp_password_option(options.password)) do |sftp|
 
         files = sftp.dir.glob(options.remote_path, options.remote_pattern)
-        total = files.size
-        result.found(files.size, files.map(&:name))
+        options.result.found(files.size, files.map(&:name))
 
         files.map(&:name).each do |path|
-          result.starting_path(path)
+          options.result.starting_path(path)
           options.download_count += 1 if sftp.download!("#{options.remote_path}#{path}", "#{options.local_path}#{path}")
-          result.finished_path(path)
-          result.files_downloaded << "#{options.local_path}#{path}"
+          options.result.finished_path(path)
+          options.result.files_downloaded << "#{options.local_path}#{path}"
         end
       end
-
-      result.downloaded(options.download_count)
-      result.finished
     end
 
     def sftp_password_option(password)

data/lib/easy_downloader/uploader.rb

@@ -0,0 +1,29 @@
+module EasyDownloader
+  class Uploader < AbstractLoader
+
+    private
+
+    def execute_load
+      [:ftp, :http, :sftp].include?(@options.type) ?
+        send("#{@options.type.to_s}_upload".to_sym, @options) :
+        raise(NotImplementedError.new("we don't have an uploader of this type."))
+    end
+
+    def error_message(options, e)
+      message = <<-ERROR_MESSAGE
+        There was a problem uploading to #{options.host}.
+        The error we got was:
+            #{e.message}
+            #{e.backtrace.inspect}
+        We tried connecting with:
+        host: #{options.host}
+        user: #{options.user}
+        pass: [filtered]
+        source: #{options.local_path}
+        remote directory path: #{options.remote_path}
+        remote file pattern: #{options.remote_pattern}
+              ERROR_MESSAGE
+      message
+    end
+  end
+end

data/lib/easy_downloader.rb

@@ -1,73 +1,24 @@
+require 'active_support'
+require 'active_support/core_ext'
 require 'easy_downloader/result'
 require 'easy_downloader/options'
-require 'easy_downloader/sftp_downloader'
-require 'easy_downloader/ftp_downloader'
-require 'easy_downloader/http_downloader'
+require 'easy_downloader/sftp'
+require 'easy_downloader/ftp'
+require 'easy_downloader/http'
+require 'easy_downloader/abstract_loader'
+require 'easy_downloader/downloader'
+require 'easy_downloader/uploader'
 require 'net/sftp'
 module EasyDownloader
 
   class InvalidRemoteDirectory < Exception; end
+
   def self.download(*options)
-    Downloader.new(*options)
+    Downloader.new(*options).execute
   end
 
-  class Downloader
-    attr_reader :files, :result
-
-    include SftpDownloader
-    include FtpDownloader
-    include HttpDownloader
-
-
-    # Set up and immediately download files. The object has only two attributes:
-    #   1. result
-    #   2. files
-    #
-    #  @param [Hash, #options] options to use including host, password, source, and destination directories.%
-    #    The available keys are:
-    #
-    #    :type =>  (required) The protocal used to download the file. One of :sftp, :ftp or :http.
-    #    :host =>  (required) the domain of the remote server (source)
-    #    :remote_path => a relative path to "cd" into when we first access the remote server
-    #    :remote_pattern => a glob pattern that will select only the files we want to download.%
-    #       see Ruby's core API if you are not familiar with this concept.
-    #    :user =>  a username or login used for authenticating on the server
-    #    :password =>  a password that, in combination with the user, will grant access to the remote server/host
-    def initialize(*options)
-      @options= Options.new(*options)
-      download
-      @result = @options.result
-      @files  = @result.files_downloaded
-    end
-
-    private
-
-    def download
-      begin
-        case @options.type
-        when :ftp
-          ftp_download(@options)
-        when :http
-          http_download(@options)
-        when :sftp
-          sftp_download(@options)
-        end
-
-      rescue Exception => e
-        @options.result.errors= <<-ERROR_MESSAGE
-  There was a problem downloading from #{@options.host}.
-  The error we got was:
-      #{e.message}
-      #{e.backtrace.inspect}
-  We tried connecting with:
-  host: #{@options.host}
-  user: #{@options.user}
-  pass: [filtered]
-  directory_path: #{@options.remote_path}
-  file_pattern: #{@options.remote_pattern}
-  destination: #{@options.local_path}
-        ERROR_MESSAGE
-      end
-    end
+  def self.upload(*options)
+    Uploader.new(*options).execute
   end
+
 end

data/spec/easy_downloader/abstract_loader_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'easy_downloader/abstract_loader'
+
+describe EasyDownloader::AbstractLoader do
+  describe "sets options" do
+    it "creates a new options object" do
+      abs = EasyDownloader::AbstractLoader.new(:local_path => 'hi')
+      abs.instance_variable_get(:@options).should be_instance_of(EasyDownloader::Options)
+    end
+  end
+
+  describe "#execute" do
+    subject { EasyDownloader::AbstractLoader.new({:local_path => 'hi'})}
+    before do
+      subject.stub(:execute_load => true)
+    end
+
+    it "sets the start time" do
+      subject.execute
+      subject.result.started_at.should be > (3.seconds.ago)
+    end
+
+    it "executes the load" do
+      subject.should_receive :execute_load
+      subject.execute
+    end
+
+    it "sets the finished time" do
+      subject.execute
+      subject.result.finished_at.should be > (3.seconds.ago)
+    end
+
+    it "sets the number of files loaded to 0 when starting out" do
+      subject.execute
+      subject.result.loaded.should == 0
+    end
+  end
+end

data/spec/easy_downloader/options_spec.rb

@@ -4,23 +4,50 @@ require 'easy_downloader/options'
 
 describe EasyDownloader::Options do
   context 'Accessors' do
-   [:files, :successful, :result, :download_count,
-    :host, :user, :password, :local_path,
-    :destination_dir, :remote_path, :remote_pattern].each do |accessor|
+   [:files, :successful, :result, :load_count,
+    :host, :user, :password,
+    :local_path, :remote_path,
+    :local_pattern, :remote_pattern,
+    :local_file, :remote_file].each do |accessor|
      specify {subject.should respond_to(accessor)}
     end
   end
 
   describe "exposes options" do
-    [:host, :user, :password, :remote_path, :remote_pattern, :local_path].each_with_index do |exposable_option, index|
+    [:host, :user, :password, :remote_pattern].each_with_index do |exposable_option, index|
       it "exposes #{exposable_option}" do
         option = EasyDownloader::Options.new(exposable_option => "hi there #{index}")
         option.send(exposable_option).should == "hi there #{index}"
       end
     end
+
     it "exposes type as a symbol" do
       option = EasyDownloader::Options.new(:type => "hithere")
       option.type.should == :hithere
     end
+
+    context "exposes local_path with a '/' in the end" do
+      it "even if there isn't one" do
+        option = EasyDownloader::Options.new(:local_path => "hithere")
+        option.send(:local_path).should == "hithere/"
+      end
+
+      it "if there's already one" do
+        option = EasyDownloader::Options.new(:local_path => "hithere/")
+        option.send(:local_path).should == "hithere/"
+      end
+    end
+
+    context "exposes remote_path with a '/' in the end" do
+      it "even if there isn't one" do
+        option = EasyDownloader::Options.new(:remote_path => "hithere")
+        option.send(:remote_path).should == "hithere/"
+      end
+
+      it "if there's already one" do
+        option = EasyDownloader::Options.new(:remote_path => "hithere/")
+        option.send(:remote_path).should == "hithere/"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: easy_downloader
 version: !ruby/object:Gem::Version 
-  hash: 296151478
+  hash: 296151474
   prerelease: true
   segments: 
   - 0
   - 0
-  - 2
+  - 3
   - alpha
-  version: 0.0.2.alpha
+  version: 0.0.3.alpha
 platform: ruby
 authors: 
 - Bernardo Telles
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-21 00:00:00 -05:00
+date: 2010-12-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -159,11 +159,15 @@ files:
 - VERSION
 - easy_downloader.gemspec
 - lib/easy_downloader.rb
-- lib/easy_downloader/ftp_downloader.rb
-- lib/easy_downloader/http_downloader.rb
+- lib/easy_downloader/abstract_loader.rb
+- lib/easy_downloader/downloader.rb
+- lib/easy_downloader/ftp.rb
+- lib/easy_downloader/http.rb
 - lib/easy_downloader/options.rb
 - lib/easy_downloader/result.rb
-- lib/easy_downloader/sftp_downloader.rb
+- lib/easy_downloader/sftp.rb
+- lib/easy_downloader/uploader.rb
+- spec/easy_downloader/abstract_loader_spec.rb
 - spec/easy_downloader/options_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -203,5 +207,6 @@ signing_key:
 specification_version: 3
 summary: A dead simple, one-method downloader, with friendly error messages
 test_files: 
+- spec/easy_downloader/abstract_loader_spec.rb
 - spec/easy_downloader/options_spec.rb
 - spec/spec_helper.rb

data/lib/easy_downloader/ftp_downloader.rb

@@ -1,39 +0,0 @@
-require 'net/ftp'
-module EasyDownloader
-  module FtpDownloader
-    def ftp_download(options)
-      download_count = options.download_count
-      result = options.result
-      result.started
-      Net::FTP.open(options.host,
-                    options.user,
-                    ftp_password_option(options.password)) do |ftp|
-
-        begin
-          ftp.chdir(options.remote_path) 
-        rescue InvalidRemoteDirectory
-        end
-
-        files = ftp.nlst.select {|file_name| options.remote_pattern == '*' || file_name =~ Regexp.new(options.remote_pattern) }
-        puts files.join("\n")
-        total = files.size
-        result.found(files.size, files)
-
-        files.each do |path|
-          result.starting_path(path)
-          ftp.get(path, "#{options.local_path}#{path}")
-          download_count += 1 
-          result.finished_path(path)
-          result.files_downloaded << "#{options.local_path}#{path}"
-        end
-      end
-
-      result.downloaded(download_count)
-      result.finished
-    end
-
-    def ftp_password_option(password)
-      password ? password : nil
-    end
-  end
-end

data/lib/easy_downloader/http_downloader.rb

@@ -1,30 +0,0 @@
-module HttpDownloader
-  def http_download(options)
-    #result = options.result
-    #result.started
-    #Net::SFTP.start(options.host,
-    #                options.user,
-    #                password_option(options.password)) do |sftp|
-
-    #  files = sftp.dir.glob(options.remote_path, options.remote_pattern)
-    #  total = files.size
-    #  result.found(files.size, files.map(&:name))
-
-    #  files.map(&:name).each do |path|
-    #    result.starting_path(path)
-    #    download_count += 1 if sftp.download!("#{options.remote_path}#{path}", "#{options.destination_dir}#{path}")
-    #    result.finished_path(path)
-    #    files_downloaded << "#{options.destination_dir}#{path}"
-    #  end
-    #end
-
-    #result.downloaded(download_count)
-    #result.finished
-  end
-
-  def password_option(password)
-    password ?
-      {:password => password} :
-      Hash.new
-  end
-end