RubySunrise 0.2 → 0.3

data/lib/solareventcalculator.rb

@@ -128,77 +128,85 @@ class SolarEventCalculator
   end
 
   def compute_utc_civil_sunrise
-    compute_utc_solar_event(96, true)
+    convert_to_datetime(compute_utc_solar_event(96, true))
   end
 
   def compute_utc_civil_sunset
-    compute_utc_solar_event(96, false)
+    convert_to_datetime(compute_utc_solar_event(96, false))
   end
 
   def compute_utc_official_sunrise
-    compute_utc_solar_event(90.8333, true)
+    convert_to_datetime(compute_utc_solar_event(90.8333, true))
   end
 
   def compute_utc_official_sunset
-    compute_utc_solar_event(90.8333, false)
+    convert_to_datetime(compute_utc_solar_event(90.8333, false))
   end
 
   def compute_utc_nautical_sunrise
-    compute_utc_solar_event(102, true)
+    convert_to_datetime(compute_utc_solar_event(102, true))
   end
 
   def compute_utc_nautical_sunset
-    compute_utc_solar_event(102, false)
+    convert_to_datetime(compute_utc_solar_event(102, false))
   end
 
   def compute_utc_astronomical_sunrise
-    compute_utc_solar_event(108, true)
+    convert_to_datetime(compute_utc_solar_event(108, true))
   end
 
   def compute_utc_astronomical_sunset
-    compute_utc_solar_event(108, false)
+    convert_to_datetime(compute_utc_solar_event(108, false))
+  end
+
+  def convert_to_datetime(time)
+    DateTime.parse("#{@date.strftime}T#{time.hour}:#{time.min}:00+0000") unless time == nil
   end
 
   def compute_civil_sunrise(timezone)
-    put_in_timezone(compute_utc_civil_sunrise, timezone)
+    put_in_timezone(compute_utc_solar_event(96, true), timezone)
   end
 
   def compute_civil_sunset(timezone)
-    put_in_timezone(compute_utc_civil_sunset, timezone)
+    put_in_timezone(compute_utc_solar_event(96, false), timezone)
   end
 
   def compute_official_sunrise(timezone)
-    put_in_timezone(compute_utc_official_sunrise, timezone)
+    put_in_timezone(compute_utc_solar_event(90.8333, true), timezone)
   end
 
   def compute_official_sunset(timezone)
-    put_in_timezone(compute_utc_official_sunset, timezone)
+    put_in_timezone(compute_utc_solar_event(90.8333, false), timezone)
   end
 
   def compute_nautical_sunrise(timezone)
-    put_in_timezone(compute_utc_nautical_sunrise, timezone)
+    put_in_timezone(compute_utc_solar_event(102, true), timezone)
   end
 
   def compute_nautical_sunset(timezone)
-    put_in_timezone(compute_utc_nautical_sunset, timezone)
+    put_in_timezone(compute_utc_solar_event(102, false), timezone)
   end
 
   def compute_astronomical_sunrise(timezone)
-    put_in_timezone(compute_utc_astronomical_sunrise, timezone)
+    put_in_timezone(compute_utc_solar_event(108, true), timezone)
   end
 
   def compute_astronomical_sunset(timezone)
-    put_in_timezone(compute_utc_astronomical_sunset, timezone)
+    put_in_timezone(compute_utc_solar_event(108, false), timezone)
   end
 
   def put_in_timezone(utcTime, timezone)
     tz = TZInfo::Timezone.get(timezone)
-    noonUTC = Time.gm(@date.year, @date.mon, @date.mday, 12, 0)
-    noonLocal = tz.utc_to_local(noonUTC)
-    offset = noonLocal - noonUTC
-
+    # puts "UTCTime #{utcTime}"
     local = utcTime + get_utc_offset(timezone)
-    Time.parse("#{@date.strftime('%a %b %d')} #{local.strftime(' %H:%M:%S')} #{offset} #{@date.year}")
+    # puts "LocalTime #{local}"
+
+    offset = (get_utc_offset(timezone) / 60 / 60).to_i
+    offset = (offset > 0) ? "+" + offset.to_s : offset.to_s
+
+    timeInZone = DateTime.parse("#{@date.strftime}T#{local.strftime('%H:%M:%S')}#{offset}")
+    # puts "CALC:timeInZone #{timeInZone}"
+    timeInZone
   end
 
   def get_utc_offset(timezone)

data/rubysunrise.gemspec

@@ -1,12 +1,13 @@
 spec = Gem::Specification.new do | s |
   s.name = "RubySunrise"
-  s.version = "0.2"
+  s.version = "0.3"
   s.author = "Mike Reedell / LuckyCatLabs"
-  s.email = "mike@luckycatlabs.com"
-  s.homepage = "http://www.luckycatlabs.com"
+  s.email = "mike@reedell.com"
+  s.homepage = "http://www.mikereedell.com"
   s.platform = Gem::Platform::RUBY
   s.summary = "Calculate the sunrise/sunset given lat/long coordinates and the date.  Computes civil, official, nautical, and astronomical sunrise/sunset."
   s.files = ["rubysunrise.gemspec"] + Dir.glob("lib/**/*")
   s.test_files = Dir.glob("{test}/**/*test.rb")
   s.has_rdoc = false
+  s.add_runtime_dependency "tzinfo"
 end

data/test/bulkdatatest.rb

@@ -3,8 +3,26 @@ require '../lib/solareventcalculator'
 describe SolarEventCalculator, "Test the sunset algorithm" do
 
   it "returns correct sunrise/sunset data over a year" do
-    dataFile = File.open("39_9937N-75_7850W#America-New_York.txt", 'r')
-    tz = TZInfo::Timezone.get("America/New_York")
+    Dir.glob("*.txt") do | dataFileName |
+    puts dataFileName
+
+    nameParts = dataFileName.split('#')
+    timeZone = nameParts[1].split('.')[0].sub!('-', '/')
+    latString = nameParts[0].split('-')[0].sub!('_', '.')
+    longString = nameParts[0].split('-')[1].sub!('_', '.')
+
+    latitude = BigDecimal.new(latString.chop)
+    longitude = BigDecimal.new(longString.chop)
+    if latString.end_with?('S')
+      latitude = BigDecimal.new("0") - latitude
+    end
+
+    if longString.end_with?('W')
+      longitude = BigDecimal.new("0") - longitude
+    end
+
+    tz = TZInfo::Timezone.get(timeZone)
+    dataFile = File.open(dataFileName, 'r')
 
     dataFile.readlines.each do |dataLine|
       parts = dataLine.split(',')
@@ -12,47 +30,69 @@ describe SolarEventCalculator, "Test the sunset algorithm" do
       calc = SolarEventCalculator.new(date, BigDecimal.new("39.9937"), BigDecimal.new("-75.7850"))
 
       time = parts[0].split(':')
-      expectedAstronomicalRise = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_astronomical_sunrise("America/New_York").should be_close_to(expectedAstronomicalRise)
+      expectedAstronomicalRise = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_astronomical_sunrise(timeZone).should be_close_to(expectedAstronomicalRise, "Astronomical Rise")
 
       time = parts[1].split(':')
-      expectedNauticalRise = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_nautical_sunrise("America/New_York").should be_close_to(expectedNauticalRise)
+      expectedNauticalRise = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_nautical_sunrise(timeZone).should be_close_to(expectedNauticalRise, "Nautical Rise")
 
       time = parts[2].split(':')
-      expectedCivilRise = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_civil_sunrise("America/New_York").should be_close_to(expectedCivilRise.getlocal)
+      expectedCivilRise = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_civil_sunrise(timeZone).should be_close_to(expectedCivilRise, "Civil Rise")
 
       time = parts[3].split(':')
-      expectedOfficialRise = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_official_sunrise("America/New_York").should be_close_to(expectedOfficialRise.getlocal)
+      expectedOfficialRise = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_official_sunrise(timeZone).should be_close_to(expectedOfficialRise, "Official Rise")
 
       time = parts[4].split(':')
-      expectedOfficialSet = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_official_sunset("America/New_York").should be_close_to(expectedOfficialSet)
+      expectedOfficialSet = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_official_sunset(timeZone).should be_close_to(expectedOfficialSet, "Official Set")
 
       time = parts[5].split(':')
-      expectedCivilSet = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_civil_sunset("America/New_York").should be_close_to(expectedCivilSet)
+      expectedCivilSet = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_civil_sunset(timeZone).should be_close_to(expectedCivilSet, "Civil Set")
 
       time = parts[6].split(':')
-      expectedNauticalSet = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_nautical_sunset("America/New_York").should be_close_to(expectedNauticalSet)
+      expectedNauticalSet = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_nautical_sunset(timeZone).should be_close_to(expectedNauticalSet, "Nautical Set")
 
       time = parts[7].split(':')
-      expectedAstronomicalSet = Time.local(date.year, date.mon, date.mday, time[0], time[1])
-      calc.compute_astronomical_sunset("America/New_York").should be_close_to(expectedAstronomicalSet)
+      expectedAstronomicalSet = put_in_timezone(date, time[0], time[1], timeZone)
+      calc.compute_astronomical_sunset(timeZone).should be_close_to(expectedAstronomicalSet, "Astronomical Set")
+    end
     end
   end
 end
 
-Spec::Matchers.define :be_close_to do |expected|
+def put_in_timezone(date, hours, minutes, timezone)
+  if hours.to_i == 99
+    return nil
+  end
+  offset = get_utc_offset(date, timezone)
+
+  timeInZone = DateTime.parse("#{date.strftime}T#{hours}:#{minutes}:00#{offset}")
+  timeInZone
+end
+
+def get_utc_offset(date, timezone)
+  tz = TZInfo::Timezone.get(timezone)
+  noonUTC = Time.utc(date.year,date.mon, date.mday, 12, 0)
+  offset = ((tz.utc_to_local(noonUTC) - noonUTC) / 60 / 60).to_i
+  offset = (offset  > 0) ? "+" + offset.to_s : offset.to_s
+end
+
+Spec::Matchers.define :be_close_to do |expected, type|
   match do |actual|
-    (expected - 61) < actual && actual < (expected + 61)
+    if expected != nil && actual != nil
+      (expected - 61) < actual && actual < (expected + 61)
+    else
+      expected == nil && actual == nil
+    end
   end
 
   failure_message_for_should do |actual|
-    " actual #{actual} is outside +-1 minute of expected #{expected}"
+    " actual #{type} #{actual} is outside +-1 minute of expected  #{type} #{expected}"
   end
 
   failure_message_for_should_not do |actual|

data/test/sunrisetest.rb

@@ -55,36 +55,36 @@ describe SolarEventCalculator, "test the math for home" do
     @calc.compute_local_mean_time(trueLong, longHour, t, localHour).should eql(BigDecimal.new("11.0818"))
   end
 
-  it "returns correct civil sunrise time" do
-    @calc.compute_utc_civil_sunrise.should eql(Time.gm(@date.year, @date.mon, @date.mday, 11, 4))
+  it "returns correct UTC civil sunrise time" do
+    @calc.compute_utc_civil_sunrise.should eql(DateTime.parse("#{@date.strftime}T11:04:00-00:00"))
   end
 
-  it "returns correct official sunrise time" do
-    @calc.compute_utc_official_sunrise.should eql(Time.gm(@date.year, @date.mon, @date.mday, 11, 33))
+  it "returns correct UTC official sunrise time" do
+    @calc.compute_utc_official_sunrise.should eql(DateTime.parse("#{@date.strftime}T11:33:00-00:00"))
   end
 
-  it "returns correct nautical sunrise time" do
-    @calc.compute_utc_nautical_sunrise.should eql(Time.gm(@date.year, @date.mon, @date.mday, 10, 32))
+  it "returns correct UTC nautical sunrise time" do
+    @calc.compute_utc_nautical_sunrise.should eql(DateTime.parse("#{@date.strftime}T10:32:00-00:00"))
   end
 
-  it "returns correct astronomical sunrise time" do
-    @calc.compute_utc_astronomical_sunrise.should eql(Time.gm(@date.year, @date.mon, @date.mday, 10, 1))
+  it "returns correct UTC astronomical sunrise time" do
+    @calc.compute_utc_astronomical_sunrise.should eql(DateTime.parse("#{@date.strftime}T10:01:00-00:00"))
   end
 
   it "returns correct 'America/New_York' official sunrise time" do
-    @calc.compute_official_sunrise('America/New_York').should eql(Time.local(@date.year, @date.mon, @date.mday, 7, 33))
+    @calc.compute_official_sunrise('America/New_York').should eql(DateTime.parse("#{@date.strftime}T07:33:00-04:00"))
   end
 
   it "returns correct 'America/New_York' civil sunrise time" do
-    @calc.compute_civil_sunrise('America/New_York').should eql(Time.local(@date.year, @date.mon, @date.mday, 7, 4))
+    @calc.compute_civil_sunrise('America/New_York').should eql(DateTime.parse("#{@date.strftime}T07:04:00-04:00"))
   end
 
   it "returns correct 'America/New_York' nautical sunrise time" do
-    @calc.compute_nautical_sunrise('America/New_York').should eql(Time.local(@date.year, @date.mon, @date.mday, 6, 32))
+    @calc.compute_nautical_sunrise('America/New_York').should eql(DateTime.parse("#{@date.strftime}T06:32:00-04:00"))
   end
 
   it "returns correct 'America/New_York' astronomical sunrise time" do
-    @calc.compute_astronomical_sunrise('America/New_York').should eql(Time.local(@date.year, @date.mon, @date.mday, 6, 1))
+    @calc.compute_astronomical_sunrise('America/New_York').should eql(DateTime.parse("#{@date.strftime}T06:01:00-04:00"))
   end
 end
 

data/test/sunsettest.rb

@@ -56,37 +56,37 @@ describe SolarEventCalculator, "Test the sunset algorithm" do
   end
 
   it "returns correct UTC civil sunset time" do
-    @calc.compute_utc_civil_sunset.should eql(Time.gm(@date.year, @date.mon, @date.mday, 22, 28))
+    @calc.compute_utc_civil_sunset.should eql(DateTime.parse("#{@date.strftime}T22:28:00-00:00"))
   end
 
   it "returns correct UTC official sunset time" do
-    @calc.compute_utc_official_sunset.should eql(Time.gm(@date.year, @date.mon, @date.mday, 21, 59))
+    @calc.compute_utc_official_sunset.should eql(DateTime.parse("#{@date.strftime}T21:59:00-00:00"))
   end
 
   it "returns correct UTC nautical sunset time" do
-    @calc.compute_utc_nautical_sunset.should eql(Time.gm(@date.year, @date.mon, @date.mday, 23, 0))
+    @calc.compute_utc_nautical_sunset.should eql(DateTime.parse("#{@date.strftime}T23:00:00-00:00"))
   end
 
   it "returns correct UTC astronomical sunset time" do
-    @calc.compute_utc_astronomical_sunset.should eql(Time.gm(@date.year, @date.mon, @date.mday, 23, 31))
+    @calc.compute_utc_astronomical_sunset.should eql(DateTime.parse("#{@date.strftime}T23:31:00-00:00"))
   end
 
   it "returns correct 'America/New_York' offical sunset time" do
-    @calc.compute_official_sunset("America/New_York").should eql(Time.local(@date.year, @date.mon, @date.mday, 17, 59))
+    @calc.compute_official_sunset("America/New_York").should eql(DateTime.parse("#{@date.strftime}T17:59:00-04:00"))
   end
 
   it "returns correct 'America/New_York' civil sunset time" do
-    @calc.compute_civil_sunset("America/New_York").should eql(Time.local(@date.year, @date.mon, @date.mday, 18, 28))
+    @calc.compute_civil_sunset("America/New_York").should eql(DateTime.parse("#{@date.strftime}T18:28:00-04:00"))
   end
 
   it "returns correct 'America/New_York' nautical sunset time" do
-    @calc.compute_nautical_sunset("America/New_York").should eql(Time.local(@date.year, @date.mon, @date.mday, 19, 00))
+    @calc.compute_nautical_sunset("America/New_York").should eql(DateTime.parse("#{@date.strftime}T19:00:00-04:00"))
   end
 
   it "returns correct 'America/New_York' astronomical sunset time" do
-    @calc.compute_astronomical_sunset("America/New_York").should eql(Time.local(@date.year, @date.mon, @date.mday, 19, 31))
+    @calc.compute_astronomical_sunset("America/New_York").should eql(DateTime.parse("#{@date.strftime}T19:31:00-04:00"))
   end
-  # 18:00,18:28,19:00,19:32
+  # DateTime.parse("#{@date.strftime}T06:32:00-04:00")
 end
 
 describe SolarEventCalculator, "test the math for areas where the sun doesn't set" do

data/test/test.rb

@@ -0,0 +1,11 @@
+require 'date'
+require '../lib/solareventcalculator'
+
+date = Date.parse('2008-11-01')
+calc = SolarEventCalculator.new(date, BigDecimal.new("39.9537"), BigDecimal.new("-75.7850"))
+
+utcOfficialSunrise = calc.compute_utc_official_sunrise
+localOfficialSunrise = calc.compute_official_sunrise('America/New_York')
+
+puts "utcOfficialSunrise #{utcOfficialSunrise}"
+puts "localOfficialSunrise #{localOfficialSunrise}"

metadata

@@ -1,64 +1,66 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: RubySunrise
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  version: "0.2"
+version: !ruby/object:Gem::Version
+  version: '0.3'
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Mike Reedell / LuckyCatLabs
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-03-13 00:00:00 -05:00
-default_executable: 
-dependencies: []
-
+date: 2012-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: &70286578500580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70286578500580
 description: 
-email: mike@luckycatlabs.com
+email: mike@reedell.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - rubysunrise.gemspec
 - lib/solareventcalculator.rb
-has_rdoc: true
-homepage: http://www.luckycatlabs.com
+- test/bulkdatatest.rb
+- test/sunrisetest.rb
+- test/sunsettest.rb
+- test/test.rb
+homepage: http://www.mikereedell.com
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
-summary: Calculate the sunrise/sunset given lat/long coordinates and the date.  Computes civil, official, nautical, and astronomical sunrise/sunset.
-test_files: 
+summary: Calculate the sunrise/sunset given lat/long coordinates and the date.  Computes
+  civil, official, nautical, and astronomical sunrise/sunset.
+test_files:
 - test/bulkdatatest.rb
 - test/sunrisetest.rb
 - test/sunsettest.rb
+- test/test.rb