net-ftp-list 3.2.11 → 3.3.0

data/lib/net/ftp/list/netware.rb

@@ -9,27 +9,25 @@ require 'time'
 class Net::FTP::List::Netware < Net::FTP::List::Parser
   # Stolen straight from the ASF's commons Java FTP LIST parser library.
   # http://svn.apache.org/repos/asf/commons/proper/net/trunk/src/java/org/apache/commons/net/ftp/
-  REGEXP = %r!^
+  REGEXP = /^
     (d|-){1}\s+
     \[(.*?)\]\s+
     (\S+)\s+(\d+)\s+
     (\S+\s+\S+\s+((\d+:\d+)|(\d{4})))
     \s+(.*)
-  $!x
+  $/x.freeze
 
   # Parse a Netware like FTP LIST entries.
-  def self.parse(raw)
+  def self.parse(raw, timezone: :utc)
     match = REGEXP.match(raw.strip) or return false
-
-    is_dir = match[1] == 'd'
+    type  = match[1] == 'd' ? :dir : :file
 
     emit_entry(
       raw,
-      :mtime => Time.parse(match[5]),
-      :filesize => match[4].to_i,
-      :dir => is_dir, 
-      :file => !is_dir,
-      :basename => match[9]
+      mtime: parse_time(match[5], timezone: timezone),
+      filesize: match[4].to_i,
+      type: type,
+      basename: match[9],
     )
   end
 end

data/lib/net/ftp/list/parser.rb

@@ -1,28 +1,45 @@
+require 'date'
+
 # Abstract FTP LIST parser. It really just defines and documents the interface.
 class Net::FTP::List::Parser
+  class << self
+    # Returns registered parsers.
+    def parsers
+      @parsers ||= []
+    end
 
-  @@parsers = []
+    # Manuall register a parser.
+    def register(parser)
+      parsers.push(parser) unless parsers.include?(parser)
+    end
 
-  # Run a passed block with each parser in succession, from the most specific to the least
-  # specific. Will return the result of the block.
-  def self.with_each_parser(&blk) #:yields: parser
-    @@parsers.each(&blk)
-  end
+    # Automatically add an inheriting parser to the list of known parsers.
+    def inherited(klass)
+      super
+      register(klass)
+    end
 
-  # Automatically add an inheriting parser to the list of known parsers.
-  def self.inherited(klass) #:nodoc:
-    @@parsers.push(klass)
-  end
+    # The main parse method. Return false from it if parsing fails (this is cheaper than raising an exception)
+    def parse(_raw, **)
+      false
+    end
 
-  # The main parse method. Return false from it if parsing fails (this is cheaper than raising an exception)
-  def self.parse(raw)
-    return false
-  end
+    private
 
-  private
+    # Automatically adds the name of the parser class to the server_type field
+    def emit_entry(raw, **extra)
+      Net::FTP::List::Entry.new raw, **extra, server_type: to_s.split('::').pop
+    end
 
-  # Automatically adds the name of the parser class to the server_type field
-  def self.emit_entry(raw, extra_attributes)
-    Net::FTP::List::Entry.new raw, extra_attributes.merge(:server_type => to_s.split('::').pop)
+    def parse_time(str, timezone:, format: nil)
+      case timezone
+      when :utc
+        (format ? DateTime.strptime(str, format) : DateTime.parse(str)).to_time
+      when :local
+        format ? Time.strptime(str, format) : Time.parse(str)
+      else
+        raise ArgumentError, "invalid timezone #{timezone}, only :utc and :local are allowed"
+      end
+    end
   end
 end

data/lib/net/ftp/list/rumpus.rb

@@ -6,28 +6,27 @@ require 'net/ftp/list/parser'
 # drwxr-xr-x               folder        0 Nov 30 10:03 houdini
 # -rw-r--r--        0      101426   101426 Jun  7  2008 imap with spaces.rb
 class Net::FTP::List::Rumpus < Net::FTP::List::Parser
-
-  REGEXP = %r!^
-    ([drwxr-]{10})\s+
+  REGEXP = /^
+    ([drwx-]{10})\s+
     (folder|0\s+\d+)\s+
     (\d+)\s+
     (\w+)\s+
     (\d{1,2})\s+
     (\d{2}:\d{2}|\d{4})\s+
     (.+)
-  $!x
+  $/x.freeze
 
   # Parse a Rumpus FTP LIST entry.
-  def self.parse(raw)
+  def self.parse(raw, timezone: :utc)
     match = REGEXP.match(raw.strip) or return false
+    type  = match[2] == 'folder' ? :dir : :file
 
     emit_entry(
       raw,
-      :basename => match[7],
-      :mtime => Time.parse([match[4], match[5], match[6]].join(" ")),
-      :file => !(match[2] == "folder"),
-      :dir => (match[2] == "folder"),
-      :filesize => match[3].to_i
+      basename: match[7],
+      mtime: parse_time(match[4..6].join(' '), timezone: timezone),
+      type: type,
+      filesize: match[3].to_i,
     )
   end
 end

data/lib/net/ftp/list/unix.rb

@@ -8,11 +8,10 @@ require 'net/ftp/list/parser'
 #   drwxr-xr-x   4 steve    group       4096 Dec 10 20:23 etc
 #   -rw-r--r--   1 root     other        531 Jan 29 03:26 README.txt
 class Net::FTP::List::Unix < Net::FTP::List::Parser
-
   # Stolen straight from the ASF's commons Java FTP LIST parser library.
   # http://svn.apache.org/repos/asf/commons/proper/net/trunk/src/java/org/apache/commons/net/ftp/
   REGEXP = %r{
-    ([pbcdlfmpSs-])
+    ([pbcdlfmSs-])
     (((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))\+?\s+
     (?:(\d+)\s+)?
     (\S+)?\s+
@@ -22,69 +21,63 @@ class Net::FTP::List::Unix < Net::FTP::List::Parser
     ((?:\d+[-/]\d+[-/]\d+)|(?:\S+\s+\S+))\s+
     (\d+(?::\d+)?)\s+
     (\S*)(\s*.*)
-  }x
+  }x.freeze
 
   ONE_YEAR = (60 * 60 * 24 * 365)
 
   # Parse a Unix like FTP LIST entries.
-  def self.parse(raw)
+  def self.parse(raw, timezone: :utc)
     match = REGEXP.match(raw.strip) or return false
-
-    dir, symlink, file, device = false, false, false, false
-    case match[1]
-      when /d/      then dir = true
-      when /l/      then symlink = true
-      when /[f-]/   then file = true
-      when /[psbc]/ then device = true
-    end
-    return false unless dir or symlink or file or device
+    type  = case match[1]
+            when /d/      then :dir
+            when /l/      then :symlink
+            when /[f-]/   then :file
+            when /[psbc]/ then :device
+            end
+    return false if type.nil?
 
     # Don't match on rumpus (which looks very similar to unix)
-    return false if match[17].nil? and ((match[15].nil? and match[16].to_s == 'folder') or match[15].to_s == '0')
+    return false if match[17].nil? && ((match[15].nil? && (match[16].to_s == 'folder')) || (match[15].to_s == '0'))
 
     # TODO: Permissions, users, groups, date/time.
     filesize = match[18].to_i
-    
     mtime_month_and_day = match[19]
     mtime_time_or_year = match[20]
 
     # Unix mtimes specify a 4 digit year unless the data is within the past 180
-    # days or so. Future dates always specify a 4 digit year. 
+    # days or so. Future dates always specify a 4 digit year.
     # If the parsed date, with today's year, could be in the future, then
     # the date must be for the previous year
-    mtime_string = if mtime_time_or_year.match(/^[0-9]{1,2}:[0-9]{2}$/)
-      if Time.parse("#{mtime_month_and_day} #{Time.now.year}") > Time.now
-        "#{mtime_month_and_day} #{mtime_time_or_year} #{Time.now.year - 1}"
-      else
-        "#{mtime_month_and_day} #{mtime_time_or_year} #{Time.now.year}"
-      end
-    elsif mtime_time_or_year.match(/^[0-9]{4}$/)
-      "#{mtime_month_and_day} #{mtime_time_or_year}"
-    end
-
-    mtime = Time.parse(mtime_string)
+    mtime_string = case mtime_time_or_year
+                   when /^[0-9]{1,2}:[0-9]{2}$/
+                     if parse_time("#{mtime_month_and_day} #{Time.now.year}", timezone: timezone) > Time.now
+                       "#{mtime_month_and_day} #{mtime_time_or_year} #{Time.now.year - 1}"
+                     else
+                       "#{mtime_month_and_day} #{mtime_time_or_year} #{Time.now.year}"
+                     end
+                   when /^[0-9]{4}$/
+                     "#{mtime_month_and_day} #{mtime_time_or_year}"
+                   end
 
+    mtime = parse_time(mtime_string, timezone: timezone)
     basename = match[21].strip
 
     # filenames with spaces will end up in the last match
     basename += match[22] unless match[22].nil?
 
     # strip the symlink stuff we don't care about
-    if symlink
-      basename.sub!(/\s+\->(.+)$/, '')
-      symlink_destination = $1.strip if $1
+    if type == :symlink
+      basename.sub!(/\s+->(.+)$/, '')
+      symlink_destination = Regexp.last_match(1).strip if Regexp.last_match(1)
     end
 
     emit_entry(
       raw,
-      :dir => dir,
-      :file => file,
-      :device => device,
-      :symlink => symlink,
-      :filesize => filesize,
-      :basename => basename,
-      :symlink_destination => symlink_destination,
-      :mtime => mtime
+      type: type,
+      filesize: filesize,
+      basename: basename,
+      symlink_destination: symlink_destination,
+      mtime: mtime,
     )
   end
 end

data/lib/net/ftp/list/unknown.rb

@@ -3,12 +3,9 @@ require 'net/ftp/list/parser'
 # If all other attempts to parse the entry fail this is the parser that is going to be used.
 # It might be a good idea to fail loudly.
 class Net::FTP::List::Unknown < Net::FTP::List::Parser
-  def self.parse(raw)
-    if Net::FTP::List.raise_on_failed_server_detection
-      raise Net::FTP::List::ParseError, "Could not parse #{raw} since none of the parsers was up to the task"
-    end
+  def self.parse(raw, **)
+    raise Net::FTP::List::ParseError, "Could not parse #{raw} since none of the parsers was up to the task" if Net::FTP::List.raise_on_failed_server_detection
 
-    emit_entry(raw, {})
+    emit_entry(raw)
   end
 end
-

data/net-ftp-list.gemspec

@@ -1,61 +1,19 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: net-ftp-list 3.2.11 ruby lib
-
 Gem::Specification.new do |s|
-  s.name = "net-ftp-list".freeze
-  s.version = "3.2.11"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib".freeze]
-  s.authors = ["Stateless Systems".freeze]
-  s.date = "2018-04-02"
-  s.email = "enquiries@statelesssystems.com".freeze
-  s.extra_rdoc_files = [
-    "README.txt"
-  ]
-  s.files = [
-    ".ruby-version",
-    "Gemfile",
-    "Gemfile.lock",
-    "README.txt",
-    "Rakefile",
-    "VERSION.yml",
-    "lib/net/ftp/list.rb",
-    "lib/net/ftp/list/entry.rb",
-    "lib/net/ftp/list/microsoft.rb",
-    "lib/net/ftp/list/netware.rb",
-    "lib/net/ftp/list/parser.rb",
-    "lib/net/ftp/list/rumpus.rb",
-    "lib/net/ftp/list/unix.rb",
-    "lib/net/ftp/list/unknown.rb",
-    "net-ftp-list.gemspec",
-    "test/test_net_ftp_list.rb",
-    "test/test_net_ftp_list_entry.rb",
-    "test/test_net_ftp_list_microsoft.rb",
-    "test/test_net_ftp_list_netware.rb",
-    "test/test_net_ftp_list_rumpus.rb",
-    "test/test_net_ftp_list_unix.rb"
-  ]
-  s.homepage = "http://github.com/stateless-systems/net-ftp-list".freeze
-  s.rubygems_version = "2.7.6".freeze
-  s.summary = "Parse FTP LIST command output.".freeze
+  s.name = 'net-ftp-list'
+  s.version = '3.3.0'
+  s.authors = ['Stateless Systems']
+  s.email = 'enquiries@statelesssystems.com'
+  s.summary = 'Parse FTP LIST command output.'
+  s.homepage = 'http://github.com/stateless-systems/net-ftp-list'
+  s.license = 'MIT'
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
+  s.files         = `git ls-files -z`.split("\x0").reject {|f| f.start_with?('test/') }
+  s.test_files    = `git ls-files -z -- test/*`.split("\x0")
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 2.5'
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<jeweler>.freeze, [">= 0"])
-      s.add_development_dependency(%q<test-unit>.freeze, [">= 0"])
-    else
-      s.add_dependency(%q<jeweler>.freeze, [">= 0"])
-      s.add_dependency(%q<test-unit>.freeze, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<jeweler>.freeze, [">= 0"])
-    s.add_dependency(%q<test-unit>.freeze, [">= 0"])
-  end
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rubocop-bsm'
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'timecop'
 end
-

data/test/test_net_ftp_list.rb

@@ -2,14 +2,13 @@ require 'test/unit'
 require 'net/ftp/list'
 
 class TestNetFTPList < Test::Unit::TestCase
-
   def test_all
     one = Net::FTP::List.parse('drwxr-xr-x 4 user     group    4096 Dec 10 20:23 etc')
     assert_kind_of Net::FTP::List::Entry, one
     assert one.dir?
     assert !one.file?
 
-    two = Net::FTP::List.parse("++ unknown garbage +++")
+    two = Net::FTP::List.parse('++ unknown garbage +++')
     assert_kind_of Net::FTP::List::Entry, two
     assert two.unknown?
     assert_equal '', two.basename
@@ -18,7 +17,7 @@ class TestNetFTPList < Test::Unit::TestCase
   def test_raise_when_flag_set
     Net::FTP::List.raise_on_failed_server_detection = true
     assert_raise(Net::FTP::List::ParseError) do
-      Net::FTP::List.parse("++ unknown garbage +++")
+      Net::FTP::List.parse('++ unknown garbage +++')
     end
   ensure
     Net::FTP::List.raise_on_failed_server_detection = false

data/test/test_net_ftp_list_entry.rb

@@ -1,18 +1,18 @@
 require 'test/unit'
 require 'net/ftp/list'
+require 'bigdecimal'
 
 class TestNetFTPEntry < Test::Unit::TestCase
-
   def test_equality
-    a = Net::FTP::List::Entry.new('foo1', {:basename => 'foo1'})
-    b = Net::FTP::List::Entry.new('foo2', {:basename => 'foo2'})
-    c = Net::FTP::List::Entry.new('foo1', {:basename => 'foo1'})
+    a = Net::FTP::List::Entry.new('foo1', basename: 'foo1')
+    b = Net::FTP::List::Entry.new('foo2', basename: 'foo2')
+    c = Net::FTP::List::Entry.new('foo1', basename: 'foo1')
 
-    assert a.eql? c
+    assert a.eql?(c)
     assert a.eql? a
     assert !a.eql?(b)
     assert !a.eql?(1)
-    assert !a.eql?(1.0)
+    assert !a.eql?(BigDecimal('1.0'))
   end
 
   def test_comparison
@@ -26,24 +26,24 @@ class TestNetFTPEntry < Test::Unit::TestCase
 
     assert file2 > file1
     assert file2 >= file1
-    assert file2 == file2
+    assert file2 == Net::FTP::List.parse(raw2)
+    assert file2 <= file3
+    assert file2 < file3
+    assert file2 >= file1
+    assert file2 > file1
+    assert file2 != file1
+    assert file2 != file3
     assert file2 <= file3
     assert file2 < file3
-    assert !(file2 < file1)
-    assert !(file2 <= file1)
-    assert !(file2 == file1)
-    assert !(file2 == file3)
-    assert !(file2 > file3)
-    assert !(file2 >= file3)
 
-    assert !(file2 < 2)
-    assert !(file2 < 2.0)
+    assert file2 >= 2
+    assert file2 >= 2.0
     assert file2 <= 2
     assert file2 <= 2.0
     assert file2 == 2
-    assert file2 == 2.0
-    assert !(file2 > 2)
-    assert !(file2 > 2.0)
+    assert file2 == BigDecimal('2.0')
+    assert file2 <= 2
+    assert file2 <= 2.0
     assert file2 >= 2
     assert file2 >= 2.0
 
@@ -52,7 +52,7 @@ class TestNetFTPEntry < Test::Unit::TestCase
   end
 
   def test_raise_on_unknown_options
-    assert_raise(ArgumentError) { Net::FTP::List::Entry.new("foo", {:bar => "baz"}) }
+    assert_raise(ArgumentError) { Net::FTP::List::Entry.new('foo', bar: 'baz') }
   end
 
   def test_default_values
@@ -67,7 +67,6 @@ class TestNetFTPEntry < Test::Unit::TestCase
     assert !e.file?
     assert !e.symlink?
     assert_kind_of Time, e.mtime
-    assert_equal "Unknown", e.server_type
+    assert_equal 'Unknown', e.server_type
   end
-
 end