flexyear 2.1.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 929b57a6f2f71b83adb9d436b5304e88802ccec1
-  data.tar.gz: d4936577ab3e36019669b9c9222fc8611a757cbd
+SHA256:
+  metadata.gz: 76222dec0e41ccbd4cfae4dd0d6ce3372790ae0ff9f1a0454b7003b663d03f1a
+  data.tar.gz: 9ae27ce940ba0e5b8e5258c7e4ccc2b405913b077b2193eef32ff7f5ca8f1702
 SHA512:
-  metadata.gz: f20398d5815ac685692558a248e2f1eab79735186d34b8ea7fc9668287a73b152e972fcbff1be08dd0b129a1deb870adb8a812b001ae0dda6553239d10c44443
-  data.tar.gz: 2e746c4ee7fbb2b48d84a022674da74e78e5690a175e64ef93becb052e1ebe694ae5c07e838ae9d8ccc6a25420faac887e043069afe413e58455f970af7caed5
+  metadata.gz: b375a2c188636a09b4598e0141649112d4845485b3c618061d86cdc16a099ccbf5aee9c5b51b84b5a9a5d8b58cffa52219b8cedd15fa8ea26aac8d610f051fb3
+  data.tar.gz: 1264dbafb0d737569bde093983260a23bb1d0f8468ad09ecf1d4d3b6a31a9c6eb437717cebe49e6810511052682023daede11376f28ee306b81e54aa989ed88a

data/README.md

@@ -7,15 +7,23 @@ Examples:
 ```ruby
 FlexYear.new("1980s").year_low == 1980
 FlexYear.new("1980s").year_high == 1989
+FlexYear.new("1980s").decade == 1980s
 
 FlexYear.new("mid-80s").year_low == 1983
 FlexYear.new("mid-80s").year_high == 1986
+FlexYear.new("mid-80s").decade == 1980s
 
 FlexYear.new(1983).year_low == 1983
 FlexYear.new(1983).year_high == 1983
+FlexYear.new(1983).decade == 1980s
+
+FlexYear.new(198*).year_low == 1980
+FlexYear.new(198*).year_high == 1989
+FlexYear.new(198*).decade == 1980s
 
 FlexYear.new(["1980s", "1988 - 2000", 2001]).year_low == 1980
 FlexYear.new(["1980s", "1988 - 2000", 2001]).year_high == 2001
+FlexYear.new(["1980s", "1988 - 2000", nil, 2001]).decades == [1980s, nil, nil, 2000s]
 ```
 
 It's pretty flexible in the kinds of things it takes. For more examples, see the spec.
@@ -48,3 +56,11 @@ Or install it yourself as:
 ### Test
 
 `rake`
+
+### Publish a new version
+
+We use bundlers rake commands to release versions. To cut and release a new version:
+
+1. Update lib/flexyear/version.rb and increment to your new desired version
+2. Commit and push your version bump
+3. Run `bundle exec rake release` to package and publish that version

data/lib/flexyear/version.rb

@@ -1,3 +1,3 @@
 class FlexYear
-  VERSION = "2.1.1"
+  VERSION = "2.4.0"
 end

data/lib/flexyear.rb

@@ -23,7 +23,7 @@ require 'date'
 class FlexYear
   class InvalidYearError < ArgumentError; end
 
-  attr_reader :year_low, :year_high
+  attr_reader :year_low, :year_high, :decade, :decades
 
   def initialize(year_input)
     @year_input = year_input
@@ -39,6 +39,26 @@ class FlexYear
     @year_input
   end
 
+  def decade?
+    return false unless year_low && year_high
+    year_low % 10 == 0 && year_high % 10 == 9
+  end
+
+  def parse_decade(yr_low, yr_high)
+    return if @year_input.is_a?(Array)
+    return unless yr_low && yr_high
+
+    same_decade = yr_low.to_s[0,3] == yr_high.to_s[0, 3]
+    @decade = "#{yr_low.to_s[0,3]}0s" if same_decade
+  end
+
+  def parse_decades(years)
+    return unless @year_input.is_a?(Array)
+
+    parsed_decades = years.flat_map { |y| self.class.new(y).decade }
+    @decades = parsed_decades
+  end
+
   private
 
   def parse_year_list(years)
@@ -47,14 +67,17 @@ class FlexYear
       [year.year_low, year.year_high]
     end
 
-    flat_years = all_years.compact.uniq
+    flat_years = all_years.uniq.map { |y| y.nil? ? Date.today.year : y }
 
     @year_low = flat_years.min
     @year_high = flat_years.max
+
+    parse_decades(years)
   end
 
   def parse_year_string(year_string)
     parse_year(year_string.to_s.strip)
+    parse_decade(@year_low, @year_high)
   end
 
   def centuryize(year, base_year=nil)
@@ -87,6 +110,9 @@ class FlexYear
     if year_string =~ range_regex && $1 && $2
       @year_low = centuryize($1).to_i
       @year_low, @year_high = [@year_low, centuryize($2, @year_low).to_i].sort
+    elsif year_string =~ open_ended_range_regex
+      @year_low = centuryize($1).to_i
+      @year_high = Date.today.year
     else
       if year_string =~ decade_regex
         @base_year = centuryize($1).to_i
@@ -111,6 +137,10 @@ class FlexYear
     /(\d+)\s*-\s*(\d+)/
   end
 
+  def open_ended_range_regex
+    /(\d+)\s*-\s*(\D+)/
+  end
+
   def asterisk_regex
     /(\d+).*\*$/
   end

data/spec/flexyear_spec.rb

@@ -12,72 +12,108 @@ describe FlexYear do
       subject { flexyear_class.new("") }
       its(:year_low) { should be_nil }
       its(:year_high) { should be_nil }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
     end
 
     context "given nil" do
       subject { flexyear_class.new(nil) }
       its(:year_low) { should be_nil }
       its(:year_high) { should be_nil }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
     end
 
     context "text" do
       subject { flexyear_class.new("something") }
       its(:year_low) { should be_nil }
       its(:year_high) { should be_nil }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
     end
 
     context "given 1979 as number" do
       subject { flexyear_class.new(1979) }
       its(:year_low) { should eq(1979) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context "given 1979" do
       subject { flexyear_class.new("1979") }
       its(:year_low) { should eq(1979) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context "given 1979 (with a space)" do
       subject { flexyear_class.new("1979 ") }
       its(:year_low) { should eq(1979) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context 'given 197*' do
       subject { flexyear_class.new('197*') }
       its(:year_low) { should eq(1970) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(true) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context "given 1970s" do
       subject { flexyear_class.new("1970s") }
       its(:year_low) { should eq(1970) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(true) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context "given 70s" do
       subject { flexyear_class.new("70s") }
       its(:year_low) { should eq(1970) }
       its(:year_high) { should eq(1979) }
+      its(:decade?) { should eq(true) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
     end
 
     context "given something with negative and dots" do
       subject { flexyear_class.new("approx.-2006") }
       its(:year_low) { should eq(2005) }
       its(:year_high) { should eq(2007) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should eq("2000s") }
+      its(:decades) { should be_nil }
     end
 
     context 'given before 1973' do
       subject { FlexYear.new('before 1973') }
       its(:year_low) { should be_nil }
       its(:year_high) { should eq(1973) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
     end
 
     context 'given after 1973' do
       subject { FlexYear.new('after 1973') }
       its(:year_low) { should eq(1973) }
       its(:year_high) { should be_nil }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
     end
 
     ["mid 1970s", "mid 70s", "mid-70s", "mid-70's"].each do |year|
@@ -85,7 +121,10 @@ describe FlexYear do
         subject { flexyear_class.new(year) }
         its(:year_low) { should eq(1973) }
         its(:year_high) { should eq(1976) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
         its(:to_s) { should eq(year) }
+        its(:decade?) { should eq(false) }
       end
     end
 
@@ -94,6 +133,9 @@ describe FlexYear do
         subject { flexyear_class.new(year) }
         its(:year_low) { should eq(1970) }
         its(:year_high) { should eq(1973) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
     end
 
@@ -102,6 +144,9 @@ describe FlexYear do
         subject { flexyear_class.new(year) }
         its(:year_low) { should eq(1976) }
         its(:year_high) { should eq(1979) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
     end
 
@@ -110,6 +155,9 @@ describe FlexYear do
         subject { flexyear_class.new(range) }
         its(:year_low) { should eq(1973) }
         its(:year_high) { should eq(1975) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
     end
 
@@ -117,6 +165,27 @@ describe FlexYear do
       subject { flexyear_class.new('1975-1973') }
       its(:year_low) { should eq(1973) }
       its(:year_high) { should eq(1975) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should eq("1970s") }
+      its(:decades) { should be_nil }
+    end
+
+    context "given a range from a year to present" do
+      subject { flexyear_class.new('1975-Present') }
+      its(:year_low) { should eq(1975) }
+      its(:year_high) { should eq(2016) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil }
+      its(:decades) { should be_nil }
+    end
+
+    context "given a range in difference decades" do
+      subject { flexyear_class.new('1975-1983') }
+      its(:year_low) { should eq(1975) }
+      its(:year_high) { should eq(1983) }
+      its(:decade?) { should eq(false) }
+      its(:decade) { should be_nil}
+      its(:decades) { should be_nil }
     end
 
     context "given a range" do
@@ -124,6 +193,9 @@ describe FlexYear do
         subject { flexyear_class.new(range) }
         its(:year_low) { should eq(2003) }
         its(:year_high) { should eq(2004) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("2000s") }
+        its(:decades) { should be_nil }
       end
     end
 
@@ -132,72 +204,108 @@ describe FlexYear do
         subject { flexyear_class.new('1973 (Circa)') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'at the beginning of the string' do
         subject { flexyear_class.new('Circa 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'abbreviated' do
         subject { flexyear_class.new('ca 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with dots' do
         subject { flexyear_class.new('c.a. 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with c.' do
         subject { flexyear_class.new('c. 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with ca.' do
         subject { flexyear_class.new('ca. 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with approx.' do
         subject { flexyear_class.new('approx. 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with appxly.' do
         subject { flexyear_class.new('appxly 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with around' do
         subject { flexyear_class.new('around 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with about' do
         subject { flexyear_class.new('about 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with circ' do
         subject { flexyear_class.new('circ. 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'with cca' do
         subject { flexyear_class.new('cca 1973') }
         its(:year_low) { should eq(1972) }
         its(:year_high) { should eq(1974) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should eq("1970s") }
+        its(:decades) { should be_nil }
       end
 
       context 'given 2 character fields' do
@@ -205,33 +313,57 @@ describe FlexYear do
           subject { flexyear_class.new("73") }
           its(:year_low) { should eq(1973) }
           its(:year_high) { should eq(1973) }
+          its(:decade?) { should eq(false) }
+          its(:decade) { should eq("1970s") }
+          its(:decades) { should be_nil }
         end
 
         context "from current century" do
           subject { flexyear_class.new("06") }
           its(:year_low) { should eq(2006) }
           its(:year_high) { should eq(2006) }
+          its(:decade?) { should eq(false) }
+          its(:decade) { should eq("2000s") }
+          its(:decades) { should be_nil }
         end
       end
     end
 
     context "given a list" do
       context "mixed years" do
-        subject { flexyear_class.new(["1980s", "mid-80s", "1988 - 1999", 2001,]) }
+        subject { flexyear_class.new(["1980s", "mid-80s", "1988 - 1999", 2001, "199*"]) }
         its(:year_low) { should eq(1980) }
         its(:year_high) { should eq(2001) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should be_nil }
+        its(:decades) { should eq(["1980s", "1980s", nil, "2000s", "1990s"])}
       end
 
       context "same years" do
         subject { flexyear_class.new(["1988", "1988"]) }
         its(:year_low) { should eq(1988) }
         its(:year_high) { should eq(1988) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should be_nil }
+        its(:decades) { should eq(["1980s", "1980s"])}
       end
 
       context "mixed years with nil" do
         subject { flexyear_class.new(["1988", "1990s", nil]) }
         its(:year_low) { should eq(1988) }
-        its(:year_high) { should eq(1999) }
+        its(:year_high) { should eq(2016) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should be_nil }
+        its(:decades) { should eq(["1980s", "1990s", nil])}
+      end
+
+      context "with a year with an undefined end date" do
+        subject { flexyear_class.new(["1980s", "mid-80s", "1988 - 1999", 2001, "199*", "1999 - Present"]) }
+        its(:year_low) { should eq(1980) }
+        its(:year_high) { should eq(2016) }
+        its(:decade?) { should eq(false) }
+        its(:decade) { should be_nil }
+        its(:decades) { should eq(["1980s", "1980s", nil, "2000s", "1990s", nil])}
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexyear
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Dan Melnick & Yan Pritzker
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-21 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,7 +100,7 @@ homepage: http://github.com/reverbdotcom/flexyear
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -115,9 +115,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Natural language year range parser
 test_files: