gtfs_reader 1.2.0 → 3.1.0

data/lib/gtfs_reader/file_row.rb

@@ -3,64 +3,72 @@ require 'csv'
 module GtfsReader
   # Contains the contents of a single row read in from the file
   class FileRow
-    attr_reader :line_number
+    attr_reader :line_number, :headers
 
-    #@param line_number [Integer] the line number from the source file
-    #@return [Array<Symbol>]
-    #@param data [CSV::Row] the data for this row
-    #@param definition [FileDefinition] the definition of the columns that the
-    #  data in this row represent
+    # @param line_number [Integer] the line number from the source file
+    # @return [Array<Symbol>]
+    # @param data [CSV::Row] the data for this row
+    # @param definition [FileDefinition] the definition of the columns that the
+    #   data in this row represent
     def initialize(line_number, headers, data, definition, do_parse)
-      @line_number, @headers, @data, @definition, @do_parse =
-          line_number, headers, data, definition, do_parse
+      @line_number = line_number
+      @headers = headers
+      @data = data
+      @definition = definition
+      @do_parse = do_parse
       @parsed = {}
     end
 
-    #@return [Array<Symbol>]
-    def headers
-      @headers
-    end
-
-    #@param column [Symbol] the name of the column to fetch
-    #@return the parsed data for the column at this row
-    #@see #raw
+    # @param column [Symbol] the name of the column to fetch
+    # @return the parsed data for the column at this row
+    # @see #raw
     def [](column)
       return raw(column) unless @do_parse
 
-      @parsed[column] ||= begin
-        ParserContext.new(column, self).
-            instance_exec raw(column), &@definition[column].parser
-      end
+      @parsed[column] ||=
+        ParserContext.new(column, self)
+                     .instance_exec(raw(column), &@definition[column].parser)
+    end
+
+    # @return [Boolean] if this row has the given column
+    def col?(col)
+      @headers.include?(col)
     end
 
-    #@param (see #[])
-    #@return the data unparsed data from the column at this row
+    # @param (see #[])
+    # @return the data unparsed data from the column at this row
     def raw(column)
       @data[column]
     end
 
-    #@return [Hash] a hash representing this row of data, where each key is the
-    #  column name and each value is the parsed data for this row
+    # @return [Hash] a hash representing this row of data, where each key is the
+    #   column name and each value is the parsed data for this row
     def to_hash
-      ::Hash[ *headers.inject([]) {|list,h| list << h << self[h] } ]
+      ::Hash[
+        *headers.inject([]) { |list, h| list << h << self[h] }
+      ]
     end
 
-    #@return [Array] an array representing this row of data
+    # @return [Array] an array representing this row of data
     def to_a
-      headers.map {|h| self[h] }
+      headers.map { |h| self[h] }
     end
   end
 
   class ParserContext
     def initialize(column, file_row)
-      @column, @file_row = column, file_row
+      @column = column
+      @file_row = file_row
     end
 
     def method_missing(column)
-      if column == @column
-        raise "Parser for '#{column}' cannot refer to itself"
-      end
-      @file_row[column] or super
+      raise "Parser for '#{column}' cannot refer to itself" if column == @column
+
+      @file_row.col?(column) ? @file_row[column] : super
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
     end
   end
 end

data/lib/gtfs_reader/log.rb

@@ -1,18 +1,31 @@
-require 'log4r'
-require 'log4r/formatter/patternformatter'
+require 'logger'
 require 'colorize'
 
 module GtfsReader
   module Log
     class << self
-      def debug(*args, &block); log :debug, *args, &block end
-      def  info(*args, &block); log :info,  *args, &block end
-      def  warn(*args, &block); log :warn,  *args, &block end
-      def error(*args, &block); log :error, *args, &block end
-      def fatal(*args, &block); log :fatal, *args, &block end
+      def debug(*args, &block)
+        log(:debug, *args, &block)
+      end
+
+      def info(*args, &block)
+        log(:info,  *args, &block)
+      end
+
+      def warn(*args, &block)
+        log(:warn,  *args, &block)
+      end
+
+      def error(*args, &block)
+        log(:error, *args, &block)
+      end
+
+      def fatal(*args, &block)
+        log(:fatal, *args, &block)
+      end
 
       def log(level, *args, &block)
-        logger.send level, *args, &block
+        logger.send(level, *args, &block)
         nil
       end
 
@@ -23,14 +36,14 @@ module GtfsReader
 
       def level=(lev)
         logger.level =
-            case lev
-            when :debug then logger.levels.index 'DEBUG'
-            when :info  then logger.levels.index 'INFO'
-            when :warn  then logger.levels.index 'WARN'
-            when :error then logger.levels.index 'ERROR'
-            when :fatal then logger.levels.index 'FATAL'
-            else raise "unknown log level '#{lev}'"
-            end
+          case lev
+          when :debug then Logger::DEBUG
+          when :info  then Logger::INFO
+          when :warn  then Logger::WARN
+          when :error then Logger::ERROR
+          when :fatal then Logger::FATAL
+          else raise "unknown log level '#{lev}'"
+          end
       end
 
       def level
@@ -51,20 +64,21 @@ module GtfsReader
       private
 
       def create_logger
-        Log4r::Logger.new('GtfsReader').tap do |log|
-          out = Log4r::StdoutOutputter.new('log_stdout')
-          out.formatter = Log4r::PatternFormatter.new pattern: '%d [%l]: %m'
-          log.outputters << out
-          log.level = Log4r::INFO
-          log.debug { 'Starting GtfsReader...'.underline.colorize :yellow }
+        Logger.new($stderr).tap do |log|
+          log.level = Logger::INFO
+          log.debug { 'Starting GtfsReader...'.underline.colorize(:yellow) }
         end
       end
     end
 
     class NoOpLogger
-      def method_missing(*args, &block)
+      def method_missing(*_args)
         nil
       end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
     end
   end
 end

data/lib/gtfs_reader/source_updater.rb

@@ -11,45 +11,44 @@ module GtfsReader
   # Downloads remote Feed files, checks that they are valid, and passes each
   # file in the feed to the handlers in the given [Source].
   class SourceUpdater
-    #@param name [String] an arbitrary string describing this source
-    #@param source [Source]
+    # @param name [String] an arbitrary string describing this source
+    # @param source [Source]
     def initialize(name, source)
-      @name, @source = name, source
+      @name = name
+      @source = source
       @temp_files = {}
     end
 
     # Call the "before" callback set on this source
     def before_callbacks
-      if @source.before
-        @source.before.call fetch_data_set_identifier
-      end
+      @source.before.call(fetch_data_set_identifier) if @source.before
     end
 
     # Download the data from the remote server
     def download_source
       Log.debug { "         Reading #{@source.url.green}" }
-      zip = Tempfile.new 'gtfs'
+      zip = Tempfile.new('gtfs')
       zip.binmode
       zip << open(@source.url).read
       zip.rewind
 
-      extract_to_tempfiles zip
+      extract_to_tempfiles(zip)
 
       Log.debug { "Finished reading #{@source.url.green}" }
-    rescue Exception => e
-      Log.error e.message
+    rescue StandardException => e
+      Log.error(e.message)
       raise e
     ensure
-      zip.try :close
+      zip.try(:close)
     end
 
     def close
-      @temp_files.values.each &:close
+      @temp_files.values.each(&:close)
     end
 
     # Parse the filenames in the feed and check which required and optional
     # files are present.
-    #@raise [RequiredFilenamesMissing] if the feed is missing a file which is
+    # @raise [RequiredFilenamesMissing] if the feed is missing a file which is
     #  marked as "required" in the [FeedDefinition]
     def check_files
       @found_files = []
@@ -57,9 +56,7 @@ module GtfsReader
       check_optional_files
       # Add feed files of zip to the list of files to be processed
       @source.feed_definition.files.each do |req|
-        if filenames.include? req.filename
-          @found_files << req
-        end
+        @found_files << req if filenames.include?(req.filename)
       end
     end
 
@@ -67,15 +64,15 @@ module GtfsReader
     def check_columns
       @found_files.each do |file|
         @temp_files[file.filename].open do |data|
-          FileReader.new data, file, validate: true
+          FileReader.new(data, file, validate: true)
         end
       end
     end
 
     def process_files
       @found_files.each do |file|
-        if @source.handlers.handler? file.name
-          process_from_temp_file file
+        if @source.handlers.handler?(file.name)
+          process_from_temp_file(file)
         else
           Log.warn { "Skipping #{file.filename.yellow} (no handler)" }
         end
@@ -86,7 +83,7 @@ module GtfsReader
 
     def extract_to_tempfiles(zip)
       Zip::File.open(zip).each do |entry|
-        temp = Tempfile.new "gtfs_file_#{entry.name}"
+        temp = Tempfile.new("gtfs_file_#{entry.name}")
         temp.binmode
         temp << entry.get_input_stream.read
         temp.close
@@ -96,22 +93,22 @@ module GtfsReader
 
     # Check for the given list of expected filenames in the zip file
     def check_missing_files(expected, found_color, missing_color)
-      check = '✔'.colorize found_color
-      cross = '✘'.colorize missing_color
+      check = '✔'.colorize(found_color)
+      cross = '✘'.colorize(missing_color)
 
       expected.map do |req|
         filename = req.filename
-        if filenames.include? filename
-          Log.info { "#{filename.rjust filename_width} [#{check}]" }
+        if filenames.include?(filename)
+          Log.info { "#{filename.rjust(filename_width)} [#{check}]" }
           nil
         else
-          Log.info { "#{filename.rjust filename_width} [#{cross}]" }
+          Log.info { "#{filename.rjust(filename_width)} [#{cross}]" }
           filename
         end
       end.compact
     end
 
-    #@return <FixNum> the maximum string-width of the filenames, so they can be
+    # @return <FixNum> the maximum string-width of the filenames, so they can be
     #  aligned when printed on the console.
     def filename_width
       @filename_width ||= @source.feed_definition.files.max do |a, b|
@@ -132,22 +129,22 @@ module GtfsReader
     #   the same if they happen to have the same size)
     # - The current date/time (this will always result in a fresh download)
     def fetch_data_set_identifier
-      if @source.url =~ /\A#{URI::regexp}\z/
-        uri = URI @source.url
+      if @source.url =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+        uri = URI(@source.url)
         Net::HTTP.start(uri.host) do |http|
-          head_request = http.request_head uri.path
-          if head_request.key? 'etag'
+          head_request = http.request_head(uri.path)
+          if head_request.key?('etag')
             head_request['etag']
           else
-            Log.warn "No ETag supplied with: #{uri.path}"
-            fetch_http_fallback_identifier head_request
+            Log.warn("No ETag supplied with: #{uri.path}")
+            fetch_http_fallback_identifier(head_request)
           end
         end
       else # it's not a url, it may be a file => last modified
         begin
-          File.mtime @source.url
+          File.mtime(@source.url)
         rescue StandardError => e
-          Log.error e
+          Log.error(e)
           raise e
         end
       end
@@ -156,9 +153,9 @@ module GtfsReader
     # Find a "next best" ID when the HEAD request does not return an "ETag"
     # header.
     def fetch_http_fallback_identifier(head_request)
-      if head_request.key? 'last-modified'
+      if head_request.key?('last-modified')
         head_request['last-modified']
-      elsif head_request.key? 'content-length'
+      elsif head_request.key?('content-length')
         head_request['content-length']
       else
         Time.now.to_s
@@ -169,27 +166,27 @@ module GtfsReader
       do_parse = !GtfsReader.config.skip_parsing
       hash = !!GtfsReader.config.return_hashes
 
-      Log.info "Reading file #{file.filename.cyan}..."
+      Log.info("Reading file #{file.filename.cyan}...")
       begin
-        reader = FileReader.new @temp_files[file.filename], file,
-                                parse: do_parse, hash: hash
-        @source.handlers.handle_file file.name, reader
+        reader = FileReader.new(@temp_files[file.filename], file,
+                                parse: do_parse, hash: hash)
+        @source.handlers.handle_file(file.name, reader)
       end
     end
 
-    #@raise [RequiredFilenamesMissing] if a file is missing a header which is
+    # @raise [RequiredFilenamesMissing] if a file is missing a header which is
     #  marked as "required" in the [FeedDefinition]
     def check_required_files
       Log.info { 'required files'.magenta }
       files = @source.feed_definition.required_files
-      missing = check_missing_files files, :green, :red
+      missing = check_missing_files(files, :green, :red)
       raise RequiredFilenamesMissing, missing unless missing.empty?
     end
 
     def check_optional_files
       Log.info { 'optional files'.cyan }
       files = @source.feed_definition.optional_files
-      check_missing_files files, :cyan, :light_yellow
+      check_missing_files(files, :cyan, :light_yellow)
     end
   end
 end

data/lib/gtfs_reader/version.rb

@@ -3,27 +3,28 @@ module GtfsReader
   # {Bumper} class which will modify this file to increase the version
   module Version
     # The following four lines are generated, so don't mess with them.
-    MAJOR = 1
-    MINOR = 2
+    MAJOR = 3
+    MINOR = 1
     PATCH = 0
     BUILD = nil
 
-    #@return [String] the current version in the form of +1.2.3.build+
+    # @return [String] the current version in the form of +1.2.3.build+
     def self.to_s
-      [MAJOR, MINOR, PATCH, BUILD].compact.join '.'
+      [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
     end
 
     # A helper class which bumps the version number stored in this file
     class Bumper
-      PARTS = %i[major minor patch]
-      PATTERN = %r[(\s+)MAJOR = \d+\s+MINOR = \d+\s+PATCH = \d+\s+BUILD = .+]
+      PARTS = %i[major minor patch].freeze
+      PATTERN = /(\s+)MAJOR = \d+\s+MINOR = \d+\s+PATCH = \d+\s+BUILD = .+/
 
-      #@param filename [String] the file to edit
-      #@param part [String] the part of the version to bump. one of major,
-      #  minor, or patch
-      def initialize(filename=__FILE__, part)
+      # @param part [String] the part of the version to bump. one of major,
+      #   minor, or patch
+      # @param filename [String] the file to edit
+      def initialize(part, filename = __FILE__)
         raise "#{part} not one of #{PARTS}" unless PARTS.include? part
-        @filename, @part = filename, part
+        @filename = filename
+        @part = part
       end
 
       # Increase the version number and write it to this file
@@ -33,42 +34,42 @@ module GtfsReader
         text = '\1' + ["MAJOR = #{parts[:major]}",
                        "MINOR = #{parts[:minor]}",
                        "PATCH = #{parts[:patch]}",
-                       "BUILD = #{parts[:build] || 'nil'}"].join( '\1' )
+                       "BUILD = #{parts[:build] || 'nil'}"].join('\1')
 
-        out_data = File.read( @filename ).gsub PATTERN, text
-        #puts out_data
-        File.open( @filename, 'w' ) { |out| out << out_data }
-        puts "Bumped version to #{to_s}"
+        out_data = File.read(@filename).gsub(PATTERN, text)
+        # puts out_data
+        File.open(@filename, 'w') { |out| out << out_data }
+        puts "Bumped version to #{self}"
       end
 
-      #@return [String] What the new version string will be.
+      # @return [String] What the new version string will be.
       def to_s
         p = new_version
-        [p[:major], p[:minor], p[:patch], p[:build]].compact.join ?.
+        [p[:major], p[:minor], p[:patch], p[:build]].compact.join('.')
       end
 
       private
 
       def new_version
-        @vers ||= { major: MAJOR,
-                    minor: MINOR,
-                    patch: PATCH,
-                    build: BUILD }.merge new_parts
+        @new_version ||= { major: MAJOR,
+                           minor: MINOR,
+                           patch: PATCH,
+                           build: BUILD }.merge(new_parts)
       end
 
       def new_parts
         case @part
         when :major then {
-            major: MAJOR + 1,
-            minor: 0,
-            patch: 0
+          major: MAJOR + 1,
+          minor: 0,
+          patch: 0
         }
         when :minor then {
-            minor: MINOR + 1,
-            patch: 0
+          minor: MINOR + 1,
+          patch: 0
         }
         else {
-            patch: PATCH + 1
+          patch: PATCH + 1
         }
         end
       end