parsi-date 0.3.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a3d3208eb15dffe3337029d416689f316b35ada0
-  data.tar.gz: 345fe584383351f93dedbe88dec53d69ab4da941
+SHA256:
+  metadata.gz: 3ba469a494b1e1aae0d7c2c7f588da147cc467248ddbe734f435e3fab64d4171
+  data.tar.gz: 56e054bb3539f9e52ceb0ed6f766d9b058ee2a0457b61ba78593e5ce12232193
 SHA512:
-  metadata.gz: 6e30ea83c086ea01d854ce30dcb756007d298ebedf2531abbf05db90c1db55f0087ca28b59887483c5f7f64fe34307c7c54dfbc5b2e0d4f6018ff08284e98f17
-  data.tar.gz: b5452ff1d01c2983317da602d660c1c435c4789aaf7e36e2c9c2c8ae0e865ae228d092b4ac595e8a403a394d34c5ff0c43819f2e7a56a275771dcceceb441e30
+  metadata.gz: 2584be47bf36f9946259cf0e8d8954c4ab9132ae05986509f70655fc57900f9e5bbb43eefc0186a93992a0a1990c9fb99b8f06639558f78f3e88c9ed1330bbc9
+  data.tar.gz: dc6fc42431960c45147036b6dc86ae3097ac9dbfb27e5d96be312d5048c71f3d6b3ebd26c41501d1f028bb56075b853e2646adb638338716fc3f9aa35aabc6bf

data/.github/workflows/ruby.yml

@@ -0,0 +1,26 @@
+name: Ruby
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+          - '3.1'
+          - '3.2'
+          - '3.3'
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rspec spec

data/README.md

@@ -0,0 +1,94 @@
+# Parsi Date
+
+The Parsi Date library is an implementation of the [Solar Hijri Calendar](http://en.wikipedia.org/wiki/Solar_Hijri_calendar), also known as the Jalali or Persian Calendar, which is the official calendar of Iran. This library aims to create a Solar Hijri date library that closely resembles Ruby's built-in date library, providing a seamless experience for users who need to work with the Solar Hijri dates. The conversion algorithm used in this library is inspired by FarsiWeb.
+
+## Features
+
+- **Parsi::Date** and **Parsi::DateTime**: These objects can be used just like Ruby's `Date` and `DateTime` objects.
+- **Date Conversion:** Easily convert between Gregorian and Solar Hijri dates.
+- **Leap Year Calculation:** Determine if a given Solar Hijri year is a leap year.
+- **Date Parsing and Formatting:** Parse Solar Hijri date strings and format dates in various styles.
+
+## Usage
+
+### Basic Operations
+
+You can use `Parsi::Date` and `Parsi::DateTime` objects in the same way you use `Date` and `DateTime` objects in Ruby. Here are some examples:
+
+```ruby
+# Get today's Solar Hijri date
+a = Parsi::Date.today
+# => #<Parsi::Date: 1391-08-09 (4912461/2,0/1)>
+
+# Add 12 months to it
+b = a >> 12
+# => #<Parsi::Date: 1392-08-09 (4913193/2,0/1)>
+
+# Count the number of Sundays between two dates
+a.upto(b).select{ |d| d.sunday? }.count
+# => 52
+
+# Check if a given year is a leap year
+Parsi::Date.leap?(1391)
+# => true
+```
+
+### Parsing and Formatting Dates
+
+You can parse Solar Hijri date strings and format them in various styles:
+
+```ruby
+# Parse a Solar Hijri date string
+c = Parsi::Date.parse("1391/10/12")
+# => #<Parsi::Date: 1391-10-12 (4912587/2,0)>
+
+# Format the date in Persian
+c.strftime("%A %d %B %Y")
+# => "سه‌شنبه 12 دی 1391"
+
+# Format the date in English
+c.strftime("%^EA %d %^EB %Y")
+# => "Seshambe 12 Day 1391"
+```
+
+### Converting Between Calendars
+
+You can easily convert between Gregorian and Solar Hijri dates:
+
+```ruby
+# Convert a Gregorian date to Solar Hijri
+d = Date.civil(2012, 10, 30).to_parsi
+# => #<Parsi::Date: 1391-08-09 (4912461/2,0/1)>
+
+# Convert a Solar Hijri date back to Gregorian
+d.to_gregorian
+# => #<Date: 2012-10-30 ((2456231j,0s,0n),+0s,2299161j)>
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parsi-date'
+```
+
+And then execute:
+
+```sh
+bundle install
+```
+
+Or install it yourself as:
+
+```sh
+gem install parsi-date
+```
+
+## License
+
+The Parsi Date library is open-source software licensed under the MIT license.
+
+## Contributing
+
+If you would like to contribute to the development of the Parsi Date library, please feel free to fork the repository and submit pull requests. Contributions, bug reports, and feature requests are welcome and appreciated.

data/lib/parsi-date.rb

@@ -135,61 +135,68 @@ module Parsi
     JALALI_EPOCH_IN_AJD    = Rational(3896641, 2) # :nodoc:
     MJD_EPOCH_IN_AJD       = Rational(4800001, 2) # 1858-11-17 # :nodoc:
     UNIX_EPOCH_IN_AJD      = Rational(4881175, 2) # 1970-01-01 # :nodoc:
-    JALALI_EPOCH_IN_CJD    = 1948321 # :nodoc:
+    JALALI_EPOCH_IN_CJD    = 1948320 # :nodoc:
     MJD_EPOCH_IN_CJD       = 2400001 # :nodoc:
     UNIX_EPOCH_IN_CJD      = 2440588 # :nodoc:
     LD_EPOCH_IN_CJD        = 2299160 # :nodoc:
-    DAYS_IN_MONTH          = [nil, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29] # :nodoc:
+    DAYS_IN_MONTH          = [0, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29] # :nodoc:
+
+    LEAP_REMINDERS         = [1, 5, 9, 13, 17, 22, 26, 30].freeze
 
     shared_methods = Module.new do
 
       # Returns true if the given year is a leap year of the calendar.
       def leap? year
-        ((((((year - ((year > 0) ? 474 : 473)) % 2820) + 474) + 38) * 682) % 2816) < 682
+        LEAP_REMINDERS.include?(year - (year / 33).floor * 33)
       end
       alias_method :jalali_leap?, :leap?
 
       private
 
-      DAYS_TO_FIRST_OF_MONTH = [nil, 0, 31, 62, 93, 124, 155, 186, 216, 246, 276, 306, 336] # :nodoc:
-
       # Convert a Civil Date to a Julian Day Number and returns the corresponding Julian Day Number.
-      def civil_to_jd year, month, day # :nodoc:
-        epbase = year - 474
-        epyear = 474 + (epbase % 2820)
-
-        day + DAYS_TO_FIRST_OF_MONTH[month] +
-          (epyear * 682 - 110) / 2816 +
-          (epyear - 1) * 365 +
-          (epbase / 2820 * 1029983) +
-          (JALALI_EPOCH_IN_CJD - 1)
+      def civil_to_jd(year, month, day) # :nodoc:
+        year -= 1
+        month -= 1
+        day -= 1
+
+        jd = 365*year + (year/33)*8 + (year%33+3)/4;
+        while month > 0
+          jd += DAYS_IN_MONTH[month]
+          month -= 1
+        end
+
+        jd + day + JALALI_EPOCH_IN_CJD
       end
 
       # Convert a Julian Day Number to a Civil Date. +jday+ is the Julian Day Number.
       #
       # Returns the corresponding [year, month, day_of_month] as a three-element array.
-      def jd_to_civil jday
-        depoch = (jday - first_day_of_year(475))
-        cycle, cyear = depoch.divmod 1029983
+      def jd_to_civil jd
+        jd -= JALALI_EPOCH_IN_CJD
 
-        if cyear == 1029982
-          ycycle = 2820
-        else
-          aux1, aux2 = cyear.divmod 366
-          ycycle = (2134 * aux1 + 2816 * aux2 + 2815) / 1028522 + aux1 + 1
+        n, jd = jd.divmod 12053
+        m, jd = jd.divmod 1461
+        year = 33*n + 4*m + 1
+
+        if jd >= 366
+          n, jd = (jd - 1).divmod 365
+          year += n
+        end
+
+        month = 1
+        while month < 12 && jd >= DAYS_IN_MONTH[month]
+          jd -= DAYS_IN_MONTH[month]
+          month += 1
         end
-        year  = ycycle + 2820 * cycle + 474
-        yday  = jday - first_day_of_year(year) + 1
-        month = ((yday <= 186) ? yday / 31.0 : (yday - 6) / 30.0).ceil
-        day   = (jday - first_day_of_month(year, month) + 1)
-        [year, month, day]
+
+        [year, month, jd + 1]
       end
 
       # Do +year+, +month+, and day-of-month +day+ make a valid Civil Date?
       # Returns the corresponding Julian Day Number if they do, nil if they don't.
       # Invalid values cause an ArgumentError to be raised.
       def _valid_civil? year, month, day # :nodoc:
-        return unless year.is_a?(Fixnum) && month.is_a?(Fixnum) && day.is_a?(Fixnum)
+        return unless year.is_a?(Integer) && month.is_a?(Integer) && day.is_a?(Integer)
         return civil_to_jd(year, 12, 30) if leap?(year) && month == 12 && day == 30
 
         if 1 <= month && month <= 12 && 1 <= day && day <= DAYS_IN_MONTH[month]
@@ -330,7 +337,6 @@ module Parsi
       #   Parsi::Date.jd             # => #<Parsi::Date: -5335-09-01>
       #
       def jd jday=0
-        jd = _valid_jd? jday
         new! jd_to_ajd(jday, 0, 0), 0
       end
 
@@ -731,7 +737,7 @@ module Parsi
     def marshal_dump() [@ajd, @offset] end
 
     # Load from Marshal format.
-    def marshal_load(a) @ajd, @of, = a end
+    def marshal_load(a) @ajd, @offset, = a end
   end
 end
 
@@ -747,8 +753,9 @@ class Date
 
   # Returns a Parsi::Date object representing same date in Jalali calendar
   def to_parsi
-    Parsi::Date.new! ajd, offset
+    Parsi::Date.new! ajd
   end
+
   alias :jalali     :to_parsi
   alias :to_jalali  :to_parsi
   alias :to_persian :to_parsi

data/lib/version.rb

@@ -1,5 +1,5 @@
 module Parsi
   class Date
-    VERSION = "0.3.1"
+    VERSION = "0.5.1"
   end
 end

data/parsi-date.gemspec

@@ -18,9 +18,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
-  s.add_development_dependency("bundler", "~> 1.4")
-  s.add_development_dependency("rake", "~> 10.0")
-  s.add_development_dependency("rspec", "~> 2.0")
-  s.add_development_dependency("activerecord", "~> 4.2")
-  s.add_development_dependency("sqlite3", "~> 1.3")
+  s.add_development_dependency("bundler", "~> 2.0")
+  s.add_development_dependency("json", "~> 2.0")
+  s.add_development_dependency("rake", "~> 13.0")
+  s.add_development_dependency("rspec", "~> 3.0")
+  s.add_development_dependency("activerecord", "~> 6.0")
+  s.add_development_dependency("sqlite3", "~> 1.5")
 end

data/spec/parsi-date/accessor_spec.rb

@@ -1,57 +1,66 @@
 describe "Parsi::Date#ajd" do
   it "determines the Astronomical Julian day" do
-    Parsi::Date.civil(1391, 8, 6).ajd.should == Rational(4912455, 2)
+    expect(Parsi::Date.civil(1391, 8, 6).ajd).to be == Rational(4912455, 2)
+    expect(Parsi::Date.civil(1403, 12, 30).ajd).to be == Rational(4921509, 2)
   end
 end
 
 describe "Parsi::Date#amjd" do
   it "determines the Astronomical Modified Julian day" do
-    Parsi::Date.civil(1391, 8, 6).amjd.should == 56227
+    expect(Parsi::Date.civil(1391, 8, 6).amjd).to be == 56227
+    expect(Parsi::Date.civil(1403, 12, 30).amjd).to be == 60754
   end
 end
 
 describe "Parsi::Date#mjd" do
   it "determines the Modified Julian day" do
-    Parsi::Date.civil(1391, 8, 6).mjd.should == 56227
+    expect(Parsi::Date.civil(1391, 8, 6).mjd).to be == 56227
+    expect(Parsi::Date.civil(1403, 12, 30).mjd).to be == 60754
   end
 end
 
 describe "Parsi::Date#ld" do
-  it "determines the Modified Julian day" do
-    Parsi::Date.civil(1391, 8, 6).ld.should == 157068
+  it "determines the number of days since the Day of Calendar Reform" do
+    expect(Parsi::Date.civil(1391, 8, 6).ld).to be == 157068
+    expect(Parsi::Date.civil(1403, 12, 30).ld).to be == 161595
   end
 end
 
 describe "Parsi::Date#year" do
   it "determines the year" do
-    Parsi::Date.civil(1391, 8, 6).year.should == 1391
+    expect(Parsi::Date.civil(1391, 8, 6).year).to be == 1391
+    expect(Parsi::Date.civil(1403, 12, 30).year).to be == 1403
   end
 end
 
 describe "Parsi::Date#yday" do
   it "determines the year" do
-    Parsi::Date.civil(1391, 1, 17).yday.should == 17
-    Parsi::Date.civil(1391, 8, 6).yday.should == 222
+    expect(Parsi::Date.civil(1391, 1, 17).yday).to be == 17
+    expect(Parsi::Date.civil(1391, 8, 6).yday).to be == 222
+    expect(Parsi::Date.civil(1403, 12, 30).yday).to be == 366
   end
 end
 
 describe "Parsi::Date#mon" do
   it "determines the month" do
-    Parsi::Date.civil(1391, 1, 17).mon.should == 1
-    Parsi::Date.civil(1391, 8, 6).mon.should == 8
+    expect(Parsi::Date.civil(1391, 1, 17).mon).to be == 1
+    expect(Parsi::Date.civil(1391, 8, 6).mon).to be == 8
+    expect(Parsi::Date.civil(1403, 12, 30).mon).to be == 12
   end
 end
 
 describe "Parsi::Date#mday" do
   it "determines the day of the month" do
-    Parsi::Date.civil(1391, 1, 17).mday.should == 17
-    Parsi::Date.civil(1391, 10, 28).mday.should == 28
+    expect(Parsi::Date.civil(1391, 1, 17).mday).to be == 17
+    expect(Parsi::Date.civil(1391, 10, 28).mday).to be == 28
+    expect(Parsi::Date.civil(1403, 12, 30).mday).to be == 30
   end
 end
 
 describe "Parsi::Date#wday" do
   it "determines the week day" do
-    Parsi::Date.civil(1391, 1, 17).wday.should == 4
-    Parsi::Date.civil(1391, 8, 6).wday.should == 6
+    expect(Parsi::Date.civil(1391, 1, 17).wday).to be == 4
+    expect(Parsi::Date.civil(1391, 8, 6).wday).to be == 6
+    expect(Parsi::Date.civil(1403, 12, 30).wday).to be == 4
   end
 end

data/spec/parsi-date/accessors_helper_spec.rb

@@ -1,5 +1,6 @@
 require 'active_record'
 require 'sqlite3'
+require 'json'
 
 ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 
@@ -24,7 +25,7 @@ end
 describe "Record extended with Parsi::Date::Accessors" do
   it "has parsi postfixed accessor for giver attributes" do
     record = Record.new
-    %i(created_at_parsi created_at_parsi= updated_at_parsi updated_at_parsi).each do |name|
+    [:created_at_parsi, :created_at_parsi=, :updated_at_parsi, :updated_at_parsi].each do |name|
       expect(record.respond_to?(name)).to be_truthy
     end
   end
@@ -55,7 +56,7 @@ describe "Record extended with Parsi::Date::Accessors" do
 
       it "raises error when string is not a date" do
         record = Record.new
-        expect {record.created_at_parsi = "1393-13-11" }.to raise_error
+        expect {record.created_at_parsi = "1393-13-11" }.to raise_error(ArgumentError, 'invalid date')
       end
     end
   end

data/spec/parsi-date/add_month_spec.rb

@@ -1,27 +1,27 @@
 describe "Parsi::Date#>>" do
   it "adds the number of months to a Parsi::Date" do
-    d = Parsi::Date.civil(1391, 2, 27) >> 10
-    d.should == Parsi::Date.civil(1391, 12, 27)
+    expect(Parsi::Date.civil(1391, 2, 27) >> 10).to be == Parsi::Date.civil(1391, 12, 27)
+    expect(Parsi::Date.civil(1403, 11, 30) >> 1).to be == Parsi::Date.civil(1403, 12, 30)
   end
 
   it "sets the day to the last day of a month if the day doesn't exist" do
-    d = Parsi::Date.civil(1391, 6, 31) >> 1
-    d.should == Parsi::Date.civil(1391, 7, 30)
+    expect(Parsi::Date.civil(1391, 6, 31) >> 1).to be == Parsi::Date.civil(1391, 7, 30)
+    expect(Parsi::Date.civil(1402, 11, 30) >> 1).to be == Parsi::Date.civil(1402, 12, 29)
   end
 
   it "raise a TypeError when passed a Symbol" do
-    lambda { Parsi::Date.civil(1391, 2, 27) >> :hello }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) >> :hello }.to raise_error(TypeError)
   end
 
   it "raise a TypeError when passed a String" do
-    lambda { Parsi::Date.civil(1391, 2, 27) >> "hello" }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) >> "hello" }.to raise_error(TypeError)
   end
 
   it "raise a TypeError when passed a Parsi::Date" do
-    lambda { Parsi::Date.civil(1391, 2, 27) >> Parsi::Date.new }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) >> Parsi::Date.new }.to raise_error(TypeError)
   end
 
   it "raise a TypeError when passed an Object" do
-    lambda { Parsi::Date.civil(1391, 2, 27) >> Object.new }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) >> Object.new }.to raise_error(TypeError)
   end
 end

data/spec/parsi-date/add_spec.rb

@@ -1,27 +1,27 @@
 describe "Parsi::Date#+" do
   it "adds the number of days to a Parsi::Date" do
-    d = Parsi::Date.civil(1391, 2, 27) + 10
-    d.should == Parsi::Date.civil(1391, 3, 6)
+    expect(Parsi::Date.civil(1391, 2, 27) + 10).to be == Parsi::Date.civil(1391, 3, 6)
+    expect(Parsi::Date.civil(1403, 12, 29) + 1).to be == Parsi::Date.civil(1403, 12, 30)
+    expect(Parsi::Date.civil(1403, 12, 30) + 1).to be == Parsi::Date.civil(1404, 1, 1)
   end
 
   it "adds a negative number of days to a Parsi::Date" do
-    d = Parsi::Date.civil(1391, 2, 27) + (-10)
-    d.should == Parsi::Date.civil(1391, 2, 17)
+    expect(Parsi::Date.civil(1391, 2, 27) + (-10)).to be == Parsi::Date.civil(1391, 2, 17)
   end
 
   it "raises a TypeError when passed a Symbol" do
-    lambda { Parsi::Date.civil(1391, 2, 27) + :hello }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) + :hello }.to raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a String" do
-    lambda { Parsi::Date.civil(1391, 2, 27) + "hello" }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) + "hello" }.to raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a Parsi::Date" do
-    lambda { Parsi::Date.civil(1391, 2, 27) + Parsi::Date.new }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) + Parsi::Date.new }.to raise_error(TypeError)
   end
 
   it "raises a TypeError when passed an Object" do
-    lambda { Parsi::Date.civil(1391, 2, 27) + Object.new }.should raise_error(TypeError)
+    expect { Parsi::Date.civil(1391, 2, 27) + Object.new }.to raise_error(TypeError)
   end
 end

data/spec/parsi-date/comp_spec.rb

@@ -2,29 +2,29 @@ require 'date'
 
 describe "Parsi::Date#<=>" do
   it "returns 0 when two dates are equal" do
-    (Parsi::Date.civil(1391, 4, 6) <=> Parsi::Date.civil(1391, 4, 6)).should == 0
-    (Parsi::Date.civil(1391, 4, 6) <=> Date.civil(2012, 6, 26)).should == 0
+    expect(Parsi::Date.civil(1391, 4, 6) <=> Parsi::Date.civil(1391, 4, 6)).to be == 0
+    expect(Parsi::Date.civil(1391, 4, 6) <=> Date.civil(2012, 6, 26)).to be == 0
   end
 
   it "returns -1 when self is less than another date" do
-    (Parsi::Date.civil(1391, 4, 5) <=> Parsi::Date.civil(1391, 4, 6)).should == -1
-    (Parsi::Date.civil(1391, 4, 5) <=> Date.civil(2012, 6, 26)).should == -1
+    expect(Parsi::Date.civil(1391, 4, 5) <=> Parsi::Date.civil(1391, 4, 6)).to be == -1
+    expect(Parsi::Date.civil(1391, 4, 5) <=> Date.civil(2012, 6, 26)).to be == -1
   end
 
   it "returns 1 when self is greater than another date" do
-    (Parsi::Date.civil(1392, 4, 7) <=> Parsi::Date.civil(1391, 4, 6)).should == 1
-    (Parsi::Date.civil(1391, 4, 7) <=> Date.civil(2012, 6, 26)).should == 1
+    expect(Parsi::Date.civil(1392, 4, 7) <=> Parsi::Date.civil(1391, 4, 6)).to be == 1
+    expect(Parsi::Date.civil(1391, 4, 7) <=> Date.civil(2012, 6, 26)).to be == 1
   end
 
   it "returns 0 when self is equal to a Numeric" do
-    (Parsi::Date.civil(1391, 4, 6) <=> Rational(4912209,2)).should == 0
+    expect(Parsi::Date.civil(1391, 4, 6) <=> Rational(4912209,2)).to be == 0
   end
 
   it "returns -1 when self is less than a Numeric" do
-    (Parsi::Date.civil(1391, 4, 6) <=> Rational(4912210,2)).should == -1
+    expect(Parsi::Date.civil(1391, 4, 6) <=> Rational(4912210,2)).to be == -1
   end
 
   it "returns 1 when self is greater than a Numeric" do
-    (Parsi::Date.civil(1391, 4, 6) <=> Rational(4912208,2)).should == 1
+    expect(Parsi::Date.civil(1391, 4, 6) <=> Rational(4912208,2)).to be == 1
   end
 end

data/spec/parsi-date/constants_spec.rb

@@ -1,41 +1,45 @@
 # encoding: utf-8
 describe "Date constants" do
   it "defines MONTHNAMES" do
-    Parsi::Date::MONTHNAMES.should == [nil] +
-      %w(فروردین اردیبهشت خرداد تیر مرداد شهریور مهر آبان آذر دی بهمن اسفند)
+    expect(Parsi::Date::MONTHNAMES).to be ==
+      [nil] + %w(فروردین اردیبهشت خرداد تیر مرداد شهریور مهر آبان آذر دی بهمن اسفند)
   end
 
   it "defines EN_MONTHNAMES" do
-    Parsi::Date::EN_MONTHNAMES.should == [nil] +
-      %w(farvardin ordibehesht khordad tir mordad shahrivar mehr aban azar day bahman esfand)
+    expect(Parsi::Date::EN_MONTHNAMES).to be ==
+      [nil] + %w(farvardin ordibehesht khordad tir mordad shahrivar mehr aban azar day bahman esfand)
   end
 
   it "defines ABBR_MONTHNAMES" do
-    Parsi::Date::ABBR_MONTHNAMES.should == [nil] +
-      %w(far ord kho tir mor sha meh abn azr day bah esf)
+    expect(Parsi::Date::ABBR_MONTHNAMES).to be ==
+      [nil] + %w(far ord kho tir mor sha meh abn azr day bah esf)
   end
 
   it "defines DAYNAMES" do
-    Parsi::Date::DAYNAMES.should == %w(یک‌شنبه دوشنبه سه‌شنبه چهارشنبه پنج‌شنبه جمعه شنبه)
+    expect(Parsi::Date::DAYNAMES).to be ==
+      %w(یک‌شنبه دوشنبه سه‌شنبه چهارشنبه پنج‌شنبه جمعه شنبه)
   end
 
   it "defines EN_DAYNAMES" do
-    Parsi::Date::EN_DAYNAMES.should == %w(yekshanbe doshanbe seshanbe chaharshanbe panjshanbe jomee shanbe)
+    expect(Parsi::Date::EN_DAYNAMES).to be ==
+      %w(yekshanbe doshanbe seshanbe chaharshanbe panjshanbe jomee shanbe)
   end
 
   it "defines ABBR_DAYNAMES" do
-    Parsi::Date::ABBR_DAYNAMES.should == %w(۱ش ۲ش ۳ش ۴ش ۵ش ج ش)
+    expect(Parsi::Date::ABBR_DAYNAMES).to be ==
+      %w(۱ش ۲ش ۳ش ۴ش ۵ش ج ش)
   end
 
   it "defines ABBR_EN_DAYNAMES" do
-    Parsi::Date::ABBR_EN_DAYNAMES.should == %w(ye do se ch pj jo sh)
+    expect(Parsi::Date::ABBR_EN_DAYNAMES).to be ==
+      %w(ye do se ch pj jo sh)
   end
 
   it "freezes MONTHNAMES, DAYNAMES, EN_DAYNAMES, ABBR_MONTHNAMES, ABBR_DAYSNAMES" do
     [Parsi::Date::MONTHNAMES, Parsi::Date::EN_MONTHNAMES, Parsi::Date::ABBR_MONTHNAMES,
      Parsi::Date::DAYNAMES, Parsi::Date::EN_DAYNAMES,
-     Parsi::Date::ABBR_DAYNAMES, Parsi::Date::ABBR_EN_DAYNAMES].each do |ary|
-      ary.should be_frozen
+     Parsi::Date::ABBR_DAYNAMES, Parsi::Date::ABBR_EN_DAYNAMES].each do |array|
+      expect(array).to be_frozen
     end
   end
 end

data/spec/parsi-date/construction_spec.rb

@@ -21,38 +21,39 @@ describe Parsi::Date do
 
     it "constructs a Date for 1/1/1 by default" do
       date = Parsi::Date.civil
-      date.year.should  == 1
-      date.month.should == 1
-      date.day.should   == 1
+      expect(date.year ).to be == 1
+      expect(date.month).to be == 1
+      expect(date.day  ).to be == 1
     end
   end
 
   context "ordinal" do
     it "constructs a Date object from an ordinal date" do
-      Parsi::Date.ordinal(1390).should       == Parsi::Date.civil(1390, 1, 1)
-      Parsi::Date.ordinal(1390,7).should     == Parsi::Date.civil(1390, 1, 7)
-      Parsi::Date.ordinal(1390,100).should   == Parsi::Date.civil(1390, 4, 7)
+      expect(Parsi::Date.ordinal(1390)     ).to be == Parsi::Date.civil(1390, 1, 1)
+      expect(Parsi::Date.ordinal(1390, 7)  ).to be == Parsi::Date.civil(1390, 1, 7)
+      expect(Parsi::Date.ordinal(1390, 100)).to be == Parsi::Date.civil(1390, 4, 7)
+      expect(Parsi::Date.ordinal(1403, 366)).to be == Parsi::Date.civil(1403, 12, 30)
     end
   end
 
   context "parse" do
-    it "should parse date from strings" do
+    it "parses date from strings" do
       ['1391/8/6', '1391-8-6', '1391 8 6', '1391 8 6', '13910806'].each do |date_string|
         date = Parsi::Date.parse date_string
-        [date.year, date.month, date.day].should == [1391, 8, 6]
+        expect([date.year, date.month, date.day]).to be == [1391, 8, 6]
       end
     end
 
     it "completes century when second arg is true" do
-      Date.stub(:today) { Date.new 2012, 10, 26 }
+      allow(Date).to receive(:today) { Date.new 2012, 10, 26 }
       date = Parsi::Date.parse '91/8/5', true
-      [date.year, date.month, date.day].should == [1391, 8, 5]
+      expect([date.year, date.month, date.day]).to be == [1391, 8, 5]
     end
 
-    it "should raise ArgumentError on invalid date string" do
-      expect { date = Parsi::Date.parse '1390/12/30' }.to      raise_error(ArgumentError)
+    it "raises ArgumentError on invalid date string" do
+      expect { date = Parsi::Date.parse '1390/12/30'      }.to raise_error(ArgumentError)
       expect { date = Parsi::Date.parse 'bad date string' }.to raise_error(ArgumentError)
-      expect { date = Parsi::Date.parse '12-30-1390' }.to      raise_error(ArgumentError)
+      expect { date = Parsi::Date.parse '12-30-1390'      }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/parsi-date/conversion_spec.rb

@@ -1,36 +1,47 @@
 describe "Parsi::Date.jd" do
   it "constructs a date form given Chronological Julian day number" do
-    Parsi::Date.jd(2456228).should == Parsi::Date.civil(1391, 8, 6)
-    Parsi::Date.jd(2456229).should == Parsi::Date.civil(1391, 8, 7)
+    expect(Parsi::Date.jd(2456228)).to be == Parsi::Date.civil(1391, 8, 6)
+    expect(Parsi::Date.jd(2456229)).to be == Parsi::Date.civil(1391, 8, 7)
+    expect(Parsi::Date.jd(2456229)).to be == Parsi::Date.civil(1391, 8, 7)
+    expect(Parsi::Date.jd(2460755)).to be == Parsi::Date.civil(1403, 12, 30)
+    expect(Parsi::Date.jd(2460756)).to be == Parsi::Date.civil(1404, 1, 1)
   end
 
   it "returns a Date object representing Julian day 0 if no arguments passed"do
-    Parsi::Date.jd.should == Parsi::Date.civil(-5334, 9, 1)
+    expect(Parsi::Date.jd).to be == Parsi::Date.civil(-5334, 9, 3)
   end
 
   it "constructs a Date object if passed a negative number" do
-    Parsi::Date.jd(-1).should == Parsi::Date.civil(-5334, 8, 30)
+    expect(Parsi::Date.jd(-1)).to be == Parsi::Date.civil(-5334, 9, 2)
   end
 end
 
 describe "Parsi::Date#jd" do
   it "determines the Julian day for a Date object" do
-    Parsi::Date.civil(1391, 8, 7).jd.should == 2456229
+    expect(Parsi::Date.civil(1391, 8, 7).jd  ).to be == 2456229
+    expect(Parsi::Date.civil(1403, 12, 30).jd).to be == 2460755
+    expect(Parsi::Date.civil(1404, 1, 1).jd  ).to be == 2460756
   end
 end
 
 describe "Parsi::Date#to_gregorian" do
   it "converts date to Gregorian date" do
     date = Parsi::Date.civil(1391, 8, 7).to_gregorian
-    date.should be_a(Date)
-    date.should == Date.civil(2012, 10, 28)
+    expect(date).to be_a(Date)
+    expect(date).to be == Date.civil(2012, 10, 28)
+
+    expect(Parsi::Date.civil(1366, 11, 14).to_gregorian).to be == Date.civil(1988, 2, 3)
+    expect(Parsi::Date.civil(1403, 12, 30).to_gregorian).to be == Date.civil(2025, 3, 20)
   end
 end
 
 describe "Date#to_parsi" do
   it "converts date to Parsi date" do
     date = Date.civil(2012, 10, 28).to_parsi
-    date.should be_a(Parsi::Date)
-    date.should == Parsi::Date.civil(1391, 8, 7)
+    expect(date).to be_a(Parsi::Date)
+    expect(date).to be == Parsi::Date.civil(1391, 8, 7)
+
+    expect(Date.civil(1988, 2, 3).to_parsi ).to be == Parsi::Date.civil(1366, 11, 14)
+    expect(Date.civil(2025, 3, 20).to_parsi).to be == Parsi::Date.civil(1403, 12, 30)
   end
 end

data/spec/parsi-date/leap_spec.rb

@@ -1,13 +1,15 @@
 describe "Parsi::Date#leap?" do
   it "returns true if a year is a leap year in the Parsi (Jalali) calendar" do
-    Parsi::Date.leap?(1387).should be_truthy
-    Parsi::Date.leap?(1391).should be_truthy
-    Parsi::Date.leap?(1395).should be_truthy
+    expect(Parsi::Date.leap?(1387)).to be true
+    expect(Parsi::Date.leap?(1391)).to be true
+    expect(Parsi::Date.leap?(1395)).to be true
+    expect(Parsi::Date.leap?(1403)).to be true
   end
 
   it "returns false if a year is not a leap year in the Parsi (Jalali) calendar" do
-    Parsi::Date.leap?(1390).should be_falsey
-    Parsi::Date.leap?(1392).should be_falsey
-    Parsi::Date.leap?(1400).should be_falsey
+    expect(Parsi::Date.leap?(1390)).to be false
+    expect(Parsi::Date.leap?(1392)).to be false
+    expect(Parsi::Date.leap?(1400)).to be false
+    expect(Parsi::Date.leap?(1404)).to be false
   end
 end

data/spec/parsi-date/step_spec.rb

@@ -5,23 +5,23 @@ describe "Parsi::Date#step" do
     de = Parsi::Date.civil(1391, 9, 29)
     count = 0
     de.step(ds) do |d|
-      d.should <= ds
-      d.should >= de
+      expect(d).to be <= ds
+      expect(d).to be >= de
       count += 1
     end
-    count.should == 13
+    expect(count).to be == 13
 
     count = 0
     de.step(ds, 5) do |d|
-      d.should <= ds
-      d.should >= de
+      expect(d).to be <= ds
+      expect(d).to be >= de
       count += 1
     end
-    count.should == 3
+    expect(count).to be == 3
 
     count = 0
     ds.step(de) do |d|; count += 1; end
-    count.should == 0
+    expect(count).to be == 0
   end
 
   it "steps backward in time" do
@@ -29,22 +29,22 @@ describe "Parsi::Date#step" do
     de = Parsi::Date.civil(1390, 3, 29)
     count = 0
     ds.step(de, -1) do |d|
-      d.should <= ds
-      d.should >= de
+      expect(d).to be <= ds
+      expect(d).to be >= de
       count += 1
     end
-    count.should == 17
+    expect(count).to be == 17
 
     count = 0
     ds.step(de, -5) do |d|
-      d.should <= ds
-      d.should >= de
+      expect(d).to be <= ds
+      expect(d).to be >= de
       count += 1
     end
-    count.should == 4
+    expect(count).to be == 4
 
     count = 0
     de.step(ds, -1) do |d|; count += 1; end
-    count.should == 0
+    expect(count).to be == 0
   end
 end

data/spec/parsi-date/strftime_spec.rb

@@ -1,108 +1,108 @@
 # encoding: utf-8
 describe "Parsi::Date#strftime" do
 
-  it "should be able to print the date" do
-    Parsi::Date.civil(1390, 4, 6).strftime.should == "1390/04/06"
+  it "is able to print the date" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime).to be == "1390/04/06"
   end
 
-  it "should be able to print the full day name" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%A").should == "دوشنبه"
+  it "is able to print the full day name" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%A")).to be == "دوشنبه"
   end
 
-  it "should be able to print the short day name" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%a").should == "۲ش"
+  it "is able to print the short day name" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%a")).to be == "۲ش"
   end
 
-  it "should be able to print the full month name" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%B").should == "تیر"
-    Parsi::Date.civil(1390, 4, 6).strftime("%EB").should == "tir"
-    Parsi::Date.civil(1390, 4, 6).strftime("%^EB").should == "Tir"
+  it "is able to print the full month name" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%B")  ).to be == "تیر"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%EB") ).to be == "tir"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%^EB")).to be == "Tir"
   end
 
-  it "should be able to print the short month name" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%b").should == "tir"
-    Parsi::Date.civil(1390, 4, 6).strftime("%h").should == "tir"
-    Parsi::Date.civil(1390, 4, 6).strftime("%^b").should == "Tir"
-    Parsi::Date.civil(1390, 4, 6).strftime("%^h").should == "Tir"
-    Parsi::Date.civil(1390, 4, 6).strftime("%b").should == Parsi::Date.civil(1390, 4, 6).strftime("%h")
+  it "is able to print the short month name" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%b") ).to be == "tir"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%h") ).to be == "tir"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%^b")).to be == "Tir"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%^h")).to be == "Tir"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%b") ).to be == Parsi::Date.civil(1390, 4, 6).strftime("%h")
   end
 
-  it "should be able to print the century" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%C").should == "13"
+  it "is able to print the century" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%C")).to be == "13"
   end
 
-  it "should be able to print the month day with leading zeroes" do
-    Parsi::Date.civil(1390, 4,  6).strftime("%d").should == "06"
-    Parsi::Date.civil(1390, 4, 16).strftime("%d").should == "16"
+  it "is able to print the month day with leading zeroes" do
+    expect(Parsi::Date.civil(1390, 4,  6).strftime("%d")).to be == "06"
+    expect(Parsi::Date.civil(1390, 4, 16).strftime("%d")).to be == "16"
   end
 
-  it "should be able to print the month day with leading spaces and without em" do
-    Parsi::Date.civil(1390, 4,  6).strftime("%-d").should == "6"
-    Parsi::Date.civil(1390, 4,  6).strftime("%e").should == " 6"
-    Parsi::Date.civil(1390, 4, 16).strftime("%e").should == "16"
+  it "is able to print the month day with leading spaces and without em" do
+    expect(Parsi::Date.civil(1390, 4,  6).strftime("%-d")).to be == "6"
+    expect(Parsi::Date.civil(1390, 4,  6).strftime("%e") ).to be == " 6"
+    expect(Parsi::Date.civil(1390, 4, 16).strftime("%e") ).to be == "16"
   end
 
-  it "should be able to print the month with leading zeroes, spaces and none" do
-    Parsi::Date.civil(1390,  4, 6).strftime("%m").should == "04"
-    Parsi::Date.civil(1390, 11, 6).strftime("%m").should == "11"
-    Parsi::Date.civil(1390,  4, 6).strftime("%_m").should == " 4"
-    Parsi::Date.civil(1390, 11, 6).strftime("%_m").should == "11"
-    Parsi::Date.civil(1390,  4, 6).strftime("%-m").should == "4"
-    Parsi::Date.civil(1390, 11, 6).strftime("%-m").should == "11"
+  it "is able to print the month with leading zeroes, spaces and none" do
+    expect(Parsi::Date.civil(1390,  4, 6).strftime("%m") ).to be == "04"
+    expect(Parsi::Date.civil(1390, 11, 6).strftime("%m") ).to be == "11"
+    expect(Parsi::Date.civil(1390,  4, 6).strftime("%_m")).to be == " 4"
+    expect(Parsi::Date.civil(1390, 11, 6).strftime("%_m")).to be == "11"
+    expect(Parsi::Date.civil(1390,  4, 6).strftime("%-m")).to be == "4"
+    expect(Parsi::Date.civil(1390, 11, 6).strftime("%-m")).to be == "11"
   end
 
-  it "should be able to add a newline" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%n").should == "\n"
+  it "is able to add a newline" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%n")).to be == "\n"
   end
 
-  it "should be able to add a tab" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%t").should == "\t"
+  it "is able to add a tab" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%t")).to be == "\t"
   end
 
-  it "should be able to show the week day" do
-    Parsi::Date.civil(1390, 4, 11).strftime("%w").should == "6"
-    Parsi::Date.civil(1390, 4, 12).strftime("%w").should == "0"
+  it "is able to show the week day" do
+    expect(Parsi::Date.civil(1390, 4, 11).strftime("%w")).to be == "6"
+    expect(Parsi::Date.civil(1390, 4, 12).strftime("%w")).to be == "0"
   end
 
-  it "should be able to show the year in YYYY format" do
-    Parsi::Date.civil(1390, 4, 9).strftime("%Y").should == "1390"
+  it "is able to show the year in YYYY format" do
+    expect(Parsi::Date.civil(1390, 4, 9).strftime("%Y")).to be == "1390"
   end
 
-  it "should be able to show the year in YY format" do
-    Parsi::Date.civil(1390, 4, 9).strftime("%y").should == "90"
+  it "is able to show the year in YY format" do
+    expect(Parsi::Date.civil(1390, 4, 9).strftime("%y")).to be == "90"
   end
 
-  it "should be able to escape the % character" do
-    Parsi::Date.civil(1390, 4, 9).strftime("%%").should == "%"
+  it "is able to escape the % character" do
+    expect(Parsi::Date.civil(1390, 4, 9).strftime("%%")).to be == "%"
   end
 
   ############################
   # Specs that combine stuff #
   ############################
 
-  it "should be able to print the date in full" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%c").should == "۲ش 6 تیر 1390"
-    Parsi::Date.civil(1390, 4, 6).strftime("%c").should == Parsi::Date.civil(1390, 4, 6).strftime('%a %-d %B %Y')
+  it "is able to print the date in full" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%c")).to be == "۲ش 6 تیر 1390"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%c")).to be == Parsi::Date.civil(1390, 4, 6).strftime('%a %-d %B %Y')
   end
 
-  it "should be able to print the date with slashes" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%D").should == "90/04/06"
-    Parsi::Date.civil(1390, 4, 6).strftime("%D").should == Parsi::Date.civil(1390, 4, 6).strftime('%y/%m/%d')
+  it "is able to print the date with slashes" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%D")).to be == "90/04/06"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%D")).to be == Parsi::Date.civil(1390, 4, 6).strftime('%y/%m/%d')
   end
 
-  it "should be able to print the date as YYYY-MM-DD" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%F").should == "1390-04-06"
-    Parsi::Date.civil(1390, 4, 6).strftime("%F").should == Parsi::Date.civil(1390, 4, 6).strftime('%Y-%m-%d')
+  it "is able to print the date as YYYY-MM-DD" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%F")).to be == "1390-04-06"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%F")).to be == Parsi::Date.civil(1390, 4, 6).strftime('%Y-%m-%d')
   end
 
-  it "should be able to show the commercial week" do
-    Parsi::Date.civil(1390, 4, 9).strftime("%v").should == " 9-تیر-1390"
-    Parsi::Date.civil(1390, 4, 9).strftime("%v").should == Parsi::Date.civil(1390, 4, 9).strftime('%e-%B-%Y')
+  it "is able to show the commercial week" do
+    expect(Parsi::Date.civil(1390, 4, 9).strftime("%v")).to be == " 9-تیر-1390"
+    expect(Parsi::Date.civil(1390, 4, 9).strftime("%v")).to be == Parsi::Date.civil(1390, 4, 9).strftime('%e-%B-%Y')
   end
 
-  it "should be able to show YY/MM/DD" do
-    Parsi::Date.civil(1390, 4, 6).strftime("%x").should == "90/04/06"
-    Parsi::Date.civil(1390, 4, 6).strftime("%x").should == Parsi::Date.civil(1390, 4, 6).strftime('%y/%m/%d')
+  it "is able to show YY/MM/DD" do
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%x")).to be == "90/04/06"
+    expect(Parsi::Date.civil(1390, 4, 6).strftime("%x")).to be == Parsi::Date.civil(1390, 4, 6).strftime('%y/%m/%d')
   end
 
 end

data/spec/parsi-date/week_methods_spec.rb

@@ -1,17 +1,17 @@
 describe "Parsi::Date#cwday?" do
   it "returns the day of calendar week (1-7, Monday is 1)" do
-    Parsi::Date.civil(1393, 12, 3).cwday.should == 7
-    Parsi::Date.civil(1394,  1, 3).cwday.should == 1
+    expect(Parsi::Date.civil(1393, 12, 3).cwday).to be == 7
+    expect(Parsi::Date.civil(1394,  1, 3).cwday).to be == 1
   end
 end
 
 describe "Parsi::Date#cweek?" do
   it "returns the calendar week number (1-53)" do
-    Parsi::Date.civil(1393, 11, 30).cweek.should == 48
-    Parsi::Date.civil(1393, 12, 1).cweek.should == 48
-    Parsi::Date.civil(1393, 12, 29).cweek.should == 52
-    Parsi::Date.civil(1394, 1, 1).cweek.should == 1
-    Parsi::Date.civil(1394, 1, 7).cweek.should == 1
-    Parsi::Date.civil(1394, 1, 8).cweek.should == 2
+    expect(Parsi::Date.civil(1393, 11, 30).cweek).to be == 48
+    expect(Parsi::Date.civil(1393, 12, 1).cweek ).to be == 48
+    expect(Parsi::Date.civil(1393, 12, 29).cweek).to be == 52
+    expect(Parsi::Date.civil(1394, 1, 1).cweek  ).to be == 1
+    expect(Parsi::Date.civil(1394, 1, 7).cweek  ).to be == 1
+    expect(Parsi::Date.civil(1394, 1, 8).cweek  ).to be == 2
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 require 'parsi-date'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsi-date
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Hassan Zamani
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-05 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,70 +16,84 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
 description: A Solar Hijri (Jalali) date library for Ruby, whitch provides much of
   Ruby's built-in date class
 email: hsn.zamani@gmail.com
@@ -87,13 +101,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
-- README.rdoc
-- TODO
+- README.md
 - lib/parsi-date-accessors.rb
 - lib/parsi-date.rb
 - lib/parsi-datetime.rb
@@ -116,7 +129,7 @@ homepage: http://github.com/hzamani/parsi-date
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -131,9 +144,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.3.25
+signing_key:
 specification_version: 4
 summary: Solar Hijri (Jalali, Persian, Parsi) date library for Ruby
 test_files:
@@ -150,4 +162,3 @@ test_files:
 - spec/parsi-date/strftime_spec.rb
 - spec/parsi-date/week_methods_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/.travis.yml

@@ -1,6 +0,0 @@
-language: ruby
-rvm:
-  - 2.0.0
-  - 1.9.3
-script:
-  - bundle exec rspec spec/

data/README.rdoc

@@ -1,31 +0,0 @@
-= Parsi Date
-
-This is an implementation of {Solar Hijri Calendar}[http://en.wikipedia.org/wiki/Solar_Hijri_calendar]
-(some times referred to as Jalali or Persian Calendar) which is Iran's official calendar.
-Main aim of this gem is to create a Solar Hijri date library as close as possible to the built-in date library.
-Conversion algorithm originally adopted from {here}[http://www.fourmilab.ch/documents/calendar/].
-
-== Usage
-
-You can use <tt>Parsi::Date<\tt> and <tt>Parsi::DateTime<\tt> objects as +Date+ and +DateTime+ objects
-For example:
-
-  a = Parsi::Date.today                     # => #<Parsi::Date: 1391-08-09 (4912461/2,0/1)>
-  b = a >> 12                               # => #<Parsi::Date: 1392-08-09 (4913193/2,0/1)>
-  a.upto(b).select{ |d| d.sunday? }.count   # => 52
-
-  Parsi::Date.leap? 1391                    # => true
-
-  c = Parsi::Date.parse "1391/10/12"        # => #<Parsi::Date: 1391-10-12 (4912587/2,0)>
-  c.strftime "%A %d %B %Y"                  # => "سه‌شنبه 12 دی 1391"
-  c.strftime "%^EA %d %^EB %Y"              # => "Seshambe 12 Day 1391"
-
-For converting a +Date+ or +DateTime+ object just call +to_parsi+ (aliased to +jalali+ and +to_jalali+) on it.
-To convert back use +to_gregorian+.
-
-  d = Date.civil(2012, 10, 30).to_parsi     # => #<Parsi::Date: 1391-08-09 (4912461/2,0/1)>
-  d.to_gregorian                            # => #<Date: 2012-10-30 ((2456231j,0s,0n),+0s,2299161j)>
-
-
-
-Copyright (c) 2012 Hassan Zamani, released under the MIT license.

data/TODO

@@ -1,13 +0,0 @@
-(A) Write rdocs
-(A) Fulfill specs
-
-Add change log
-
-Add activerecord helper: (maybe it's better to add somewhere else parsi-localize for example)
-
-class Product < ActiveRecord::Base
-  # this must add :parsi_released_at accessors and sync with original attribute
-  has_parsi_date_for :released_at
-
-  # can have an optional name
-  has_parsi_date_for :lifecycel_ended_at, as: 'end_of_life'