astrolith 0.1.0

data/lib/ruby_chart_engine/calculations/houses.rb

@@ -0,0 +1,97 @@
+module RubyChartEngine
+  module Calculations
+    class Houses
+      attr_reader :julian_day, :latitude, :longitude, :house_system
+
+      def initialize(julian_day:, latitude:, longitude:, house_system: :placidus)
+        @julian_day = julian_day
+        @latitude = latitude
+        @longitude = longitude
+        @house_system = house_system
+      end
+
+      # Calculate house cusps and angles
+      def calculate
+        system_code = HOUSE_SYSTEMS[house_system] || 'P'
+
+        # Call swe_houses - returns a flat array of 23 elements
+        # [0-12]: house cusps (0 is unused, 1-12 are the 12 houses)
+        # [13+]: ASCMC values (ascendant, MC, ARMC, vertex, etc.)
+        result = Swe4r.swe_houses(julian_day, latitude, longitude, system_code)
+
+        unless result.is_a?(Array)
+          raise Error, "Unexpected swe_houses return type: #{result.class} - #{result.inspect}"
+        end
+
+        {
+          cusps: extract_cusps(result),
+          angles: extract_angles(result)
+        }
+      rescue StandardError => e
+        raise Error, "Failed to calculate houses: #{e.message}\nResult type: #{result.class rescue 'unknown'}\nResult: #{result.inspect rescue 'uninspectable'}"
+      end
+
+      # Determine which house a longitude is in
+      def house_for_longitude(longitude, cusps)
+        # Normalize longitude
+        longitude = normalize_degrees(longitude)
+
+        # Return default if cusps is empty or invalid
+        return 1 if cusps.nil? || cusps.empty? || cusps.length < 12
+
+        # Find the house
+        12.times do |i|
+          cusp_start = cusps[i]
+          cusp_end = cusps[(i + 1) % 12]
+
+          # Skip if cusps are nil
+          next if cusp_start.nil? || cusp_end.nil?
+
+          # Handle wrapping around 0 degrees
+          if cusp_start > cusp_end
+            return i + 1 if longitude >= cusp_start || longitude < cusp_end
+          else
+            return i + 1 if longitude >= cusp_start && longitude < cusp_end
+          end
+        end
+
+        1 # Default to first house
+      end
+
+      private
+
+      def extract_cusps(result_array)
+        # swe_houses returns a flat array where:
+        # [0-12]: house cusps (0 is unused, 1-12 are the 12 houses)
+        # We want indices 1-12
+        return [] unless result_array.is_a?(Array) && result_array.length >= 13
+
+        result_array[1..12]
+      end
+
+      def extract_angles(result_array)
+        # swe_houses returns a flat array where:
+        # [13]: Ascendant
+        # [14]: MC (Midheaven)
+        # [15]: ARMC
+        # [16]: Vertex
+        # [17-22]: Other values
+        return {} unless result_array.is_a?(Array) && result_array.length >= 17
+
+        {
+          ascendant: result_array[13],
+          midheaven: result_array[14],
+          descendant: normalize_degrees(result_array[13] + 180),
+          imum_coeli: normalize_degrees(result_array[14] + 180),
+          vertex: result_array[16]
+        }
+      end
+
+      def normalize_degrees(degrees)
+        degrees = degrees % 360
+        degrees += 360 if degrees < 0
+        degrees
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/calculations/positions.rb

@@ -0,0 +1,113 @@
+module RubyChartEngine
+  module Calculations
+    class Positions
+      attr_reader :julian_day, :latitude, :longitude
+
+      def initialize(julian_day:, latitude:, longitude:)
+        @julian_day = julian_day
+        @latitude = latitude
+        @longitude = longitude
+      end
+
+      # Calculate position for a single celestial object
+      def calculate_planet(planet_id)
+        # Calculation flags: 4 = SEFLG_MOSEPH (use built-in Moshier ephemeris), 256 = SEFLG_SPEED
+        # Using Moshier ephemeris (analytical) to avoid needing external ephemeris files
+        # Provides precision of ~0.1 arc seconds for planets, ~3" for Moon
+        flags = 4 | 256  # SEFLG_MOSEPH | SEFLG_SPEED
+
+        result = Swe4r.swe_calc_ut(julian_day, planet_id, flags)
+
+        # swe_calc_ut returns an array: [longitude, latitude, distance, speed_long, speed_lat, speed_dist]
+        # Extract values based on whether it's an array or hash
+        if result.is_a?(Array)
+          {
+            longitude: result[0],
+            latitude: result[1],
+            distance: result[2],
+            speed_longitude: result[3],
+            speed_latitude: result[4],
+            speed_distance: result[5]
+          }
+        elsif result.is_a?(Hash)
+          {
+            longitude: result[:longitude] || result['longitude'],
+            latitude: result[:latitude] || result['latitude'],
+            distance: result[:distance] || result['distance'],
+            speed_longitude: result[:speed_longitude] || result['speed_longitude'],
+            speed_latitude: result[:speed_latitude] || result['speed_latitude'],
+            speed_distance: result[:speed_distance] || result['speed_distance']
+          }
+        else
+          raise Error, "Unexpected swe_calc_ut return type: #{result.class}"
+        end
+      rescue => e
+        raise Error, "Failed to calculate position for planet #{planet_id}: #{e.message}"
+      end
+
+      # Calculate all planets
+      def calculate_all_planets
+        positions = {}
+
+        PLANETS.each do |name, id|
+          positions[name] = calculate_planet(id)
+        end
+
+        # Calculate points
+        POINTS.each do |name, id|
+          if name == :south_node
+            # South Node is opposite of North Node
+            north_node = calculate_planet(POINTS[:north_node])
+            positions[name] = north_node.dup
+            positions[name][:longitude] = normalize_degrees(north_node[:longitude] + 180)
+          elsif name == :chiron
+            # Chiron is not available in Moshier ephemeris, skip it
+            # Would require external ephemeris files (seas_*.se1)
+            next
+          else
+            positions[name] = calculate_planet(id)
+          end
+        end
+
+        positions
+      end
+
+      # Get sign from longitude
+      def longitude_to_sign(longitude)
+        sign_index = (longitude / 30).floor
+        sign_longitude = longitude % 30
+
+        {
+          index: sign_index,
+          sign: SIGNS[sign_index],
+          longitude: sign_longitude,
+          decan: ((sign_longitude / 10).floor + 1)
+        }
+      end
+
+      # Determine if planet is retrograde
+      def retrograde?(speed)
+        speed < 0
+      end
+
+      # Get movement status
+      def movement_status(speed)
+        if speed.abs < 0.0001
+          'stationary'
+        elsif speed < 0
+          'retrograde'
+        else
+          'direct'
+        end
+      end
+
+      private
+
+      def normalize_degrees(degrees)
+        degrees = degrees % 360
+        degrees += 360 if degrees < 0
+        degrees
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/charts/base_chart.rb

@@ -0,0 +1,135 @@
+module RubyChartEngine
+  module Charts
+    class BaseChart
+      attr_reader :datetime, :coordinates, :timezone, :house_system,
+                  :julian_day, :houses, :angles, :planets, :aspects
+
+      def initialize(datetime:, latitude:, longitude:, timezone: 'UTC', house_system: :placidus)
+        # Parse inputs
+        @datetime = Input::DateTime.new(datetime)
+        @coordinates = Input::Coordinates.new(lat: latitude, lon: longitude)
+        @timezone = Input::Timezone.new(timezone, @datetime.datetime)
+        @house_system = house_system
+
+        # Calculate Julian Day
+        @julian_day = @datetime.to_julian_day(@timezone.offset_hours)
+
+        # Initialize calculators
+        @position_calc = Calculations::Positions.new(
+          julian_day: @julian_day,
+          latitude: @coordinates.latitude,
+          longitude: @coordinates.longitude
+        )
+
+        @house_calc = Calculations::Houses.new(
+          julian_day: @julian_day,
+          latitude: @coordinates.latitude,
+          longitude: @coordinates.longitude,
+          house_system: @house_system
+        )
+
+        # Perform calculations
+        calculate!
+      end
+
+      def to_json(*args)
+        to_hash.to_json(*args)
+      end
+
+      def to_hash
+        {
+          metadata: metadata,
+          planets: format_planets,
+          houses: format_houses,
+          angles: format_angles,
+          aspects: @aspects
+        }
+      end
+
+      private
+
+      def calculate!
+        # Calculate houses and angles
+        house_data = @house_calc.calculate
+        @house_cusps = house_data[:cusps]
+        @angles = house_data[:angles]
+        @houses = house_data  # Store full house data including cusps and angles
+
+        # Calculate planetary positions
+        @planets = calculate_planets
+
+        # Calculate aspects
+        @aspects = Calculations::Aspects.calculate(@planets)
+      end
+
+      def calculate_planets
+        raw_positions = @position_calc.calculate_all_planets
+        formatted_planets = {}
+
+        raw_positions.each do |name, data|
+          sign_data = @position_calc.longitude_to_sign(data[:longitude])
+          house_number = @house_calc.house_for_longitude(data[:longitude], @house_cusps)
+
+          formatted_planets[name] = {
+            longitude: data[:longitude],
+            latitude: data[:latitude],
+            distance: data[:distance],
+            speed_longitude: data[:speed_longitude],
+            sign_longitude: sign_data[:longitude],
+            sign: sign_data[:sign],
+            house: house_number,
+            decan: sign_data[:decan],
+            movement: @position_calc.movement_status(data[:speed_longitude]),
+            dignities: Calculations::Dignities.calculate(name, sign_data[:index])
+          }
+        end
+
+        # Add angles as celestial points
+        @angles.each do |name, longitude|
+          next if name == :vertex # Skip vertex for now
+
+          sign_data = @position_calc.longitude_to_sign(longitude)
+
+          formatted_planets[name] = {
+            longitude: longitude,
+            sign_longitude: sign_data[:longitude],
+            sign: sign_data[:sign],
+            decan: sign_data[:decan]
+          }
+        end
+
+        formatted_planets
+      end
+
+      def format_planets
+        @planets.select { |name, _| !ANGLES.keys.include?(name) }
+      end
+
+      def format_angles
+        @planets.select { |name, _| ANGLES.keys.include?(name) }
+      end
+
+      def format_houses
+        @house_cusps.each_with_index.map do |cusp, index|
+          sign_data = @position_calc.longitude_to_sign(cusp)
+          {
+            number: index + 1,
+            cusp: cusp,
+            sign: sign_data[:sign]
+          }
+        end
+      end
+
+      def metadata
+        {
+          datetime: @datetime.datetime.iso8601,
+          julian_day: @julian_day,
+          latitude: @coordinates.latitude,
+          longitude: @coordinates.longitude,
+          timezone: @timezone.timezone.to_s,
+          house_system: @house_system.to_s
+        }
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/charts/composite.rb

@@ -0,0 +1,90 @@
+require_relative 'base_chart'
+
+module RubyChartEngine
+  module Charts
+    class Composite < BaseChart
+      attr_reader :chart1, :chart2
+
+      # Composite chart - midpoint chart between two natal charts
+      def initialize(chart1_params:, chart2_params:, house_system: :placidus)
+        # Create the two base charts
+        @chart1 = Natal.new(**chart1_params)
+        @chart2 = Natal.new(**chart2_params)
+
+        # Calculate composite datetime and location
+        composite_datetime = calculate_midpoint_datetime
+        composite_coords = calculate_midpoint_coordinates
+
+        # Initialize with composite parameters
+        super(
+          datetime: composite_datetime,
+          latitude: composite_coords[:latitude],
+          longitude: composite_coords[:longitude],
+          timezone: chart1_params[:timezone] || 'UTC',
+          house_system: house_system
+        )
+      end
+
+      def to_hash
+        super.merge(
+          chart_type: 'composite',
+          chart1_metadata: @chart1.to_hash[:metadata],
+          chart2_metadata: @chart2.to_hash[:metadata]
+        )
+      end
+
+      private
+
+      def calculate_midpoint_datetime
+        # Calculate midpoint between two datetimes
+        jd1 = @chart1.julian_day
+        jd2 = @chart2.julian_day
+
+        midpoint_jd = (jd1 + jd2) / 2.0
+
+        # Convert back to datetime
+        # swe_revjul takes 1 argument: julian day number
+        result = Swe4r.swe_revjul(midpoint_jd)
+
+        ::DateTime.new(
+          result[:year],
+          result[:month],
+          result[:day],
+          result[:hour].to_i,
+          ((result[:hour] % 1) * 60).to_i,
+          0
+        )
+      end
+
+      def calculate_midpoint_coordinates
+        lat1 = @chart1.coordinates.latitude
+        lon1 = @chart1.coordinates.longitude
+        lat2 = @chart2.coordinates.latitude
+        lon2 = @chart2.coordinates.longitude
+
+        # Simple midpoint calculation
+        # Note: This doesn't account for the spherical nature of Earth
+        # For a more accurate calculation, use great circle midpoint
+        {
+          latitude: (lat1 + lat2) / 2.0,
+          longitude: calculate_longitude_midpoint(lon1, lon2)
+        }
+      end
+
+      def calculate_longitude_midpoint(lon1, lon2)
+        # Handle date line crossing
+        diff = (lon2 - lon1).abs
+
+        if diff > 180
+          # Crosses date line - take the "other" midpoint
+          midpoint = (lon1 + lon2 + 360) / 2.0
+          midpoint -= 360 if midpoint > 180
+        else
+          midpoint = (lon1 + lon2) / 2.0
+        end
+
+        midpoint
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/charts/natal.rb

@@ -0,0 +1,79 @@
+require_relative 'base_chart'
+
+module RubyChartEngine
+  module Charts
+    class Natal < BaseChart
+      # Natal chart is the base chart type
+      # Additional natal-specific methods can be added here
+
+      def moon_phase
+        sun_lon = @planets[:sun][:longitude]
+        moon_lon = @planets[:moon][:longitude]
+
+        phase_angle = (moon_lon - sun_lon) % 360
+
+        case phase_angle
+        when 0..45
+          'New Moon'
+        when 45..90
+          'Waxing Crescent'
+        when 90..135
+          'First Quarter'
+        when 135..180
+          'Waxing Gibbous'
+        when 180..225
+          'Full Moon'
+        when 225..270
+          'Waning Gibbous'
+        when 270..315
+          'Last Quarter'
+        when 315..360
+          'Waning Crescent'
+        end
+      end
+
+      def chart_shape
+        # Analyze planetary distribution to determine chart shape
+        # This is a simplified implementation
+        longitudes = @planets.select { |k, _| PLANETS.keys.include?(k) }
+                             .map { |_, v| v[:longitude] }
+                             .sort
+
+        return 'splash' if longitudes.empty?
+
+        # Calculate the largest gap between consecutive planets
+        gaps = []
+        longitudes.each_with_index do |lon, i|
+          next_lon = longitudes[(i + 1) % longitudes.length]
+          gap = next_lon > lon ? next_lon - lon : (360 - lon) + next_lon
+          gaps << gap
+        end
+
+        max_gap = gaps.max
+        occupied_arc = 360 - max_gap
+
+        case
+        when max_gap > 240
+          'bundle'
+        when occupied_arc <= 120
+          'bundle'
+        when occupied_arc <= 180
+          'bowl'
+        when occupied_arc <= 240
+          'bucket'
+        when gaps.all? { |g| g > 20 && g < 60 }
+          'splay'
+        else
+          'splash'
+        end
+      end
+
+      def to_hash
+        super.merge(
+          moon_phase: moon_phase,
+          chart_shape: chart_shape
+        )
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/charts/progressed.rb

@@ -0,0 +1,55 @@
+require_relative 'base_chart'
+
+module RubyChartEngine
+  module Charts
+    class Progressed < BaseChart
+      attr_reader :natal_datetime, :progression_date
+
+      # Secondary Progressed chart
+      # Uses "a day for a year" progression
+      def initialize(natal_datetime:, progression_date:, latitude:, longitude:, timezone: 'UTC', house_system: :placidus)
+        @natal_datetime = natal_datetime
+        @progression_date = progression_date
+
+        # Calculate progressed datetime
+        progressed_datetime = calculate_progressed_datetime
+
+        # Initialize with progressed datetime
+        super(
+          datetime: progressed_datetime,
+          latitude: latitude,
+          longitude: longitude,
+          timezone: timezone,
+          house_system: house_system
+        )
+      end
+
+      def to_hash
+        super.merge(
+          natal_datetime: @natal_datetime.to_s,
+          progression_date: @progression_date.to_s,
+          chart_type: 'progressed'
+        )
+      end
+
+      private
+
+      def calculate_progressed_datetime
+        natal_dt = Input::DateTime.new(@natal_datetime)
+        prog_dt = Input::DateTime.new(@progression_date)
+
+        # Calculate days between natal and progression date
+        natal_date = natal_dt.datetime
+        progression_date = prog_dt.datetime
+
+        days_difference = (progression_date - natal_date).to_i
+
+        # Add the same number of days to natal datetime
+        # (Secondary progression: 1 day = 1 year)
+        progressed = natal_date + days_difference
+
+        progressed
+      end
+    end
+  end
+end

data/lib/ruby_chart_engine/charts/solar_return.rb

@@ -0,0 +1,90 @@
+require_relative 'base_chart'
+
+module RubyChartEngine
+  module Charts
+    class SolarReturn < BaseChart
+      attr_reader :natal_sun_longitude
+
+      # Solar Return chart for a specific year
+      # Calculated for the moment the Sun returns to its natal position
+      def initialize(natal_datetime:, return_year:, latitude:, longitude:, timezone: 'UTC', house_system: :placidus)
+        # Get natal Sun position
+        natal_chart_temp = Natal.new(
+          datetime: natal_datetime,
+          latitude: latitude,
+          longitude: longitude,
+          timezone: timezone
+        )
+        @natal_sun_longitude = natal_chart_temp.planets[:sun][:longitude]
+
+        # Find the moment when Sun returns to natal position in the return year
+        return_datetime = find_solar_return_time(natal_datetime, return_year, timezone)
+
+        # Initialize with the solar return datetime
+        super(
+          datetime: return_datetime,
+          latitude: latitude,
+          longitude: longitude,
+          timezone: timezone,
+          house_system: house_system
+        )
+      end
+
+      def to_hash
+        super.merge(
+          natal_sun_longitude: @natal_sun_longitude,
+          chart_type: 'solar_return'
+        )
+      end
+
+      private
+
+      def find_solar_return_time(natal_datetime, return_year, timezone)
+        # Parse natal datetime
+        natal_dt = Input::DateTime.new(natal_datetime)
+
+        # Start with birthday in the return year
+        search_date = ::DateTime.new(
+          return_year,
+          natal_dt.month,
+          natal_dt.day,
+          natal_dt.hour,
+          natal_dt.minute,
+          natal_dt.second
+        )
+
+        # Binary search to find exact moment of solar return
+        # This is a simplified implementation
+        best_date = search_date
+        min_diff = Float::INFINITY
+
+        # Search in a 48-hour window around the birthday
+        (-24..24).each do |hour_offset|
+          test_date = search_date + (hour_offset / 24.0)
+          test_dt = Input::DateTime.new(test_date)
+          tz = Input::Timezone.new(timezone, test_date)
+          jd = test_dt.to_julian_day(tz.offset_hours)
+
+          # Calculate Sun position
+          pos_calc = Calculations::Positions.new(
+            julian_day: jd,
+            latitude: 0,
+            longitude: 0
+          )
+          sun_pos = pos_calc.calculate_planet(PLANETS[:sun])
+
+          # Calculate difference from natal Sun
+          diff = (sun_pos[:longitude] - @natal_sun_longitude).abs
+          diff = 360 - diff if diff > 180
+
+          if diff < min_diff
+            min_diff = diff
+            best_date = test_date
+          end
+        end
+
+        best_date
+      end
+    end
+  end
+end