zmanim 0.1.0

data/lib/zmanim/limudim/limud.rb

@@ -0,0 +1,42 @@
+module Zmanim::Limudim
+  class Limud
+    attr_reader :interval, :unit
+
+    def initialize(interval, unit)
+      @interval = interval
+      @unit = unit
+    end
+
+    def cycle
+      interval.cycle
+    end
+
+    def description
+      unit.to_s
+    end
+
+    def start_date
+      interval.start_date
+    end
+
+    def end_date
+      interval.end_date
+    end
+
+    def iteration
+      interval.iteration
+    end
+
+    def cycle_start_date
+      cycle.start_date
+    end
+
+    def cycle_end_date
+      cycle.end_date
+    end
+
+    def cycle_iteration
+      cycle.iteration
+    end
+  end
+end

data/lib/zmanim/limudim/limud_calculator.rb

@@ -0,0 +1,137 @@
+require 'zmanim/hebrew_calendar/jewish_date'
+
+module Zmanim::Limudim
+  module LimudCalculator
+    def limud(date)
+      jewish_date = jewish_date(date)
+      cycle = find_cycle(jewish_date)
+      return nil unless cycle
+      units = cycle_units_calculation.(cycle)
+      interval = cycle.first_interval(interval_end_calculation)
+      while !jewish_date.between?(interval.start_date, interval.end_date) do
+        interval = interval.next(interval_end_calculation)
+        while !jewish_date.between?(interval.start_date, interval.end_date) && skip_interval?(interval)
+          interval = interval.skip(interval_end_calculation)
+        end
+      end
+      unit = unit_for_interval(units, interval)
+      Zmanim::Limudim::Limud.new(interval, unit)
+    end
+
+    # Jewish Date on which the first cycle starts (if not perpetual)
+    def initial_cycle_date
+      nil
+    end
+
+    # Anchor on which a cycle resets (where relevant)
+    # e.g. for Parsha this would be a Day-of-Year anchor
+    def perpetual_cycle_anchor
+      nil
+    end
+
+    # Number of units to apply over an iteration
+    def unit_step
+      1
+    end
+
+    # Are units components of some larger grouping? (e.g. pages or mishnayos)
+    def tiered_units?
+      true
+    end
+
+    # For tiered units, this would be a Hash in the format:
+    #   `{some_name: last_page, ...}`
+    # or:
+    #   `{maseches: {perek_number => mishnayos, ...}, ...}`.
+    #
+    # For simple units, use an Array in the format:
+    #   `[:some_name, ...]`
+    def default_units
+      {}
+    end
+
+    # Set if units are applied fractionally (indicated by a fractional unit_step).
+    # For example, an amud yomi calculator would set `%w(a b)`
+    def fractional_units
+      nil
+    end
+
+    # Change this when using page numbers that do not generally start from one.
+    # (e.g. Talmud Bavli pages start from 2)
+    def default_starting_page
+      1
+    end
+
+    def starting_page(units, unit_name)
+      default_starting_page
+    end
+
+    def cycle_end_calculation
+      ->(start_date, iteration){ start_date }
+    end
+
+    def interval_end_calculation
+      ->(cycle, start_date){ start_date }
+    end
+
+    def cycle_units_calculation
+      ->(cycle){ default_units }
+    end
+
+    def unit_for_interval(units, interval)
+      return tiered_units_for_interval(units, interval) if tiered_units?
+      Unit.new(*units[interval.iteration-1])
+    end
+
+    def skip_interval?(interval)
+      false
+    end
+
+    def tiered_units_for_interval(units, interval)
+      iteration = interval.iteration
+      offset = ((iteration - 1) * unit_step) + 1
+      offset2 = (offset - 1) + unit_step if unit_step > 1
+      offsets = [offset, offset2].compact
+      targets = offsets.map{|o| [o, []]}
+      results = find_offset_units(units, targets)
+      return nil unless results.map(&:first).uniq == [0]
+      paths = results.map(&:last)
+      Unit.new(*paths)
+    end
+
+    def find_offset_units(units, targets)
+      units.reduce(targets) do |t, (name, attributes)|
+        if attributes.is_a?(Numeric)
+          start = starting_page(units, name)
+          length = (attributes - start) + 1
+          t.select{|o, p| o == 0} + t.reject{|o,p| o == 0}.map do |o, p|
+            o <= length ?
+                 [0, p + [name, (start + o) - 1]] :
+                 [o - length, p]
+          end
+        else
+          t.select{|o, p| o == 0} +
+          find_offset_units(attributes, t.reject{|o,p| o == 0}.map{|o, p| [o, p + [name]]}).map do |o, p|
+            o == 0 ? [o, p] : [o, p[0..-2]]
+          end
+        end
+      end
+    end
+
+    def find_cycle(date)
+      if initial_cycle_date
+        Cycle.from_cycle_initiation(initial_cycle_date, cycle_end_calculation, date)
+      elsif perpetual_cycle_anchor
+        Cycle.from_perpetual_anchor(perpetual_cycle_anchor, cycle_end_calculation, date)
+      else
+        raise 'Cycle cannot be determined without an initial date or an anchor'
+      end
+    end
+
+    protected
+
+    def jewish_date(date)
+      date.respond_to?(:jewish_year) ? date : Zmanim::HebrewCalendar::JewishDate.new(date)
+    end
+  end
+end

data/lib/zmanim/limudim/limudim_formatter.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+module Zmanim::Limudim
+  class LimudimFormatter
+    include Zmanim::Util::TextHelper
+    include Zmanim::Util::HebrewNumericFormatter
+
+    attr_accessor :hebrew_format
+    PARSHIYOS = {
+        bereishis:       'בראשית',
+        noach:           'נח',
+        lech_lecha:      'לך לך',
+        vayeira:         'וירא',
+        chayei_sarah:    'חיי שרה',
+        toldos:          'תולדות',
+        vayeitzei:       'ויצא',
+        vayishlach:      'וישלח',
+        vayeishev:       'וישב',
+        mikeitz:         'מקץ',
+        vayigash:        'ויגש',
+        vayechi:         'ויחי',
+        shemos:          'שמות',
+        vaeirah:         'וארא',
+        bo:              'בא',
+        beshalach:       'בשלח',
+        yisro:           'יתרו',
+        mishpatim:       'משפטים',
+        terumah:         'תרומה',
+        tetzaveh:        'תצוה',
+        ki_sisa:         'כי תשא',
+        vayakheil:       'ויקהל',
+        pekudei:         'פקודי',
+        vayikra:         'ויקרא',
+        tzav:            'צו',
+        shemini:         'שמיני',
+        tazria:          'תזריע',
+        metzora:         'מצורע',
+        acharei:         'אחרי מות',
+        kedoshim:        'קדושים',
+        emor:            'אמר',
+        behar:           'בהר',
+        bechukosai:      'בחוקתי',
+        bamidbar:        'במדבר',
+        naso:            'נשא',
+        behaalosecha:    'בהעלותך',
+        shelach:         'שלח',
+        korach:          'קרח',
+        chukas:          'חקת',
+        balak:           'בלק',
+        pinchas:         'פינחס',
+        matos:           'מטות',
+        masei:           'מסעי',
+        devarim:         'דברים',
+        vaeschanan:      'ואתחנן',
+        eikev:           'עקב',
+        reei:            'ראה',
+        shoftim:         'שופטים',
+        ki_seitzei:      'כי תצא',
+        ki_savo:         'כי תבא',
+        nitzavim:        'נצבים',
+        vayeilech:       'וילך',
+        haazinu:         'האזינו',
+        vezos_haberacha: 'וזאת הברכה',
+    }
+
+    MASECHTOS = {
+        berachos: 'ברכות',
+        peah: 'פאה',
+        demai: 'דמאי',
+        kilayim: 'כלאים',
+        sheviis: 'שביעית',
+        terumos: 'תרומות',
+        maasros: 'מעשרות',
+        maaser_sheni: 'מעזר שני',
+        chalah: 'חלה',
+        orlah: 'ערלה',
+        bikurim: 'בכורים',
+        shabbos: 'שבת',
+        eruvin: 'ערובין',
+        pesachim: 'פסחים',
+        shekalim: 'שקלים',
+        yoma: 'יומא',
+        sukkah: 'סוכה',
+        beitzah: 'ביצה',
+        rosh_hashanah: 'ראש השנה',
+        taanis: 'תענית',
+        megillah: 'מגילה',
+        moed_katan: 'מועד קטן',
+        chagigah: 'חגיגה',
+        yevamos: 'יבמות',
+        kesubos: 'כתובות',
+        nedarim: 'נדרים',
+        nazir: 'נזיר',
+        sotah: 'סוטה',
+        gitin: 'גיטין',
+        kiddushin: 'קידושין',
+        bava_kamma: 'בבא קמא',
+        bava_metzia: 'בבא מציעא',
+        bava_basra: 'בבא בתרא',
+        sanhedrin: 'סנהדרין',
+        makkos: 'מכות',
+        shevuos: 'שבועות',
+        eduyos: 'עדיות',
+        avodah_zarah: 'עבודה זרה',
+        avos: 'אבות',
+        horiyos: 'הוריות',
+        zevachim: 'זבחים',
+        menachos: 'מנחות',
+        chullin: 'חולין',
+        bechoros: 'בכורות',
+        arachin: 'ערכין',
+        temurah: 'תמורה',
+        kerisos: 'כריתות',
+        meilah: 'מעילה',
+        tamid: 'תמיד',
+        midos: 'מידות',
+        kinnim: 'קינים',
+        keilim: 'כלים',
+        ohalos: 'אוהלות',
+        negaim: 'נגעים',
+        parah: 'פרה',
+        taharos: 'טהרות',
+        mikvaos: 'מקואות',
+        niddah: 'נדה',
+        machshirim: 'מכשירין',
+        zavim: 'זבים',
+        tevul_yom: 'טבול יום',
+        yadayim: 'ידים',
+        uktzin: 'עוקצין',
+        no_daf_today: 'אין דף היום',
+    }
+
+    def initialize
+      super
+      @use_geresh_gershayim = false
+    end
+
+    def format_parsha(limud)
+      prefix = hebrew_format ? 'פרשת ' : 'Parshas '
+      prefix + limud.unit.render do |parsha|
+        hebrew_format ? PARSHIYOS[parsha] : titleize(parsha)
+      end
+    end
+
+    def format_talmudic(limud)
+      return '' unless unit = (limud && limud.unit)
+      unit.render do |e|
+        if e.is_a?(Numeric)
+          format_number(e)
+        elsif hebrew_format
+          MASECHTOS[e]
+        else
+          titleize(e)
+        end
+      end
+    end
+
+    def format_tehillim(limud)
+      prefix = hebrew_format ? 'תהלים ' : 'Tehillim '
+      prefix + limud.unit.render {|e| format_number(e) }
+    end
+
+    private
+
+    def format_number(number)
+      hebrew_format ? format_hebrew_number(number) : number
+    end
+  end
+end

data/lib/zmanim/limudim/unit.rb

@@ -0,0 +1,53 @@
+module Zmanim::Limudim
+  class Unit
+    attr_reader :components
+    def initialize(*components)
+      @components = components
+    end
+
+    def to_s
+      render{|value| value }
+    end
+
+    def render
+      primary, secondary = components.map do |component|
+        Array(component).map{|v| yield v}
+      end
+      render_with_root(primary) + render_secondary(secondary, primary)
+    end
+
+    private
+
+    def render_with_root(component)
+      root, extension = component.first, component[1..-1]
+      return root.to_s if extension.length == 0
+      "#{root} #{render_extension(extension)}"
+    end
+
+    def render_extension(extension)
+      extension.join(':')
+    end
+
+    def render_secondary(second_component, first_component)
+      if second_component.nil?
+        return ''
+      elsif second_component.first != first_component.first
+        ' - ' + render_with_root(second_component)
+      elsif diff = render_difference(second_component, first_component)
+        '-' + diff
+      else
+        ''
+      end
+    end
+
+    def render_difference(rendering, comparing)
+      if rendering.length == 0
+        return nil
+      elsif rendering.first != comparing.first
+        render_extension(rendering)
+      else
+        render_difference(rendering[1..-1], comparing[1..-1])
+      end
+    end
+  end
+end

data/lib/zmanim/util/astronomical_calculations.rb

@@ -0,0 +1,34 @@
+require_relative 'math_helper'
+
+module Zmanim::Util
+  module AstronomicalCalculations
+    using Zmanim::Util::MathHelper
+
+    GEOMETRIC_ZENITH = 90.0
+
+    attr_writer :earth_radius,
+                :refraction,
+                :solar_radius
+
+    def refraction
+      @refraction ||= 34 / 60.0
+    end
+
+    def solar_radius
+      @solar_radius ||= 16 / 60.0
+    end
+
+    def earth_radius
+      @earth_radius ||= 6356.9  # km
+    end
+
+    def elevation_adjustment(elevation)
+      Math.acos(earth_radius / (earth_radius + (elevation / 1000.0))).to_degrees
+    end
+
+    def adjusted_zenith(zenith, elevation)
+      return zenith unless zenith == GEOMETRIC_ZENITH  #only adjust for exact sunrise or sunset
+      zenith + solar_radius + refraction + elevation_adjustment(elevation)
+    end
+  end
+end

data/lib/zmanim/util/geo_location.rb

@@ -0,0 +1,116 @@
+module Zmanim::Util
+  class GeoLocation
+    attr_reader   :elevation,
+                  :latitude,
+                  :location_name,
+                  :longitude,
+                  :time_zone
+
+    def initialize(name, latitude, longitude, time_zone, elevation:nil)
+      self.location_name = name
+      self.latitude = latitude
+      self.longitude = longitude
+      self.time_zone = time_zone
+      self.elevation = elevation
+    end
+
+    def self.GMT
+      new('Greenwich, England', 51.4772, 0, 'GMT')
+    end
+
+    def latitude=(args)
+      if args.respond_to?(:size) && args.size == 4
+        degrees, minutes, seconds, direction = *args
+        temp = degrees + ((minutes + (seconds / 60.0)) / 60.0)
+        raise ArgumentError unless %w{S N}.include? direction
+        raise ArgumentError unless temp >= 0
+        temp *= -1 if direction == 'S'
+        self.latitude = temp
+      else
+        raise ArgumentError unless (-90..90).include?(args)
+        @latitude = args
+      end
+    end
+
+    def longitude=(args)
+      if args.respond_to?(:size) && args.size == 4
+        degrees, minutes, seconds, direction = *args
+        temp = degrees + ((minutes + (seconds / 60.0)) / 60.0)
+        raise ArgumentError unless %w{W E}.include? direction
+        raise ArgumentError unless temp >= 0
+        temp *= -1 if direction == 'W'
+        self.longitude = temp
+      else
+        raise ArgumentError unless (-180..180).include?(args)
+        @longitude = args
+      end
+    end
+
+    def elevation=(e)
+      e ||= 0
+      raise ArgumentError unless e >= 0
+      @elevation = e
+    end
+
+    def location_name=(name)
+      @location_name = name
+    end
+
+    def time_zone=(tz)
+      tz = TZInfo::Timezone.get(tz) if tz.is_a?(String)
+      raise ArgumentError unless tz.is_a?(TZInfo::Timezone)
+      @time_zone = tz
+    end
+
+    # Number of Days to adjust due to antimeridian crossover
+    #
+    # The actual Time Zone offset may deviate from the expected offset based on the longitude
+    # But since the 'absolute time' calculations are always based on longitudinal offset from UTC
+    # for a given date, the date is presumed to only increase East of the Prime Meridian, and to
+    # only decrease West of it.
+    # For Time Zones that cross the antimeridian, the date will be artificially adjusted before calculation
+    # to conform with this presumption.
+    #
+    # For example, Samoa (located around 172W) uses a local offset of +14:00.  When asking to calculate for
+    # 2017-03-15, the calculator should operate using 2017-03-14 since the expected zone is -11.  After
+    # determining the UTC time, the local offset of +14:00 should be applied to bring the date back to 2017-03-15.
+    def antimeridian_adjustment
+      local_hours_offset = local_mean_time_offset / Zmanim::AstronomicalCalendar::HOUR_MILLIS.to_f
+      if local_hours_offset >= 20
+        1
+      elsif local_hours_offset <= -20
+        -1
+      else
+        0
+      end
+    end
+
+    # Local Mean Time offset for the expected time zone (in ms).
+    #
+    # The offset is the difference between Local Mean Time at the given
+    # longitude and Standard Time in effect for the given time zone.
+    def local_mean_time_offset
+      (longitude * 4 * Zmanim::AstronomicalCalendar::MINUTE_MILLIS) - standard_time_offset
+    end
+
+    # Standard Time offset from UTC based on the provided Time Zone (in ms).
+    #
+    # This will ignore DST transformations.
+    def standard_time_offset
+      time_zone.current_period.utc_offset * 1000
+    end
+
+    # Time Zone offset from UTC at a given point in time (in ms).
+    #
+    # This will take into account any DST transformation in effect
+    # for the given Time Zone at the given time
+    def time_zone_offset_at(utc_time)
+      time_zone.period_for_utc(utc_time).utc_total_offset * 1000
+    end
+
+    def clone
+      self.class.new(location_name.dup, latitude, longitude, time_zone.dup, elevation: elevation)
+    end
+
+  end
+end