starscope 1.3.3 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fb073a356694d459d2c8f52e8dd1f7b81d22103
-  data.tar.gz: bddae56a6b270f28bd0135e355a09f5b14c16923
+  metadata.gz: 0034f945269abf5a562e9ac393621ef5ab6dfed0
+  data.tar.gz: 772a237027e861ea5a76c3e87a891fe9cc45b825
 SHA512:
-  metadata.gz: fbe36b2c5a96dc14475b41e29d7de9344b4ea1183369a75002ecbe1e8f7bac9e37ffe8f01a108527304426fde4281a3ab8d520b750e80c5dfdc6c969475e1b1f
-  data.tar.gz: 0a79e14ddd7de65dba9fe6246e8da1f6da1f2b5ff7f93e59f0ed4a5f9741e9d53d5c771a3b20e5870836bc7358dba6ad87e82cb9c1e2b4b55bf7b1a6c9fcc268
+  metadata.gz: 68a111fe637ba4a2e0307f04d5fec574bf3fca41ad9eee91cba1f1fe07cdaa36cc18ed953a29702a0dff4c4435cdb45b8b4a0ff06a1a39702aa8136bb9b04c27
+  data.tar.gz: fb56e7e538076c94866cd6d10b427919ed91ec50fba6f4d3692b30bbcd1e56eee004f4caba8eb64c832d8e490f67faaae3b9d3498fb951fbdb2613d662ff1327

data/.rubocop.yml

@@ -0,0 +1,29 @@
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -1,7 +1,21 @@
 Changelog
 =========
 
-v1.3.3 (trunk)
+v1.4.0 (trunk)
+--------------------
+
+New Features:
+ * Implement support for files with multiple nested languages (#61).
+ * Implement support for extracting ruby inside ERB files (#120).
+
+Bug Fixes:
+ * Correctly handle the removal of language extractors (#122).
+
+Misc:
+ * Preliminary use of Rubocop for more consistent code style.
+ * Document the fact that `!` can't be used at the beginning of table names.
+
+v1.3.3 (2015-03-07)
 --------------------
 
 Bug Fixes:

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    starscope (1.3.3)
+    starscope (1.4.0)
       backports (~> 3.6)
       oj (~> 2.9)
-      parser (~> 2.2.0.3)
+      parser (~> 2.2.2)
       ruby-progressbar (~> 1.5)
 
 GEM
@@ -15,18 +15,18 @@ GEM
     coderay (1.1.0)
     metaclass (0.0.4)
     method_source (0.8.2)
-    minitest (5.5.1)
+    minitest (5.7.0)
     mocha (1.1.0)
       metaclass (~> 0.0.1)
-    oj (2.11.4)
-    parser (2.2.0.3)
+    oj (2.12.9)
+    parser (2.2.2.5)
       ast (>= 1.1, < 3.0)
     pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
     rake (10.4.2)
-    ruby-progressbar (1.7.1)
+    ruby-progressbar (1.7.5)
     slop (3.6.0)
 
 PLATFORMS

data/README.md

@@ -3,6 +3,7 @@ Starscope
 
 [![Gem Version](https://badge.fury.io/rb/starscope.svg)](http://badge.fury.io/rb/starscope)
 [![Build Status](https://travis-ci.org/eapache/starscope.svg?branch=master)](https://travis-ci.org/eapache/starscope)
+[![Code of Conduct](https://img.shields.io/badge/code%20of%20conduct-active-blue.svg)](https://eapache.github.io/conduct.html)
 
 Anyone who has done much programming in C (or C++) on a Unix-based OS has come
 across the fantastic [Cscope](http://cscope.sourceforge.net/) tool. Sadly, it
@@ -46,5 +47,7 @@ More Documentation
 Other Uses
 ----------
 
-Starscope is a supported backend for
+- Starscope is a supported backend for
 [CodeQuery](https://github.com/ruben2020/codequery).
+- Starscope has been [packaged for Arch
+  Linux](https://aur.archlinux.org/packages/ruby-starscope/).

data/bin/starscope

@@ -7,14 +7,14 @@ require 'optparse'
 require 'readline'
 require 'starscope'
 
-DEFAULT_DB='.starscope.db'
-
-options = {:read => true,
-           :write => true,
-           :update => true,
-           :output => :normal,
-           :export => [],
-           :db => DEFAULT_DB,
+DEFAULT_DB = '.starscope.db'
+
+options = { :read => true,
+            :write => true,
+            :update => true,
+            :output => :normal,
+            :export => [],
+            :db => DEFAULT_DB
 }
 
 # Options Parsing
@@ -35,53 +35,53 @@ User Manual: https://github.com/eapache/starscope/blob/master/doc/USER_GUIDE.md
 END
 
   opts.separator "\nQueries"
-  opts.on("-d", "--dump [TABLE]", "Dumps the DB or specified table to stdout") do |tbl|
+  opts.on('-d', '--dump [TABLE]', 'Dumps the DB or specified table to stdout') do |tbl|
     options[:dump] = tbl || true
   end
-  opts.on("-l", "--line-mode", "Starts line-oriented interface") do
+  opts.on('-l', '--line-mode', 'Starts line-oriented interface') do
     options[:linemode] = true
   end
-  opts.on("-q", "--query TABLE,QUERY", "Looks up QUERY in TABLE") do |query|
+  opts.on('-q', '--query TABLE,QUERY', 'Looks up QUERY in TABLE') do |query|
     options[:query] = query
   end
-  opts.on("-s", "--summary", "Print a database summary to stdout") do
+  opts.on('-s', '--summary', 'Print a database summary to stdout') do
     options[:summary] = true
   end
 
   opts.separator "\nDatabase Management"
-  opts.on("-e", "--export FORMAT[,PATH]", "Export in FORMAT to PATH, (see EXPORTING)") do |export|
+  opts.on('-e', '--export FORMAT[,PATH]', 'Export in FORMAT to PATH, (see EXPORTING)') do |export|
     options[:export] << export
   end
-  opts.on("-f", "--file FILE", "Use FILE instead of `#{DEFAULT_DB}`") do |path|
+  opts.on('-f', '--file FILE', "Use FILE instead of `#{DEFAULT_DB}`") do |path|
     options[:db] = path
   end
-  opts.on("-x", "--exclude PATTERN", "Skip files matching PATTERN") do |pattern|
+  opts.on('-x', '--exclude PATTERN', 'Skip files matching PATTERN') do |pattern|
     options[:exclude] ||= []
     options[:exclude] << pattern
   end
-  opts.on("--no-read", "Don't read the DB from a file") do
+  opts.on('--no-read', "Don't read the DB from a file") do
     options[:read] = false
   end
-  opts.on("--no-write", "Don't write the DB to a file") do
+  opts.on('--no-write', "Don't write the DB to a file") do
     options[:write] = false
   end
-  opts.on("--no-update", "Don't update the DB") do
+  opts.on('--no-update', "Don't update the DB") do
     options[:update] = false
   end
 
   opts.separator "\nMisc"
-  opts.on("-v", "--version", "Print the version number") do
+  opts.on('-v', '--version', 'Print the version number') do
     puts Starscope::VERSION
     exit
   end
-  opts.on("--verbose", "Print extra status messages") do
+  opts.on('--verbose', 'Print extra status messages') do
     if options[:output] == :quiet
       $stderr.puts "Can't be both verbose and quiet"
       exit(1)
     end
     options[:output] = :verbose
   end
-  opts.on("--quiet", "Print fewer messages") do
+  opts.on('--quiet', 'Print fewer messages') do
     if options[:output] == :verbose
       $stderr.puts "Can't be both verbose and quiet"
       exit(1)
@@ -95,19 +95,18 @@ END
     you don't specify a path, the output is written to the file '#{Starscope::Exportable::CTAGS_DEFAULT_PATH}' (for
     ctags) or '#{Starscope::Exportable::CSCOPE_DEFAULT_PATH}' (for cscope) in the current directory.
 END
-
 end.parse!
 
 def print_summary(db)
   tables = db.tables
-  puts "No tables" if tables.empty?
-  tables.sort {|a,b| a.to_s <=> b.to_s}.each do |table|
+  puts 'No tables' if tables.empty?
+  tables.sort { |a, b| a.to_s <=> b.to_s }.each do |table|
     printf("%-9s %6d records\n", table, db.records(table).length)
   end
 end
 
 def format_record(db, rec)
-  "#{rec[:name].join " "} -- #{rec[:file]}:#{rec[:line_no]} (#{db.line_for_record(rec).strip})"
+  "#{rec[:name].join ' '} -- #{rec[:file]}:#{rec[:line_no]} (#{db.line_for_record(rec).strip})"
 end
 
 def run_query(db, query, separator)
@@ -130,15 +129,15 @@ def run_query(db, query, separator)
   match = match.join(separator)
 
   if match.empty?
-    $stderr.puts "Invalid input - no query found."
+    $stderr.puts 'Invalid input - no query found.'
     return false
   end
   tables = (table == '*' ? db.tables : table.to_sym)
   results = db.query(tables, match, filters)
   if !results || results.empty?
-    puts "No results found."
+    puts 'No results found.'
   else
-    results.sort_by {|x| x[:name].join(' ')}.each do |rec|
+    results.sort_by { |x| x[:name].join(' ') }.each do |rec|
       puts format_record(db, rec)
     end
   end
@@ -149,12 +148,12 @@ rescue Starscope::DB::NoTableError
 end
 
 def dump_table(db, table)
-  records = db.records(table).sort {|a,b|
+  records = db.records(table).sort do |a, b|
     a[:name][-1].to_s.downcase <=> b[:name][-1].to_s.downcase
-  }
+  end
 
   puts "== Table: #{table} =="
-  puts "No records" if records.empty?
+  puts 'No records' if records.empty?
 
   records.each do |record|
     puts format_record(db, record)
@@ -162,11 +161,10 @@ def dump_table(db, table)
 end
 
 def dump(db, table)
-
   case table
   when nil
-    db.tables.each {|t| dump_table(db, t)}
-  when "_meta"
+    db.tables.each { |t| dump_table(db, t) }
+  when '_meta'
     puts db.metadata
   when /^_/
     puts db.metadata(table[1..-1].to_sym)
@@ -190,7 +188,7 @@ end
 output = Starscope::Output.new(options[:output])
 db = Starscope::DB.new(output)
 
-db_exists = File.exists?(options[:db])
+db_exists = File.exist?(options[:db])
 
 if options[:read] && db_exists
   # we consider it 'new data' if the db was upconverted from an old format
@@ -216,7 +214,7 @@ elsif !(options[:read] && db_exists)
   new_data = true
 end
 
-updated = db.update() if options[:update]
+updated = db.update if options[:update]
 new_data ||= updated
 
 db.save(options[:db]) if options[:write] && (new_data || !db_exists)
@@ -253,29 +251,29 @@ end
 if options[:linemode]
   puts "Run your query as 'TABLE QUERY' or run '!help' for more information."
   begin
-    while input = Readline.readline("> ", true)
+    while input = Readline.readline('> ', true)
       next if input.empty?
       cmd, param = input.split(' ', 2)
       if cmd[0] == '!'
         case cmd[1..-1]
-        when "dump"
+        when 'dump'
           dump(db, param)
-        when "export"
+        when 'export'
           if param
             export(db, param)
           else
-            puts "!export requires an argument"
+            puts '!export requires an argument'
           end
-        when "summary"
+        when 'summary'
           print_summary(db)
-        when "update"
+        when 'update'
           changed = db.update
           db.save(options[:db]) if options[:write] && changed
-        when "help"
+        when 'help'
           puts linemode_help
-        when "version"
+        when 'version'
           puts Starscope::VERSION
-        when "quit"
+        when 'quit'
           exit
         else
           puts "Unknown command: '#{input}', try '!help'."

data/doc/LANGUAGE_SUPPORT.md

@@ -16,19 +16,19 @@ on anything language-specific, they just read the internal database record
 format.
 
 For this doc, we're going to pretend to add support for a language called
-"MyLanguage". Create a file called `mylanguage.rb` in `lib/starscope/langs/` and
-drop the following template in:
+"MyLanguage". Create a file called `my_language.rb` in `lib/starscope/langs/`
+and drop the following template in:
 
 ```ruby
 module Starscope::Lang
-  module Mylanguage
+  module MyLanguage
     VERSION = 1
 
     def self.match_file(name)
       name.end_with?(".mylang")
     end
 
-    def self.extract(file)
+    def self.extract(path, contents)
       # TODO
     end
   end
@@ -36,18 +36,19 @@ end
 ```
 
 This code is pretty simple: we define a module called
-`Starscope::Lang::Mylanguage` and give it one constant and two public module
+`Starscope::Lang::MyLanguage` and give it one constant and two public module
 methods:
  * `VERSION` is a constant integer defining the current version of the
    extractor. It should be incremented when the extractor has changed enough
    that any existing files should be re-parsed with the new version.
  * `match_file` takes the name of the file and returns a boolean if that file is
    written in MyLanguage or not. This can be as simple as checking the file
-   extension (which the sample code does) or looking for a shell #! line, or
+   extension (which the sample code does) or looking for a shell `#!` line, or
    anything you want.
- * `extract` takes a readable file handle pointing to the file, and must parse
-   the file, `yield`ing records as it finds function definitions and the like.
-   It may also return a final hash of file-wide metadata to store.
+ * `extract` takes the path to the file and a string containing the contents of
+   the file, and must parse the text, `yield`ing records as it finds function
+   definitions and the like. It may also return a final hash of file-wide
+   metadata to store.
 
 The record requirements are pretty straight-forward:
 ```ruby
@@ -67,7 +68,7 @@ belongs (basically its type). Current tables already include:
 Try to use pre-existing tables where possible, but feel free to add more if the
 language has some weird feature that doesn't map to any of the above. You don't
 have to do anything special to create a new table, just yield the appropriate
-symbol.
+symbol. Table names cannot begin with exclamation points (`!`).
 
 The second yielded argument is the name (string or symbol) of the token that
 you want to add: the name of the function being called, or the name of the class
@@ -85,3 +86,19 @@ And that's it! Parse your files, yield your records, and the Starscope engine
 takes care of everything else for you. If you've added support for a language
 that you think others might find useful, please contribute it (with tests!) via
 pull request.
+
+Sublanguages and Fragments
+--------------------------
+
+Some languages (such as ERB and Markdown) include support for nesting chunks of
+other languages inside. If your extractor comes across a fragment of another
+language while it is parsing, it can pass that off to the correct sub-extractor
+by yielding to the special `FRAGMENT` table, with the name of the language as
+the name, and a `frag` argument containing the actual raw text. For example:
+
+```ruby
+yield FRAGMENT, :Ruby, :frag => my_extracted_ruby_code, :line_no => line_no
+```
+
+Fragments will be accumulated by the database and passed to the appropriate
+extractor when the current file has been completely parsed.

data/lib/starscope.rb

@@ -1,2 +1,2 @@
-require "starscope/version"
-require "starscope/db"
+require 'starscope/version'
+require 'starscope/db'

data/lib/starscope/db.rb

@@ -5,6 +5,7 @@ require 'set'
 require 'zlib'
 
 require 'starscope/exportable'
+require 'starscope/fragment_extractor'
 require 'starscope/queryable'
 require 'starscope/output'
 
@@ -19,8 +20,9 @@ Starscope::Lang.constants.each do |lang|
   LANGS[lang.to_sym] = extractor.const_get(:VERSION)
 end
 
-class Starscope::DB
+FRAGMENT = :'!fragment'
 
+class Starscope::DB
   include Starscope::Exportable
   include Starscope::Queryable
 
@@ -31,8 +33,8 @@ class Starscope::DB
 
   def initialize(output)
     @output = output
-    @meta = {:paths => [], :files => {}, :excludes => [],
-             :langs => LANGS, :version => Starscope::VERSION}
+    @meta = { :paths => [], :files => {}, :excludes => [],
+              :langs => LANGS, :version => Starscope::VERSION }
     @tables = {}
   end
 
@@ -63,43 +65,43 @@ class Starscope::DB
 
   def add_excludes(paths)
     @output.extra("Excluding files in paths #{paths}...")
-    @meta[:paths] -= paths.map {|p| self.class.normalize_glob(p)}
-    paths = paths.map {|p| self.class.normalize_fnmatch(p)}
+    @meta[:paths] -= paths.map { |p| self.class.normalize_glob(p) }
+    paths = paths.map { |p| self.class.normalize_fnmatch(p) }
     @meta[:excludes] += paths
     @meta[:excludes].uniq!
 
-    excluded = @meta[:files].keys.select {|name| matches_exclude?(name, paths)}
+    excluded = @meta[:files].keys.select { |name| matches_exclude?(name, paths) }
     remove_files(excluded)
   end
 
   def add_paths(paths)
     @output.extra("Adding files in paths #{paths}...")
-    @meta[:excludes] -= paths.map {|p| self.class.normalize_fnmatch(p)}
-    paths = paths.map {|p| self.class.normalize_glob(p)}
+    @meta[:excludes] -= paths.map { |p| self.class.normalize_fnmatch(p) }
+    paths = paths.map { |p| self.class.normalize_glob(p) }
     @meta[:paths] += paths
     @meta[:paths].uniq!
-    files = Dir.glob(paths).select {|f| File.file? f}
-    files.delete_if {|f| matches_exclude?(f)}
+    files = Dir.glob(paths).select { |f| File.file? f }
+    files.delete_if { |f| matches_exclude?(f) }
     return if files.empty?
-    @output.new_pbar("Building", files.length)
+    @output.new_pbar('Building', files.length)
     add_files(files)
     @output.finish_pbar
   end
 
   def update
-    changes = @meta[:files].keys.group_by {|name| file_changed(name)}
+    changes = @meta[:files].keys.group_by { |name| file_changed(name) }
     changes[:modified] ||= []
     changes[:deleted] ||= []
 
-    new_files = (Dir.glob(@meta[:paths]).select {|f| File.file? f}) - @meta[:files].keys
-    new_files.delete_if {|f| matches_exclude?(f)}
+    new_files = (Dir.glob(@meta[:paths]).select { |f| File.file? f }) - @meta[:files].keys
+    new_files.delete_if { |f| matches_exclude?(f) }
 
     if changes[:deleted].empty? && changes[:modified].empty? && new_files.empty?
-      @output.normal("No changes detected.")
+      @output.normal('No changes detected.')
       return false
     end
 
-    @output.new_pbar("Updating", changes[:modified].length + new_files.length)
+    @output.new_pbar('Updating', changes[:modified].length + new_files.length)
     remove_files(changes[:deleted])
     update_files(changes[:modified])
     add_files(new_files)
@@ -113,7 +115,7 @@ class Starscope::DB
 
     file = @meta[:files][rec[:file]]
 
-    return file[:lines][rec[:line_no]-1] if file[:lines]
+    return file[:lines][rec[:line_no] - 1] if file[:lines]
   end
 
   def tables
@@ -121,15 +123,15 @@ class Starscope::DB
   end
 
   def records(table)
-    raise NoTableError if not @tables[table]
+    fail NoTableError unless @tables[table]
 
     @tables[table]
   end
 
-  def metadata(key=nil)
+  def metadata(key = nil)
     return @meta.keys if key.nil?
 
-    raise NoTableError unless @meta[key]
+    fail NoTableError unless @meta[key]
 
     @meta[key]
   end
@@ -163,10 +165,10 @@ class Starscope::DB
     when 0..2
       # Old format (pre-json), so read the directories segment then rebuild
       len = stream.gets.to_i
-      add_paths(Marshal::load(stream.read(len)))
+      add_paths(Marshal.load(stream.read(len)))
       return false
     else
-      raise UnknownDBFormatError
+      fail UnknownDBFormatError
     end
   rescue Oj::ParseError
     stream.rewind
@@ -174,7 +176,7 @@ class Starscope::DB
     # try reading as formated json, which is much slower, but it is sometimes
     # useful to be able to directly read your db
     objects = []
-    Oj.load(stream) {|obj| objects << obj}
+    Oj.load(stream) { |obj| objects << obj }
     @meta, @tables = objects
     return true
   end
@@ -186,10 +188,10 @@ class Starscope::DB
 
   # File.fnmatch treats a "**" to match files and directories recursively
   def self.normalize_fnmatch(path)
-    if path == "."
-      "**"
+    if path == '.'
+      '**'
     elsif File.directory?(path)
-      File.join(path, "**")
+      File.join(path, '**')
     else
       path
     end
@@ -198,17 +200,17 @@ class Starscope::DB
   # Dir.glob treats a "**" to only match directories recursively; you need
   # "**/*" to match all files recursively
   def self.normalize_glob(path)
-    if path == "."
-      File.join("**", "*")
+    if path == '.'
+      File.join('**', '*')
     elsif File.directory?(path)
-      File.join(path, "**", "*")
+      File.join(path, '**', '*')
     else
       path
     end
   end
 
   def matches_exclude?(file, patterns = @meta[:excludes])
-    patterns.map {|p| File.fnmatch(p, file)}.any?
+    patterns.map { |p| File.fnmatch(p, file) }.any?
   end
 
   def add_files(files)
@@ -226,7 +228,7 @@ class Starscope::DB
     end
     files = files.to_set
     @tables.each do |name, tbl|
-      tbl.delete_if {|val| files.include?(val[:file])}
+      tbl.delete_if { |val| files.include?(val[:file]) }
     end
   end
 
@@ -236,7 +238,7 @@ class Starscope::DB
   end
 
   def parse_file(file)
-    @meta[:files][file] = {:last_updated => File.mtime(file).to_i}
+    @meta[:files][file] = { :last_updated => File.mtime(file).to_i }
 
     EXTRACTORS.each do |extractor|
       begin
@@ -246,27 +248,40 @@ class Starscope::DB
         next
       end
 
-      extract_file(extractor, file)
+      line_cache = File.readlines(file)
+      lines = Array.new(line_cache.length)
+      @meta[:files][file][:sublangs] = []
+      extract_file(extractor, file, line_cache, lines)
 
-      return
+      break
     end
   end
 
-  def extract_file(extractor, file)
-    lines = nil
-    line_cache = nil
-
-    extractor_metadata = extractor.extract(file) do |tbl, name, args|
-      @tables[tbl] ||= []
-      @tables[tbl] << self.class.normalize_record(file, name, args)
-
-      if args[:line_no]
-        line_cache ||= File.readlines(file)
-        lines ||= Array.new(line_cache.length)
-        lines[args[:line_no]-1] = line_cache[args[:line_no]-1].chomp
+  def extract_file(extractor, file, line_cache, lines)
+    fragment_cache = {}
+
+    extractor_metadata = extractor.extract(file, File.read(file)) do |tbl, name, args|
+      case tbl
+      when FRAGMENT
+        fragment_cache[name] ||= []
+        fragment_cache[name] << args
+      else
+        @tables[tbl] ||= []
+        @tables[tbl] << self.class.normalize_record(file, name, args)
+
+        if args[:line_no]
+          line_cache ||= File.readlines(file)
+          lines ||= Array.new(line_cache.length)
+          lines[args[:line_no] - 1] = line_cache[args[:line_no] - 1].chomp
+        end
       end
     end
 
+    fragment_cache.each do |lang, frags|
+      extract_file(Starscope::FragmentExtractor.new(lang, frags), file, line_cache, lines)
+      @meta[:files][file][:sublangs] << lang
+    end
+
     @meta[:files][file][:lang] = extractor.name.split('::').last.to_sym
     @meta[:files][file][:lines] = lines
 
@@ -280,26 +295,32 @@ class Starscope::DB
 
   def file_changed(name)
     file_meta = @meta[:files][name]
-    if !File.exists?(name) || !File.file?(name)
+    if !File.exist?(name) || !File.file?(name)
       :deleted
     elsif (file_meta[:last_updated] < File.mtime(name).to_i) ||
-          (file_meta[:lang] && (@meta[:langs][file_meta[:lang]] || 0) < LANGS[file_meta[:lang]])
+          language_out_of_date(file_meta[:lang]) ||
+          (file_meta[:sublangs] || []).any? { |lang| language_out_of_date(lang) }
       :modified
     else
       :unchanged
     end
   end
 
+  def language_out_of_date(lang)
+    return false unless lang
+    return true unless LANGS[lang]
+    (@meta[:langs][lang] || 0) < LANGS[lang]
+  end
+
   def self.normalize_record(file, name, args)
     args[:file] = file
 
     if name.is_a? Array
-      args[:name] = name.map {|x| x.to_sym}
+      args[:name] = name.map(&:to_sym)
     else
       args[:name] = [name.to_sym]
     end
 
     args
   end
-
 end