para

use v6.d;
use Date::Calendar::Strftime:api<1>;
use Date::Calendar::FrenchRevolutionary::Names;
unit role Date::Calendar::FrenchRevolutionary::Common:ver<0.1.0>:auth<zef:jforget>:api<1>;

has Int $.year  where { $_ ≥ 1 };
has Int $.month where { 1 ≤ $_ ≤ 13 };
has Int $.day   where { 1 ≤ $_ ≤ 30 };
has Int $.daycount;
has Int $.daypart where { before-sunrise() ≤ $_ ≤ after-sunset() };
has Str $.locale is rw where { Date::Calendar::FrenchRevolutionary::Names::allowed-locale($_) } = 'fr';

method !check-build-args(Int $year, Int $month, Int $day, Str $locale, &vnd1-f) {

  unless 1 ≤ $month ≤ 13 {
    X::OutOfRange.new(:what<Month>, :got($month), :range<1..13>).throw;
  }

  if $month ≤ 12 {
    unless 1 ≤ $day ≤ 30 {
      X::OutOfRange.new(:what<Day>, :got($day), :range<1..30>).throw;
    }
  }

  else {
    # Checking the additional days (sans-culottides), within either the 1..5 range or the 1..6 range.
    my Int  $vnd1-before = vnd1-f($year + 1791);
    my Int  $vnd1-after  = vnd1-f($year + 1792);
    my Bool $is-leap     = False;

    # How does it work? We compute the September number of two successive "1 Vendémiaire"
    # dates. Then we compare the values and we check if the comparison is compatible with a
    # leap French Revolutionary year and with a leap Gregorian year.
    #
    # Examples
    #
    # French Rev year             3              4                5
    # Gregorian year before    1794           1795             1796
    # Gregorian year after     1795           1796             1797
    # $vnd1-before               22             23               22
    # $vnd1-after                23             22               22
    #
    # Check                 $v1-b < $v1-a  $v1-b > $v1-a   $v1-b == $v1-a
    # Duration between $v1-b and $v1-a
    # if normal greg year       366            364              365
    # if leap   greg year       367            365              366
    # if normal frv  year       365            365              365
    # if leap   frv  year       366            366              366
    #                             |              |                |
    # Conclusion                  |              |                `-- the Gregorian and French Revolutionary
    #                             |              |                    are both normal or they are both leap
    #                             |              `------------------- the Gregorian year is leap and the French
    #                             |                                   Revolutionary year is normal
    #                             `---------------------------------- the Gregorian year is normal and the French
    #                                                                 Revolutionary year is leap
    #
    # Remark: the Gregorian year checked for leapness / normality is the Gregorian year "after",
    # because the French Revolutionary includes the February month from the Greg year "after" but
    # not from the Greg year "before".

    if $vnd1-before < $vnd1-after {
      $is-leap = True;
    }
    elsif $vnd1-before == $vnd1-after {
      $is-leap = Date.new($year + 1792, 1, 1).is-leap-year;
    }

    if $is-leap {
      unless 1 ≤ $day ≤ 6 {
        X::OutOfRange.new(:what<Day>, :got($day), :range<1..6>).throw;
      }
    }
    else {
      unless 1 ≤ $day ≤ 5 {
        X::OutOfRange.new(:what<Day>, :got($day), :range<1..5>).throw;
      }
    }
  }
  unless Date::Calendar::FrenchRevolutionary::Names::allowed-locale($locale) {
    X::Invalid::Value.new(:method<BUILD>, :name<locale>, :value($locale)).throw;
  }
}

method !build-from-args(Int $year, Int $month, Int $day, Str $locale, Int $daypart) {
  $!year     = $year;
  $!month    = $month;
  $!day      = $day;
  $!locale   = $locale;
  $!daycount = $.daycount-from-elems;
  $!daypart  = $daypart;
}

method new-from-date($date) {
  $.new-from-daycount($date.daycount, daypart => $date.?daypart // daylight);
}

method elems-from-daycount(Int $count, $vnd1-f) {
  my Int $gr_year = floor($count/ 365) + 1860;
  my Int $vnd1_count = $count + 1;
  while $vnd1_count > $count {
    -- $gr_year;
    my Int  $fr_year = $gr_year - 1791;
    my Date $vnd1 .= new($gr_year, 9, $vnd1-f($gr_year));
    $vnd1_count = $vnd1.daycount;
  }
  my $year  = $gr_year - 1791;
  my $month = 1 + floor(($count - $vnd1_count) / 30);
  my $day   = 31 + $count - $vnd1_count - 30 × $month;
  return $year, $month, $day;
}
method daycount-from-elems {
  Date.new(year => $.year + 1791, month => 9, day => $.vnd1()).daycount
  + 30 × ($.month - 1)
  + $.day
  - 1;
}

method to-date($class = 'Date') {
  # See "Learning Perl 6" page 177
  my $d = ::($class).new-from-daycount($.daycount, daypart => $.daypart);
  return $d;
}

method gist {
  sprintf("%04d-%02d-%02d", $.year, $.month, $.day);
}

method day-of-year {
  $.day + 30 × ($.month - 1);
}

method décade-number {
  ($.day / 10).ceiling + 3 × ($.month - 1);
}

method day-of-décade {
  $.day % 10 || 10;
}

method month-name {
  Date::Calendar::FrenchRevolutionary::Names::month-name($.locale, $.month);
}

method month-abbr {
  Date::Calendar::FrenchRevolutionary::Names::month-abbr($.locale, $.month);
}

method day-name {
  Date::Calendar::FrenchRevolutionary::Names::day-name($.locale, $.day);
}

method day-abbr {
  Date::Calendar::FrenchRevolutionary::Names::day-abbr($.locale, $.day);
}

method feast {
  Date::Calendar::FrenchRevolutionary::Names::feast($.locale, $.month, $.day);
}

method feast-long {
  Date::Calendar::FrenchRevolutionary::Names::feast-long($.locale, $.month, $.day);
}

method feast-caps {
  Date::Calendar::FrenchRevolutionary::Names::feast-caps($.locale, $.month, $.day);
}
method year-roman {
  my $res = '';
  my $n = $.year;
  if 1 ≤ $n ≤ 3999 {
    for (                                       (2000, 'MM'), (1000, 'M'),
          (900, 'CM'), (500, 'D'), (400, 'CD'), ( 200, 'CC'), ( 100, 'C'),
          ( 90, 'XC'), ( 50, 'L'), ( 40, 'XL'), (  20, 'XX'), (  10, 'X'),
          (  9, 'IX'), (  5, 'V'), (  4, 'IV'), (   2, 'II'), (   1, 'I'),
          ) -> $node {
      my (Int $val,  $str) = $node;
      if $n ≥ $val {
        $n   -= $val;
        $res ~= $str;
      }
    }
  }
  else {
    $res = "$n";
  }
  $res;
}
method specific-format { %( Oj => { $.feast },
                           '*' => { $.feast },
                            Ej => { $.feast-long },
                            EJ => { $.feast-caps },
                            Ey => { $.year-roman.lc },
                            EY => { $.year-roman },
                             u => { $.day-of-décade },
                             V => { $.décade-number },
                           ) }



head

Date::Calendar::FrenchRevolutionary::Common - Common code for the three variants of Date::Calendar::FrenchRevolutionary


code

=begin code :lang<raku>

use Date::Calendar::FrenchRevolutionary;

=end code


Date::Calendar::FrenchRevolutionary is a module defining a role
which is shared by the three variants of the
Date::Calendar::FrenchRevolutionary class.


See the full documentation in the main module,
C<Date::Calendar::FrenchRevolutionary>.


Jean Forget <J2N-FORGET at orange dot fr>


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


root

Names

Astronomical

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Common

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Date::Calendar::FrenchRevolutionary v0.1.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation