jalali-date 0.3.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6cf12c626b443c3634bd78cb2e329ddf5b01ef4f907f7b16503a71bdafd4cd4
+  data.tar.gz: c9c43f0171b726aa0c6e9fbc3f607c3b6883e01f61a8a9abdda9c0d8636c021a
+SHA512:
+  metadata.gz: 4b813c10502d8adf45e6cf11ea3bc278187f69acfa19b26ce5590c58c902442396e97a369598d584646056611d6ea3c6c2d696955e04b79bdd0e741ead43fb8b
+  data.tar.gz: 68a795aff57af3404af120fc3ea22f256186c2c8781665a8406d30be4410bc4fe375dc06732e2007081248b6f5767090a61a40138f3b320c211db60f2d2d5aa9

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.idea/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm: 2.4
+script: rspec

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    jalali-date (0.3.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.6.2)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (>= 1.16)
+  jalali-date!
+  rspec (~> 3.0)
+
+CHECKSUMS
+  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
+  jalali-date (0.3.7)
+  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
+  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
+  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
+  rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
+  rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
+
+BUNDLED WITH
+  4.0.10

data/LICENSE

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

data/README.md

@@ -0,0 +1,247 @@
+# Jalali Date Library
+A lightweight Ruby library for converting, formatting, and parsing Jalali (جلالی/Persian/Shamsi) dates.
+
+Jalalidate provides simple APIs for:
+
+* Gregorian → Jalali conversion
+* Jalali → Gregorian conversion
+* Jalali date formatting
+* Parsing Persian date strings
+* Working with Persian numerals and month names
+
+## Install
+Add this line to your application's Gemfile:
+
+```ruby
+ gem 'jalali-date' 
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it manually:
+
+    $ gem install jalali-date
+
+## Usage
+Date conversion and class methods:
+```ruby
+require 'jalali_date'
+
+# Create a jalali date object:
+j_date = JalaliDate.new(1402,02,25)
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 25 >
+
+j_date = JalaliDate.new(Date.today)
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 25 >
+
+# Initialize with hour, minute and second
+j_date = JalaliDate.new(Time.now)
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 25, :hour => 6, :minute => 01, :second => 30 >
+
+# Convert to gregorian date
+g_date = j_date.to_gregorian
+g_date = j_date.to_g
+#=> Mon, 15 May 2023
+
+
+# Get yesterday, today, or tomorrow in jalali
+j_today = JalaliDate.yesterday
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 24 >
+j_today = JalaliDate.today
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 25 >
+j_tomorrow = JalaliDate.tomorrow
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 26 >
+ 
+# Get year, month, and day
+year = j_date.year       #=> 1402
+month = j_date.month     #=> 02
+day = j_date.day         #=> 25
+
+# Get gregorian year, month, and day
+g_year = j_date.g_year   #=> 2023
+g_month = j_date.g_month #=> 5
+g_day = j_date.g_day     #=> 15
+
+# Get day of the year
+dy = j_date.yday #=> 51
+
+# Get the next day
+tomorrow = j_date.next
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 26 >
+
+# Add and substract days
+j_date + 6.days
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 31 >
+j_date + 1.month
+#=> <JalaliDate, :year => 1402, :month => 3, :day => 25 >
+j_date + 2.years + 5.month + 12.days
+#=> <JalaliDate, :year => 1404, :month => 8, :day => 5 >
+
+# Shift the date with number of month
+j_date >> 5
+#=> <JalaliDate, :year => 1402, :month => 7, :day => 25 >
+j_date << 5
+#=> <JalaliDate, :year => 1401, :month => 9, :day => 25 >
+
+# Compare two dates
+j_date < j_date.next       #=> true
+j_date > j_date.next       #=> false
+j_date > j_date.previous   #=> true
+j_date <=> j_date.next     #=> -1
+j_date <=> j_date          #=> 0
+j_date <=> j_date.previous #=> 1
+
+# Cycle through dates in different ways, namely, step, upto and downto
+# every 2 days, including j_date, for the next 10 days
+j_date.step( j_date + 10 , 2)
+
+# every day, including j_date and the next 5 days
+j_date.upto(j_date + 5)
+
+# every day, including j_date and the previous 5 days
+j_date.downto(j_date - 5)
+
+
+# Get day object as array or hash
+j_date.to_a     #=> [1405, 2, 25]
+j_date.to_hash  #=> {year: 1405, month: 2, day: 25}
+
+
+# Check for leap year
+JalaliDate.leap? 1402
+#=> false
+
+# Check for validity of a jalali date
+JalaliDate.valid?(1402,02,25)
+#=> true
+
+JalaliDate.valid?(1402,12,30)
+#=> false
+```
+
+### Date formatting:
+
+```ruby
+# Initialize with hour, minute and second
+j_date = JalaliDate.new(Time.now)
+#=> <JalaliDate, :year => 1402, :month => 2, :day => 25, :hour => 6, :minute => 01, :second => 30 >
+
+j_date.strftime("%a %A %b %B %d %e %j %m %w %y %Y %% %x")
+#=> "۲ش دوشنبه اردیبهشت Ordibehesht 25 25 56 2 1 02 1402 % 02/2/25"
+
+j_date.strftime("%X")
+#=> "06:01:30"
+
+j_date.strftime("%H:%M - %Y/%n/%d")
+#=> "06:01 - 1402/02/25"
+```
+
+## Format meanings:
+
+- `[%a]` The abbreviated weekday name (۳ش)
+- `[%A]` The full weekday name (یکشنبه)
+- `[%b]` The month name (اردیبهشت)
+- `[%B]` The month name in pinglish (Ordibehesht)
+- `[%d]` Day of the month (01..31)
+- `[%e]` Day of the month (1..31)
+- `[%j]` Day of the year (1..366)
+- `[%m]` Month of the year (1..12)
+- `[%n]` Month of the year (01..12)
+- `[%w]` Day of the week (Sunday is 0, 0..6)
+- `[%x]` Preferred representation for the date alone, no time in format YY/M/D
+- `[%y]` Year without a century (00..99)
+- `[%Y]` Year with century
+- `[%H]` Hour of the day, 24-hour clock (00..23)
+- `[%I]` Hour of the day, 12-hour clock (01..12)
+- `[%M]` Minute of the hour (00..59)
+- `[%p]` Meridian indicator ("بعد از ظهر" or "قبل از ظهر")
+- `[%P]` Meridian indicator ("ب.ظ" or "ق.ظ")
+- `[%S]` Second of the minute (00..60)
+- `[%X]` Preferred representation for the time alone, no date
+- `[%Z]` Time zone name
+- `[%%]` teral %'' character
+
+## Parsing Jalali Dates
+
+The parser supports multiple common Persian date formats.
+
+### Numeric Formats
+```ruby
+JalaliDate.parse('1402/02/25')
+JalaliDate.parse('1402-02-25')
+JalaliDate.parse('1402.02.25')
+```
+### Persian Month Names
+```ruby 
+JalaliDate.parse('25 اردیبهشت 1402')
+JalaliDate.parse('اردیبهشت 25 1402')
+```
+
+### DateTime Parsing
+```ruby 
+JalaliDate.parse('1402/02/25 06:01')
+JalaliDate.parse('1402/02/25 06:01:30')
+JalaliDate.parse('25 اردیبهشت ۱۴۰۲ ساعت ۰۶:۰۱')
+```
+
+### Persian Digits
+
+The parser automatically normalizes Persian and Arabic numerals:
+
+```ruby
+JalaliDate.parse('۱۴۰۲/۰۲/۲۵')
+JalaliDate.parse('١٤٠۲/٠٢/٢٥')
+```
+
+## Tests
+Simply run `rspec` command in the source directory:
+
+    $ bundle exec rspec
+
+## History
+
+#### 0.3.3 - 17.SEP.2013
+* added %n formatter for numeric representation of a month, with leading zeros, courtesy of [Mohsen Alizadeh](https://github.com/m0h3n)
+
+#### 0.3.2 - 8.APR.2013
+* Making JalaliDate class thread safe, courtesy of [Jahangir Zinedine](https://github.com/jzinedine)
+
+#### 0.3.1 - 26.APR.2011
+* Added ruby 1.9 compatibility, courtesy of [Reza](https://github.com/ryco)
+
+#### 0.3 - 6.JAN.2011
+* JalaiDate could be initialized with Time and DateTime objects
+* More options for strftime method %H,%M,%S,%X,%Z,%I,%p. read docs for more information
+* Added jdate and jcal binaries to access jcal from the command-line
+* Updated some documentations
+* Now using bundler
+
+#### 0.2 - 25.FEB.2010
+* Renamed the gem from JalaliDate to jalalidate
+* Added spec and a full test suite
+* Updated gemspec file for rubygems.org
+* Updated some documentations
+
+#### 0.02 - 8.AUG.2008
+* Added jalali to geregorian date convertor.
+* Added JalaliDate class and ported Date class method to JalaliDate
+
+#### 0.01 - 7.AUG.2008
+* Planning the project
+
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2008-2011 Allen A. Bargi. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/TODO

@@ -0,0 +1,7 @@
+=TODO
+* add week number of the year %W and %U
+* better jcal and jdate with param
+* support afghan month names
+* update read me / talk about the binaries
+* ActiveSupport::CoreExtensions::Date
+* ActionView::Helpers::DateHelper

data/bin/jcal

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'jalali_date'
+require 'jalali_date/cli'
+
+JalaliDate::Cli.jcal(*ARGV)

data/bin/jdate

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'jalali_date'
+require 'jalali_date/cli'
+
+JalaliDate::Cli.jdate(*ARGV)

data/jalalidate.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jalali_date/version"
+
+Gem::Specification.new do |s|
+  s.name                      = "jalali-date"
+  s.version                   = JalaliDate::VERSION
+  s.platform                  = Gem::Platform::RUBY
+  s.authors                   = ["Allen A. Bargi", "Loqman Hakimi"]
+  s.email                     = %q{allen.bargi@gmail.com loqmanhakimi@gmail.com}
+
+  s.homepage                  = %q{http://github.com/loqman/jalalidate}
+  s.license                   = "MIT"
+  s.summary                   = %q{A library for working with Jalali Calendar (a.k.a Persian Calendar)}
+  s.required_ruby_version     = '>= 3.0'
+  s.files                     = `git ls-files`.split("\n")
+  s.test_files                = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables               = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths             = ["lib"]
+  s.extra_rdoc_files          = [ "LICENSE", "README.md"]
+  s.rdoc_options              = ["--charset=UTF-8"]
+
+  s.add_development_dependency 'bundler', '>= 1.16'
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/jalali_date/cli.rb

@@ -0,0 +1,36 @@
+class JalaliDate
+  class Cli
+
+    # prints today's date in jalali calendar to STDOUT
+    #
+    def self.jdate(*args)
+      jdate = JalaliDate.new(Date.today)
+      puts jdate
+    end
+
+    # prints current month calendar in jalali calendar to STDOUT
+    #
+    def self.jcal(*args)
+      today = JalaliDate.new(Date.today)
+      jdate = JalaliDate.new(today.year,today.month,1)
+      # print month and year
+      puts jdate.strftime("%b %Y").center(26)
+      # print weekdays
+      puts JalaliDate::PERSIAN_ABBR_WEEKDAY_NAMES.reverse[1..6].join("  ") +  " " +  JalaliDate::PERSIAN_ABBR_WEEKDAY_NAMES.reverse[0] + " "
+      # print the month days
+      padding = true
+      JalaliDate::JDaysInMonth[jdate.month - 1].times do |index|
+        if padding
+          print " " * (jdate.jwday*4)
+          padding = false
+        end
+        print "%2d" % jdate.day + "  "
+        print "\n"  if jdate.jwday == 6
+        jdate = jdate.next
+      end
+
+      puts "\n"
+    end
+
+  end
+end

data/lib/jalali_date/version.rb

@@ -0,0 +1,3 @@
+class JalaliDate
+  VERSION = "0.3.7"
+end

data/lib/jalali_date.rb

@@ -0,0 +1,372 @@
+# encoding: utf-8
+# :title:Jalali Date #
+if RUBY_VERSION < '1.9'
+  require "jcode"
+  $KCODE = 'u'
+end
+require "date"
+require "jalali_date_parser"
+
+class JalaliDate
+
+  #:stopdoc:
+  GDaysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  JDaysInMonth = [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29]
+  PERSIAN_MONTH_NAMES = [nil, "فروردین","اردیبهشت","خرداد","تیر","مرداد","شهریور","مهر","آبان","آذر","دی","بهمن","اسفند"]
+  PERSIAN_MONTH_NAMES_PINGLISH = [nil, "Farvardin", "Ordibehesht", "Khordad", "Tir", "Mordad", "Shahrivar", "Mehr", "Aban", "Azar", "Dey", "Bahman", "Esfand"]
+  PERSIAN_WEEKDAY_NAMES = ["یک‌شنبه","دوشنبه","سه‌شنبه","چهارشنبه","پنج‌شنبه","جمعه","شنبه"]
+  PERSIAN_ABBR_WEEKDAY_NAMES = ["۱ش ","۲ش","۳ش","۴ش","۵ش","ج ","ش"]
+  PERSIAN_MERIDIAN_INDICATOR = ["قبل از ظهر","بعد از ظهر"]
+  PERSIAN_ABBR_MERIDIAN_INDICATOR = ["ق.ظ","ب.ظ"]
+  #:startdoc:
+
+  include Comparable
+
+  attr_accessor :year,:month,:day, :hour, :min, :sec
+  attr_reader :g_year, :g_month, :g_day
+
+  # Can be initialized in two ways:
+  # - First by feeding 3 arguments for Jalali Date, year,month and day.
+  # - The Second way to initializes is to pass a normal Ruby Date object, it'll be converted to jalali automatically.
+  #
+  # Example:
+  #   jdate = JalaliDate.new(Date.today)
+  #   other_jdate = JalaliDate.new(1388,9,17)
+  def initialize *args
+    if (args.size == 1) && (args.first.is_a?(Date))
+      year,month,day = gregorian_to_jalali(args.first.year, args.first.month, args.first.day)
+    elsif (args.size == 1) && (args.first.is_a?(Time) || args.first.is_a?(DateTime))
+      year,month,day = gregorian_to_jalali(args.first.year, args.first.month, args.first.day)
+      @hour = args.first.hour || 0
+      @min  = args.first.min  || 0
+      @sec  = args.first.sec  || 0
+      @zone = args.first.zone || "UTC"
+      @utc_offset = args.first.utc_offset  || 0
+    else
+      year,month,day,hour,min,sec,zone,utc_offset = args
+    end
+
+    raise ArgumentError, "invalid arguments or invalid Jalali date" unless self.class.valid?(year,month,day)
+    @year  = year
+    @month = month
+    @day   = day
+    @hour ||=  hour || 0
+    @min  ||=  min  || 0
+    @sec  ||=  sec  || 0
+    @zone ||=  zone || "UTC"
+    @utc_offset ||= utc_offset || 0
+    @g_year, @g_month, @g_day = jalali_to_gregorian(year,month,day)
+  end
+
+  # Class Methods -----------------------------------------------------------
+  class << self
+    # Return a JalaliDate object representing today's date in calendar
+    def today
+      JalaliDate.new(Date.today)
+    end
+
+    # Return a JalaliDate object representing yesterday's date in calendar
+    def yesterday
+      JalaliDate.new(Date.today - 1)
+    end
+
+    # Return a JalaliDate object representing tomorrow's date in calendar
+    def tomorrow
+      JalaliDate.new(Date.today + 1)
+    end
+
+    # Return JalaliDate from a provided string
+    def parse(s)
+      date = JalaliDateParser.parse(s)
+      date[:jalali]
+    end
+
+    # Accpets a four digit number as the jalaliyear and returns true if that particular year
+    # is a leap year in jalali calendar otherwise it returns false.
+    def leap?(y)
+      [6,22,17,13,9,5,1,30].include?(y%33) ? true : false
+    end
+
+    # Accpets three numbers for year (4 digit), month and day in jalali calendar and checks if it's a
+    # valid date according to jalali calendar or not.
+    def valid?(y,m,d)
+      ( y.class == Integer && y > 0 &&
+        m.class == Integer && (1..12).include?(m) &&
+        d.class == Integer &&
+        (
+          ((1..JDaysInMonth[m-1]).include?(d)) || (d == 30 && m == 12 && leap?(y))
+        )
+      ) ? true : false
+    end
+  end
+
+  # Instance Methods --------------------------------------------------------
+
+  # Converts a JalaiDate object to Ruby Date object
+  def to_gregorian
+    Date.new(@g_year,@g_month,@g_day)
+  end
+  alias :to_g :to_gregorian
+
+  # Returns a string represtation of the JalaliDate object in format like this: y/m/d
+  def to_s
+    [@year,@month,@day].join("/")
+  end
+
+  # Returns a hash in a format like this: {:year => @year, :month => @month, :day => @day}
+  def to_hash
+    {:year => @year, :month => @month, :day => @day}
+  end
+
+  # Returns an array in a format like this: [y,m,d]
+  def to_a
+    [@year,@month,@day]
+  end
+
+  # Return internal object state as a programmer-readable string.
+  def inspect
+    "#<#{self.class}:#{self.object_id}, :year => #{@year}, :month => #{@month}, :day => #{@day} >"
+  end
+
+  # Adds n days to the current JalaliDate object
+  def +(days)
+    self.class.new( to_g + days )
+  end
+
+  # Subtracts n days from the current JalaliDate object
+  def -(days)
+    self.class.new( to_g - days )
+  end
+
+  # Return the next day for the current JalaliDate object
+  def next(n=1)
+    self + n
+  end
+  alias :succ :next
+
+  # Return the previous day for the current JalaliDate object
+  def previous(n=1)
+    self - n
+  end
+
+  # Compares two JalaliDate objects. acts like Date#<=>
+  def <=>(other)
+    to_g <=> other.to_g
+  end
+
+  # Move JalaliDate object forward by n months
+  def >>(months)
+    y, m = (@year * 12 + (@month - 1) + months).divmod(12)
+    m,   = (m + 1)                    .divmod(1)
+    d = @day
+    d -= 1 until self.class.valid?(y, m, d)
+    self.class.new(y,m,d)
+  end
+
+  # Move JalaliDate object backward by n months
+  def <<(months)
+    self >> -months
+  end
+
+  # Step the current date forward +step+ days at a time (or backward, if step is negative) until we reach
+  # limit (inclusive), yielding the resultant date at each step.
+  #
+  # Example:
+  #   jdate = JalaliDate.new(Date.today)
+  #   jdate.step(Date.today+10, 2) do |jd|
+  #     puts jd.to_s
+  #   end
+  def step(limit, step=1)
+    da = self
+    op = %w(- <= >=)[step <=> 0]
+    while da.__send__(op, limit)
+      yield da
+      da += step
+    end
+    self
+  end
+
+  # Step forward one day at a time until we reach max (inclusive), yielding each date as we go.
+  #
+  # Example:
+  #   jdate = JalaliDate.new(Date.today)
+  #   days_string = ""
+  #   jdate.upto(jdate+5) do |jd|
+  #     days_string += jd.day.to_s
+  #   end
+  def upto(max, &block)
+    step(max, +1, &block)
+  end
+
+  # Step backward one day at a time until we reach min (inclusive), yielding each date as we go.
+  # See #upto for the example.
+  def downto(min, &block)
+    step(min, -1, &block)
+  end
+
+  # Is this a leap year?
+  def leap?
+    self.class.leap?(@year)
+  end
+
+  # Get the week day of this date. Sunday is day-of-week 0; Saturday is day-of-week 6.
+  def wday
+    to_g.wday
+  end
+
+  # Get the jalali week day of this date. Saturday is day-of-week 0;  Friday is day-of-week 6.
+  def jwday
+    (to_g.wday + 1) % 7
+  end
+
+  # Get the day-of-the-year of this date.
+  # Farvardin 1 is day-of-the-year 1
+  def yday
+    m = (@month-2 < 0) ? 0 : @month-2
+    (@month==1) ? @day : @day + JDaysInMonth[0..m].inject(0) {|sum, n| sum + n }
+  end
+
+  # Formats time according to the directives in the given format string. Any text not listed as a directive will be
+  # passed through to the output string.
+  #
+  # Format meanings:
+  #
+  # [%a]   The abbreviated weekday name (۳ش)
+  # [%A]   The full weekday name (یکشنبه)
+  # [%b]   The month name (اردیبهشت)
+  # [%B]   The month name in pinglish (Ordibehesht)
+  # [%d]   Day of the month (01..31)
+  # [%e]   Day of the month (1..31)
+  # [%j]   Day of the year (1..366)
+  # [%m]   Month of the year (1..12)
+  # [%n]   Month of the year (01..12)
+  # [%w]   Day of the week (Sunday is 0, 0..6)
+  # [%x]   Preferred representation for the date alone, no time in format YY/M/D
+  # [%y]   Year without a century (00..99)
+  # [%Y]   Year with century
+  # [%H]   Hour of the day, 24-hour clock (00..23)
+  # [%I]   Hour of the day, 12-hour clock (01..12)
+  # [%M]   Minute of the hour (00..59)
+  # [%p]   Meridian indicator ("بعد از ظهر" or "قبل از ظهر")
+  # [%P]   Meridian indicator ("ب.ظ" or "ق.ظ")
+  # [%S]   Second of the minute (00..60)
+  # [%X]   Preferred representation for the time alone, no date
+  # [%Z]   Time zone name
+  # [%%]   Literal %'' character
+  #
+  # Example:
+  #   d = JalaliDate.today
+  #   d.strftime("Printed on %Y/%m/%d")   #=> "Printed on 87/5/26
+  def strftime(format_str = '%Y/%m/%d')
+    clean_fmt = format_str.gsub(/%{2}/, "SUBSTITUTION_MARKER").
+      gsub(/%a/, PERSIAN_ABBR_WEEKDAY_NAMES[wday]).
+      gsub(/%A/, PERSIAN_WEEKDAY_NAMES[wday]).
+      gsub(/%b/, PERSIAN_MONTH_NAMES[@month]).
+      gsub(/%B/, PERSIAN_MONTH_NAMES_PINGLISH[@month]).
+      gsub(/%d/, ("%02d" % @day).to_s).
+      gsub(/%e/, @day.to_s).
+      gsub(/%m/, @month.to_s).
+	    gsub(/%n/, ("%02d" % @month).to_s).
+      gsub(/%Y/, @year.to_s).
+      gsub(/%y/, @year.to_s.slice(2,2)).
+      gsub(/%j/, yday.to_s).
+      gsub(/%H/, ("%02d" % @hour).to_s).
+      gsub(/%I/, ("%02d" % ((@hour>=12) ? @hour-12 : @hour)).to_s).
+      gsub(/%M/, ("%02d" % @min).to_s).
+      gsub(/%S/, ("%02d" % @sec).to_s).
+      gsub(/%p/, (@hour>=12 ? "بعد از ظهر" : "قبل از ظهر")).
+      gsub(/%P/, (@hour>=12 ? "ب.ظ" : "ق.ظ")).
+      gsub(/%w/, wday.to_s).
+      gsub(/%Z/, @zone).
+      gsub(/%X/, [("%02d" % @hour),("%02d" % @min),("%02d" % @sec)].join(":")).
+      gsub(/%x/, [@year.to_s.slice(2,2),@month,@day].join("/")).
+      gsub(/#{"SUBSTITUTION_MARKER"}/, '%')
+  end
+  alias :format :strftime
+
+  private #-------------------------------------------------------------------------
+
+  def gregorian_to_jalali(year, month, day) # :nodoc:
+    jj=0
+    gy = year - 1600
+    gm = month - 1
+    gd = day - 1
+    g_day_no = 365*gy + (gy+3)/4 - (gy+99)/100 + (gy+399)/400
+    gm.times { |i| g_day_no += GDaysInMonth[i] }
+    g_day_no += 1 if gm > 1 && ((gy%4 == 0 && gy%100 != 0) || (gy%400 == 0))
+    g_day_no += gd
+
+    j_day_no = g_day_no-79
+    j_np = j_day_no/12053
+    j_day_no %= 12053
+    jy = 979 + 33 * j_np + 4*(j_day_no/1461)
+    j_day_no %= 1461
+
+    if (j_day_no >= 366)
+       jy += (j_day_no - 1)/365
+       j_day_no = (j_day_no - 1) % 365
+    end
+
+    11.times do |i|
+      if j_day_no >= JDaysInMonth[i]
+        j_day_no -= JDaysInMonth[i]
+        jj = i + 1
+      else
+        jj = i
+        break
+      end
+    end
+    jm = jj + 1
+    jd = j_day_no + 1
+
+    [jy, jm, jd]
+  end
+
+  def jalali_to_gregorian(year,month,day) # :nodoc:
+    gg=0
+    jy = year - 979
+    jm = month - 1
+    jd = day - 1
+    j_day_no = 365*jy + (jy/33)*8 + (jy % 33 + 3)/4
+    jm.times { |i| j_day_no += JDaysInMonth[i] }
+    j_day_no += jd
+
+    g_day_no = j_day_no + 79
+    gy = 1600 + 400*(g_day_no/146097)
+    g_day_no %= 146097
+
+    leap = true
+    if g_day_no >= 36525
+      g_day_no -= 1
+      gy += 100 * (g_day_no/36524)
+      g_day_no %= 36524
+      (g_day_no >= 365) ? g_day_no += 1 : leap = false
+    end
+
+    gy += 4 * (g_day_no/1461)
+    g_day_no %= 1461
+
+    if g_day_no >= 366
+      leap = false
+      g_day_no -= 1
+      gy += g_day_no/365
+      g_day_no %= 365
+    end
+
+    11.times do |i|
+      leap_day = (i==1 && leap) ?  1 : 0
+      if g_day_no >= (GDaysInMonth[i] + leap_day )
+        g_day_no -= (GDaysInMonth[i] + leap_day )
+        gg = i + 1
+      else
+        gg = i
+        break
+      end
+    end
+    gm = gg + 1
+    gd = g_day_no + 1
+
+    [gy,gm,gd]
+  end
+
+end

data/lib/jalali_date_parser.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Usage:
+#   JalaliDateParser.parse("1402/02/25")
+#   JalaliDateParser.parse("۱۴۰۲-۰۲-۲۵ ۰۶:۰۱")
+#   JalaliDateParser.parse("25 اردیبهشت 1402")
+#   JalaliDateParser.parse("25 اردیبهشت 1402 ساعت 6:01:30")
+#   JalaliDateParser.parse("1402.2.25")
+#   JalaliDateParser.parse("1402/02/25T06:01:30")
+#
+# Returns:
+#   {
+#     jalali: #<JalaliDate ...>,
+#     gregorian: #<DateTime ...>,
+#     components: {
+#       year: 1402,
+#       month: 2,
+#       day: 25,
+#       hour: 06,
+#       min: 01,
+#       sec: 30
+#     }
+#   }
+
+require "date"
+require "jalali_date"
+
+module JalaliDateParser
+  PERSIAN_DIGITS = "۰۱۲۳۴۵۶۷۸۹"
+  ENGLISH_DIGITS = "0123456789"
+  ARABIC_DIGITS = "٠١٢٣٤٥٦٧٨٩"
+
+  MONTHS = {
+    "فروردین" => 1,
+    "اردیبهشت" => 2,
+    "خرداد" => 3,
+    "تیر" => 4,
+    "مرداد" => 5,
+    "شهریور" => 6,
+    "مهر" => 7,
+    "آبان" => 8,
+    "آذر" => 9,
+    "دی" => 10,
+    "بهمن" => 11,
+    "اسفند" => 12
+  }.freeze
+
+  COMMON_PATTERNS = [
+    # 1403/01/15
+    # 1403-01-15
+    # 1403.01.15
+    {
+      regex: /
+        (?<year>\d{4})
+        [\/\-.]
+        (?<month>\d{1,2})
+        [\/\-.]
+        (?<day>\d{1,2})
+        (?:[T\s]+(?<time>\d{1,2}:\d{1,2}(?::\d{1,2})?))?
+      /x
+    },
+
+    # 15/01/1403
+    # 15-01-1403
+    {
+      regex: /
+        (?<day>\d{1,2})
+        [\/\-.]
+        (?<month>\d{1,2})
+        [\/\-.]
+        (?<year>\d{4})
+        (?:[T\s]+(?<time>\d{1,2}:\d{1,2}(?::\d{1,2})?))?
+      /x
+    },
+
+    # 15 فروردین 1403
+    # فروردین 15 1403
+    {
+      regex: /
+        (?:
+          (?<day>\d{1,2})\s+
+          (?<month_name>[[:word:]\p{Arabic}]+)\s+
+          (?<year>\d{4})
+          |
+          (?<month_name2>[[:word:]\p{Arabic}]+)\s+
+          (?<day2>\d{1,2})\s+
+          (?<year2>\d{4})
+        )
+        (?:.*?(?<time>\d{1,2}:\d{1,2}(?::\d{1,2})?))?
+      /x
+    }
+  ].freeze
+
+  class ParseError < StandardError; end
+
+  module_function
+
+  def parse(input)
+    raise ParseError, "Empty input" if input.nil? || input.strip.empty?
+
+    str = normalize(input)
+
+    COMMON_PATTERNS.each do |pattern|
+      match = str.match(pattern[:regex])
+      next unless match
+
+      year  = (match[:year] || match[:year2]).to_i
+      day   = (match[:day] || match[:day2]).to_i
+
+      month =
+        if match.names.include?("month")
+          match[:month].to_i
+        else
+          MONTHS[match[:month_name] || match[:month_name2]]
+        end
+
+      hour, min, sec = extract_time(match[:time])
+
+      validate!(year, month, day, hour, min, sec)
+
+      jdate = JalaliDate.new(year, month, day, hour, min, sec)
+      gdate = jdate.to_gregorian.to_datetime
+
+      return {
+        jalali: jdate,
+        gregorian: gdate,
+        components: {
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          min: min,
+          sec: sec
+        }
+      }
+    end
+
+    raise ParseError, "Unsupported Jalali date format: #{input}"
+  end
+
+  def normalize(str)
+    s = str.dup
+
+    # Persian/Arabic digits → English
+    s.tr!(PERSIAN_DIGITS, ENGLISH_DIGITS)
+    s.tr!(ARABIC_DIGITS, ENGLISH_DIGITS)
+
+    # Normalize Arabic chars
+    s.gsub!("ي", "ی")
+    s.gsub!("ك", "ک")
+
+    # Remove extra words
+    s.gsub!(/ساعت|در|،/, " ")
+
+    # Normalize whitespace
+    s.gsub!(/\s+/, " ")
+
+    s.strip
+  end
+
+  def extract_time(time_str)
+    return [0, 0, 0] unless time_str
+
+    parts = time_str.split(":").map(&:to_i)
+
+    [
+      parts[0] || 0,
+      parts[1] || 0,
+      parts[2] || 0
+    ]
+  end
+
+  def validate!(year, month, day, hour, min, sec)
+    raise ParseError, "Invalid year" unless year > 0
+    raise ParseError, "Invalid month" unless month.between?(1, 12)
+    raise ParseError, "Invalid day" unless day.between?(1, 31)
+    raise ParseError, "Invalid hour" unless hour.between?(0, 23)
+    raise ParseError, "Invalid minute" unless min.between?(0, 59)
+    raise ParseError, "Invalid second" unless sec.between?(0, 59)
+  end
+end

data/spec/jalali_date_spec.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JalaliDate do
+
+  it "should initialize with valid year,month,date values" do
+    jdate = JalaliDate.new(1388,11,22)
+    jdate.should be_instance_of(JalaliDate)
+  end
+
+  it "should raise error for invalid year,month,date combination on initialize" do
+    lambda { JalaliDate.new(1388,14,22) }.should raise_error(ArgumentError)  # invalid month
+    lambda { JalaliDate.new(1388,14,32) }.should raise_error(ArgumentError)  # invalid day
+    lambda { JalaliDate.new(1388,14,"22") }.should raise_error(ArgumentError)  # invalid type
+    lambda { JalaliDate.new(1388,14,22,11,0) }.should raise_error(ArgumentError)  # invalid arguments
+  end
+
+  it "should initialize with a ruby date object" do
+    jdate = JalaliDate.new(Date.today)
+    jdate.should be_instance_of(JalaliDate)
+  end
+
+  it "should populate attr_accessors for jalali year, month and date and attr_reader for gregorian year,month and date" do
+    jdate = JalaliDate.new(1388,11,22)
+    jdate.year.should eql(1388)
+    jdate.month.should eql(11)
+    jdate.day.should eql(22)
+    jdate.g_year.should eql(2010)
+    jdate.g_month.should eql(2)
+    jdate.g_day.should eql(11)
+  end
+
+  it "should return today, yesterday, and tomorrow date according to jalali calendar" do
+    allow(Date).to receive(:today).and_return Date.new(2010,1,1)
+    JalaliDate.today.should === JalaliDate.new(1388,10,11)
+    JalaliDate.yesterday.should === JalaliDate.new(1388,10,10)
+    JalaliDate.tomorrow.should === JalaliDate.new(1388,10,12)
+  end
+
+  it "should distinguish invalid jalali dates" do
+    JalaliDate.valid?(1388,13,11).should be_falsey
+    JalaliDate.valid?(-1388,11,11).should be_falsey
+    JalaliDate.valid?(1388,1,45).should be_falsey
+    JalaliDate.valid?(1388,12,30).should be_falsey
+    JalaliDate.valid?(1387,12,30).should be_truthy
+  end
+
+  it "should distinguish leap years" do
+    JalaliDate.leap?(1387).should be_truthy
+    JalaliDate.leap?(1388).should be_falsey
+  end
+
+  it "should convert to gregorian date correctly" do
+    jdate = JalaliDate.new(1388,10,11)
+    jdate.to_g.should == Date.new(2010,1,1)
+  end
+
+  it "should convert to string, array and hash correctly" do
+    jdate = JalaliDate.new(1388,10,11)
+    jdate.to_s.should === "1388/10/11"
+    jdate.to_a.should === [1388,10,11]
+    jdate.to_hash.should === {:year => 1388, :month => 10, :day => 11}
+  end
+
+  it "should be able to add and substract days from the currect jalai date object" do
+    jdate = JalaliDate.new(1388,10,11)
+    five_days_later = jdate + 5
+    twenty_days_ago = jdate - 20
+    five_days_later.should === JalaliDate.new(1388,10,16)
+    twenty_days_ago.should === JalaliDate.new(1388,9,21)
+  end
+
+  it "should be able to compare two jalali dates" do
+    jdate = JalaliDate.new(1388,10,11)
+    next_month_jdate = JalaliDate.new(1388,11,11)
+    next_month_jdate.<=>(jdate).should === 1
+    jdate.<=>(next_month_jdate).should === -1
+    jdate.<=>(jdate).should == 0
+  end
+
+  it "should now its next and previous dates" do
+    jdate = JalaliDate.new(1388,10,11)
+    jdate.next.should === JalaliDate.new(1388,10,12)
+    jdate.previous.should === JalaliDate.new(1388,10,10)
+  end
+
+  it "should be able to move the month forward and backward" do
+    jdate = JalaliDate.new(1388,10,11)
+    five_month_later = jdate >> 5
+    five_month_ago = jdate << 5
+    five_month_later.should === JalaliDate.new(1389,3,11)
+    five_month_ago.should === JalaliDate.new(1388,5,11)
+  end
+
+  it "should be able to cycle through dates in different ways, namely, step, upto and downto" do
+    jdate = JalaliDate.new(1388,10,10)
+
+    days_string = ""
+    jdate.step( jdate + 10 , 2) do |jd|
+      days_string += jd.day.to_s
+    end
+    days_string.should === "101214161820"
+
+    days_string = ""
+    jdate.upto(jdate+5) do |jd|
+      days_string += jd.day.to_s
+    end
+    days_string.should === "101112131415"
+
+    days_string = ""
+    jdate.downto(jdate-5) do |jd|
+      days_string += jd.day.to_s
+    end
+    days_string.should == "1098765"
+  end
+
+  it "should return a correct year day based on Jalali Calendar" do
+    JalaliDate.new(1388,1,1).yday.should === 1
+    JalaliDate.new(1388,12,29).yday.should === 365
+    JalaliDate.new(1387,12,30).yday.should === 366
+    JalaliDate.new(1388,9,17).yday.should === 263
+  end
+
+  it "should be able to print jalali date in different formats" do
+    JalaliDate.new(1388,1,7).strftime("%a %A %b %B %d %e %j %m %w %y %Y %% %x").should == "ج  جمعه فروردین Farvardin 07 7 7 1 5 88 1388 % 88/1/7"
+  end
+
+  it "should be intialize with a time object" do
+    time = Time.now
+    JalaliDate.new(time).hour.should == time.hour
+  end
+
+  it "should be able for format %H %I %M %p %S %X %Z correctly if initiallized with time" do
+    JalaliDate.new(1388,2,15,5,50,10).strftime("%H").should === "05"
+    JalaliDate.new(1388,2,15,18,50,10).strftime("%H %I").should === "18 06"
+    JalaliDate.new(1388,2,15,12,50,10).strftime("%H %I").should === "12 00"
+    JalaliDate.new(1388,2,15,12,50,10).strftime("%H %I %M %S").should === "12 00 50 10"
+    JalaliDate.new(1388,2,15,5,50,10).strftime("%p").should === "قبل از ظهر"
+    JalaliDate.new(1388,2,15,15,50,10).strftime("%p").should === "بعد از ظهر"
+    JalaliDate.new(1388,2,15,15,50,10).strftime("%X").should === "15:50:10"
+    JalaliDate.new(1388,2,15,15,50,10).strftime("%X").should === "15:50:10"
+    JalaliDate.new(1388,2,15,15,50,10,"CET",3600).strftime("%Z").should === "CET"
+    JalaliDate.new(1388,2,2,5,50,10).strftime("%n").should === "02"
+    JalaliDate.new(1388,2,2,5,50,10).strftime("%m").should === "2"
+    time = Time.now
+    JalaliDate.new(time).strftime("%Z").should == time.zone
+  end
+
+  it "should be able to parse different formats of jalali dates" do
+    JalaliDate.parse("1402/02/25").should == JalaliDate.new(1402,2,25)
+    JalaliDate.parse("۱۴۰۲-۰۲-۲۵ ۰۶:۰۱").should == JalaliDate.new(1402,2,25)
+    JalaliDate.parse("25 اردیبهشت 1402").should == JalaliDate.new(1402,2,25)
+    JalaliDate.parse("25 اردیبهشت 1402 ساعت 6:01:30").should == JalaliDate.new(1402,2,25)
+    JalaliDate.parse("1402.2.25").should == JalaliDate.new(1402,2,25)
+    JalaliDate.parse("1402/02/25T06:01:30").should == JalaliDate.new(1402,2,25)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'jalali_date'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: jalali-date
+version: !ruby/object:Gem::Version
+  version: 0.3.7
+platform: ruby
+authors:
+- Allen A. Bargi
+- Loqman Hakimi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+email: allen.bargi@gmail.com loqmanhakimi@gmail.com
+executables:
+- jcal
+- jdate
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- bin/jcal
+- bin/jdate
+- jalalidate.gemspec
+- lib/jalali_date.rb
+- lib/jalali_date/cli.rb
+- lib/jalali_date/version.rb
+- lib/jalali_date_parser.rb
+- spec/jalali_date_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/loqman/jalalidate
+licenses:
+- MIT
+metadata: {}
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: A library for working with Jalali Calendar (a.k.a Persian Calendar)
+test_files: []