date_named_file 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f891f2477e3244bcdd8dbe173a82c77d2b69f95dd851fc4334c49d8ca21f5d8
+  data.tar.gz: 82314bb7a4f069c15a82d8f87bd4fe114cbdcf504fec8495a2484ae0ac8af85e
+SHA512:
+  metadata.gz: 2d92757d19200579ecee7c88e85e35e8ed7a3329835fbea57f5f361c3ba20227fe82006618183ec870f4d8e99449e54524c270081e552eda46bf0c84f7aabc26
+  data.tar.gz: f84bc8f8eb057a47706d44fa7d65abbc74a38fdb56d539d0b4ab289f99a669e360a5488e79d89cbfe406cb200f9cc3317e5f487f456aff539c9b424c0c654880

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.2
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in date_named_file.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Bill Dueber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# DateNamedFile -- for files with embedded dates
+
+## Usage
+
+```ruby
+
+require 'date_named_file'
+
+update_file_template = DateNamedFile.new('hathi_upd_%Y%m%d.txt.gz')
+upd = update_file_template.in_dir('/tmp/')
+#=> #<DateNamedFile::Directory:0x00007fa4105de1a0...>
+
+# Today is 2019-11-22
+# All of these will produce either a DatedFile or a MissingFile, 
+# depending on whether or not they exist in teh directory
+
+# These are all the same
+f = upd.yesterday
+f = upd.at(:yesterday)
+f = upd.at(20191121)
+f = upd.at('2019-11-21')
+f = upd.at('2019_11_21')
+f = upd.at('11/21/2019')
+f = upd.at(-1)
+
+#=> <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191121.txt.gz>
+
+# Yesterday's file is there
+f.exist? #=> true
+
+# ...but today's is not
+upd.today #=>  <DateNamedFile::MissingFile:/private/tmp/hathi_upd_20191122.txt.gz>
+upd.today.exist? #=> false
+
+# So, which ones are there?
+ upd.matching_files
+# => [<DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191118.txt.gz>,
+ #    <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191119.txt.gz>,
+ #    <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191120.txt.gz>,
+ #    <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191121.txt.gz>]
+
+# A DateNamedFile::Directory is enumerable
+
+upd.each { ... }
+f = upd.first #=> <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191118.txt.gz>
+
+# Let's get everything since the 20th
+
+upd.since '2019-11-20' #or 
+upd.since -2
+# => [<DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191120.txt.gz>,
+#     <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191121.txt.gz>]
+
+
+
+# A DatedFiles compares based on the embedded DateTime
+upd.at('2019-11-11') > upd.at('2019-11-10') #=> true
+
+# ..even across different templates and embedded date formats
+full_files = DateNamedFile.new('hathi_full_%Y-%m-%d.txt').in_dir('/tmp')
+
+last_update = upd.last #=> <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191121.txt.gz>
+last_full  = full.last #=> <DateNamedFile::DatedFile:/private/tmp/hathi_full_2019-11-20.txt.gz>
+
+last_update > last_full #=> true
+
+# A DatedFile delegates most things to a Pathname object
+last_update.ctime # => 2019-11-22 14:22:49 -0500
+last_update.basename('.gz') #=> #<Pathname:hathi_upd_20191121.txt>
+
+#...but we override #open to automatically deal with .gz files
+# if need be
+
+last_update #=> <DateNamedFile::DatedFile:/private/tmp/hathi_upd_20191121.txt.gz>
+last_update.open.first #=> "mdp.39015018415946\tdeny\t..."
+
+
+```
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'date_named_file'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install date_named_file
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/billdueber/date_named_file.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "date_named_file"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/date_named_file.gemspec

@@ -0,0 +1,34 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "date_named_file/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "date_named_file"
+  spec.version       = DateNamedFile::VERSION
+  spec.authors       = ["Bill Dueber"]
+  spec.email         = ["bill@dueber.com"]
+
+  spec.summary       = %q{Utility to deal with files with embedded dates}
+  spec.homepage      = "https://github.com/billdueber/date_named_file"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage + "CHANGELOG.md"
+
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+end

data/lib/date_named_file.rb

@@ -0,0 +1,13 @@
+require "date_named_file/version"
+require 'date_named_file/template'
+require 'date_named_file/directory'
+require 'date_named_file/dated_file'
+
+module DateNamedFile
+  class Error < StandardError; end
+
+  def self.new(*args)
+    DateNamedFile::Template.new(*args)
+  end
+
+end

data/lib/date_named_file/dated_file.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'date_named_file/template'
+
+module DateNamedFile
+
+  class DatedFile < SimpleDelegator
+    include Comparable
+
+    attr_reader :datetime
+    # @param [DateNamedFile::Template] template
+    # @param [<anything date_ish>] date_ish (see #forgiving_dateify)
+    def initialize(template, date_ish=DateTime.now)
+      @template = template
+      self.datetime = date_ish
+    end
+
+    def self.from_filename(template, filename)
+      raise Error.new("String #{filename} does not match template '#{template.template_string}'") unless template.match? filename
+      newobject = self.new(template)
+      newobject.datetime = newobject.extract_datetime_from_filename(filename)
+      newobject
+    end
+
+    # Defining to_datetime allows Dateish.forgiving_datetime to
+    # deal with it directly
+    def to_datetime
+      self.datetime
+    end
+
+    def datetime=(date_ish)
+      @datetime = Dateish.forgiving_dateify(date_ish)
+      @path = Pathname.new(@template.filename_for(@datetime).to_s)
+      __setobj__ @path
+    end
+
+    def match?(other)
+      @template.match? other.to_s
+    end
+
+    def <=>(other)
+      if self.match? other.to_s
+        self.datetime <=> extract_datetime_from_filename(other)
+      else
+        d2 = Dateish.forgiving_dateify(other)
+        z = self.datetime <=> d2
+      end
+    end
+
+    def extract_datetime_from_filename(str)
+      if m = @template.matcher.match(str)
+        Dateish.forgiving_dateify(m[1..-1].join(''))
+      else
+        DateTime.new(0)
+      end
+    end
+
+    def open
+      raise "File #{@path.to_s} doesn't exist" unless @path.exist?
+      begin
+        Zlib::GzipReader.open(@path)
+      rescue Zlib::GzipFile::Error
+        File.open(@path)
+      end
+    end
+
+    # Override pretty-print so it shows up correctly in pry
+    def pretty_print(q)
+      q.text "<#{self.class}:#{@path}>"
+    end
+
+
+  end
+
+  class MissingFile < DatedFile
+
+    def exist?
+      false
+    end
+
+    alias_method :exists?, :exist?
+  end
+
+  class OldDatedFile < SimpleDelegator
+
+    attr_reader :embedded_date, :dft
+
+    alias_method :template, :dft
+    def initialize(dft, filename)
+      @path = Pathname.new(filename)
+      self.__setobj__ @path
+      @dft = dft
+      @embedded_date = dft.datetime_from_filename(@path.basename.to_s)
+    end
+
+    def self.from_filename(dft, filename)
+      raise Error.new("String #{filename} does not match template '#{dft.template}'") unless dft.match? filename
+      self.new(dft, filename)
+    end
+
+    def self.from_date(dft, date_ish)
+      self.new(dft, dft.filename_for(date_ish))
+    end
+
+    def open
+      raise "File #{@path.to_s} doesn't exist" unless @path.exist?
+      begin
+        Zlib::GzipReader.open(@path)
+      rescue Zlib::GzipFile::Error
+        File.open(@path)
+      end
+    end
+
+    def ==(other)
+      self.basename.to_s == other.basename.to_s
+    end
+
+    def to_s
+      @path.to_s
+    end
+
+    def inspect
+      "#<#{self.class.to_s}:#{@path} template=#{@dft.template}:#{object_id}>"
+    end
+
+    def pretty_inspect
+      "#<#{self.class.to_s}: #{@path}\n  @template=#{@dft.template}\n  @embedded_date=#{@embedded_date.to_s}\n #{object_id}>"
+    end
+
+  end
+
+end

data/lib/date_named_file/dateish.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'date'
+module DateNamedFile
+
+  class InvalidDateFormat < StandardError
+  end
+
+  class NonDigitsInDelimitedDate < InvalidDateFormat
+  end
+
+  class NonTwoDigitDateParts < InvalidDateFormat
+  end
+
+  # Provide some simple and very naïve methods to turn something that might be a date
+  # into a date.
+  module DateishHelpers
+
+    ALL_DIGITS       = /\A\d+\Z/
+    VALID_DELIMITERS = /[-_ :]/
+
+    # Attempt to turn big integer (turned into a string of digits),
+    # an actual string of digits, or a delimited
+    # string of digits (delimited by chars in VALID_DELIMITERS) into
+    # a DateTime.
+    #
+    # Should handle:
+    #  * Something that response to #to_datetime, which just calls that.
+    #  * The symbols :today, :yesterday, and :tomorrow
+    #  * unix timestamp (see #extract_unix_timestamp)
+    #  * string of digits YYYYMMDD (see #extract_undelimited_datetime)
+    #  * delimited string of digits (see #extract_delimited_datetime)
+    # @param [#to_datetime, Integer, String] date_ish The thing to try to convert
+    # @return [DateTime] Our best shot at a datetime
+    # @raise [InvalidDateFormat] if we can't pull a datetime out of it
+    def forgiving_dateify(date_ish)
+      return DateTime.now if date_ish == :today
+      return (DateTime.now - 1) if date_ish == :yesterday
+      return (DateTime.now + 1) if date_ish == :tomorrow
+      if date_ish.respond_to?(:to_i) and date_ish.to_i < 0
+        return DateTime.now + date_ish.to_i
+      end
+      if date_ish.respond_to? :to_datetime
+        date_ish.to_datetime
+      else
+        str = date_ish.to_s
+        if digit_string?(str)
+          extract_from_digitstring(str) or
+            raise InvalidDateFormat.new("All-digit string '#{str}' doesn't parse as date string or unix timestamp")
+        else
+          extract_delimited_datetime(str)
+        end
+      end
+    rescue InvalidDateFormat => e
+      raise InvalidDateFormat.new("Can't turn '#{date_ish}' into a date-time: #{e.message}")
+    end
+
+
+    def extract_from_digitstring(str)
+      extract_unix_timestamp(str) or
+        extract_undelimited_datetime(str)
+    end
+
+    # An undelimited datetime is a string of digits at least
+    # eight digits long (to get YYYYMMDD). Anything after that
+    # is pulled out into two-digit chunks and sent along to
+    # DateTime.new as integers. This means:
+    # * YYYYMMDD is always necessary; everything after that is optional
+    # * The rest must be in order: Hour, Minute, Second
+    # * Everything is assumed to be two digits and zero-padded
+    #
+    # Limitations:
+    # * No support for milliseconds with normal dates. Milliseconds are
+    # parsed but silently thrown out. Because c'mon, really?
+    # @param [String<0-9>] digit_string A string of digits
+    # @return [DateTime, FalseClass] The valid DateTime, or false (for chaining)
+    def extract_undelimited_datetime(digit_string)
+      return false unless digit_string?(digit_string)
+      m = /\A(\d{4})(\d{2})(\d{2})(\d{2})?(\d{2})?(\d{2})?\d*\Z/.match(digit_string)
+      if m
+        datetime_from_parts(m[1..-1].compact)
+      else
+        false
+      end
+    end
+
+    # Any string that is (a) exactly 10 digits, and (b) starts with '1'
+    # will be considered a unix timestamp and treated as such
+    # LIMITATION: Only good back to Sept 2001
+    # @param [String<0-9>] digit_string A string of digits, should be a unix timestamp
+    # @return [DateTime, FalseClass] The valid DateTime, or false (for chaining)
+    def extract_unix_timestamp(digit_string)
+      if looks_like_unix_timestamp?(digit_string)
+        DateTime.strptime(digit_string, '%s')
+      else
+        false
+      end
+    end
+
+    # Is this plausible a modern unix timestamp? Valid back to 2001
+    # @param [String] digit_string
+    # @return [Boolean]
+    def looks_like_unix_timestamp?(digit_string)
+      digit_string?(digit_string) and
+        digit_string.size == 10 and
+        /\A1[0-9]/.match(digit_string[0..1])
+    end
+
+
+    def extract_delimited_datetime(str)
+      str = perform_simple_transforms(str)
+      validate_delimited_datetime!(str)
+      year           = extract_year(str)
+      non_year_parts = extract_non_year_parts(str)
+      all_parts      = non_year_parts.unshift(year)
+      datetime_from_parts(all_parts)
+    rescue ArgumentError => e
+      # presumably a DateTime parse error
+      false
+    rescue NonTwoDigitDateParts
+      raise InvalidDateFormat.new("Trying to parse as delimited date. '#{str}' looks to have non-two-digit parts (no zero padding?).")
+    rescue NonDigitsInDelimitedDate
+      raise InvalidDateFormat.new("Trying to parse as delimited date. '#{str}' looks to have non-digits between delimiters.")
+    end
+
+    # Deal with d/m/yyyy
+    def perform_simple_transforms(str)
+      slash_matcher = %r[(\d{1,2})/(\d{1,2})/(\d{4})]
+      if m = slash_matcher.match(str)
+        '%4d-%02d-%02d' % [m[3], m[1], m[2]]
+      else
+        str
+      end
+    end
+
+    def datetime_from_parts(parts)
+      year           = parts[0]
+      non_year_parts = parts[1..-1].map { |dstring| dstring.scan(/\d\d/) }.flatten
+      all_parts      = non_year_parts.unshift(year).map(&:to_i)
+      DateTime.new(*all_parts)
+    rescue ArgumentError
+      raise InvalidDateFormat.new("DateTime.new rejected extracted parts ([#{parts.join(',')}]).")
+    end
+
+    def extract_non_year_parts(str)
+      parts = extract_rest(str).split(VALID_DELIMITERS)
+      validate_parts!(parts)
+      parts
+    end
+
+    def validate_parts!(parts)
+      unless parts.all? { |p| digit_string?(p) }
+        raise NonDigitsInDelimitedDate.new
+      end
+
+      unless parts.all? { |p| p.size == 2 }
+        raise NonTwoDigitDateParts.new
+      end
+    end
+
+
+
+    def digit_string?(str)
+      ALL_DIGITS.match(str)
+    end
+
+    def validate_delimited_datetime!(str)
+      /\A\d{4}/.match(str) or raise InvalidDateFormat.new("'#{str}' doesn't obviously start with a year")
+    end
+
+    def extract_year(str)
+      str[0..3]
+    end
+
+    def extract_rest(str)
+      everything_after_the_year = str[4..-1]
+      ditch_leading_delimiters(everything_after_the_year)
+    end
+
+    def ditch_leading_delimiters(str)
+      str.sub(/\A#{VALID_DELIMITERS}/, '')
+    end
+
+
+  end
+
+  module Dateish
+    extend DateNamedFile::DateishHelpers
+  end
+end