time_scales 0.1.0

data/lib/time_scales/frame/scheme_relative_frame.rb

@@ -0,0 +1,21 @@
+module TimeScales
+  module Frame
+
+    class SchemeRelativeFrame < Frame::Base
+      def to_range
+        @to_range ||= ( begin_time...succ_begin_time )
+      end
+
+      def begin_time
+        @begin_time ||= Time.new( *begin_time_struct.to_a )
+      end
+
+      alias to_time begin_time
+
+      def succ_begin_time
+        raise NotImplementedError, "Subclass responsibility"
+      end
+    end
+
+  end
+end

data/lib/time_scales/frame/type_builder.rb

@@ -0,0 +1,73 @@
+module TimeScales
+
+  module Frame
+
+    class TypeBuilder
+
+      class << self
+
+        private
+
+        def add_type_cache
+          # Closure variable accessible via instance method
+          # from any instance.
+          _type_cache = {}
+
+          define_method(:type_cache){
+            _type_cache
+          }
+
+          private :type_cache
+        end
+
+      end
+
+      add_type_cache
+
+      attr_reader :parts
+
+      def initialize(parts)
+        @parts = parts
+      end
+
+      def call
+        type_cache.fetch( parts ) {
+          type_cache[parts] = build_type
+        }
+      end
+
+      private
+
+      def build_type
+        _parts = parts ; _is_scheme_scoped = scheme_scoped?
+        klass = Class.new type_base_class do
+          _parts.each do |part| ; include part.component_mixin ; end
+          include _parts.last.scheme_scoped_precision_mixin if _is_scheme_scoped
+        end
+        Frame.const_set type_const_name, klass
+        klass
+      end
+
+      def type_base_class
+        if scheme_scoped?
+          Frame::SchemeRelativeFrame
+        else
+          Frame::Base
+        end
+      end
+
+      def scheme_scoped?
+        parts.first.scope == Units::Scheme
+      end
+
+      def type_const_name
+        const_name = "#{parts.first.name}"
+        parts[1..-1].each do |part| ; const_name << "_#{part.subdivision_name}" ; end
+        const_name << 'Only' if parts.length == 1
+        const_name << '__Auto'
+      end
+    end
+
+  end
+
+end

data/lib/time_scales/parts.rb

@@ -0,0 +1,242 @@
+module TimeScales
+
+  module Parts
+
+    def self.all
+      @all_parts ||= [
+        YearOfScheme,
+        QuarterOfYear,
+        MonthOfYear,
+        MonthOfQuarter,
+        DayOfMonth,
+        DayOfYear,
+        DayOfQuarter,
+        HourOfDay,
+        MinuteOfHour,
+      ].freeze
+    end
+
+    class AbstractPart
+      def to_time_scales_part
+        self
+      end
+
+      def ===(other)
+        self == other || symbol == other
+      end
+
+      def symbol
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def subdivision
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def scope
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def scale
+        subdivision.scale
+      end
+
+      def default_for_unit?
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def to_s
+        @to_s ||= self.class.name.sub(/Class$/, '').freeze
+      end
+
+      def component_mixin
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def scheme_scoped_precision_mixin
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def name
+        @name ||= /::([^:]+)Class$/.match( self.class.name )[1]
+      end
+
+      def subdivision_name
+        subdivision.name
+      end
+
+      def &(time)
+        raise NotImplementedError, "Subclass responsibility"
+      end
+    end
+
+    class YearOfSchemeClass < AbstractPart
+      include Singleton
+
+      def symbol ; :year_of_scheme ; end
+      def subdivision ; Units::Year   ; end
+      def scope       ; Units::Scheme ; end
+      def default_for_unit? ; true    ; end
+      def component_mixin ; Frame::PartComponents::HasYearOfScheme ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasYearOfSchemePrecision ; end
+
+      def &(time)
+        time.year
+      end
+    end
+
+    YearOfScheme = YearOfSchemeClass.instance
+
+
+    class QuarterOfYearClass < AbstractPart
+      include Singleton
+
+      def symbol ; :quarter_of_year ; end
+      def subdivision ; Units::Quarter ; end
+      def scope       ; Units::Year    ; end
+      def default_for_unit? ; true ; end
+      def component_mixin ; Frame::PartComponents::HasQuarterOfYear ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasQuarterOfSchemePrecision ; end
+
+      def &(time)
+        month_offs = time.month - 1
+        ( month_offs / 3 ) + 1
+      end
+    end
+
+    QuarterOfYear = QuarterOfYearClass.instance
+
+
+    class MonthOfYearClass < AbstractPart
+      include Singleton
+
+      def symbol ; :month_of_year ; end
+      def subdivision ; Units::Month ; end
+      def scope       ; Units::Year  ; end
+      def default_for_unit? ; true ; end
+      def component_mixin ; Frame::PartComponents::HasMonthOfYear ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasMonthOfSchemePrecision ; end
+
+      def &(time)
+        time.month
+      end
+    end
+
+    MonthOfYear = MonthOfYearClass.instance
+
+
+    class MonthOfQuarterClass < AbstractPart
+      include Singleton
+
+      def symbol ; :month_of_quarter ; end
+      def subdivision ; Units::Month   ; end
+      def scope       ; Units::Quarter ; end
+      def default_for_unit? ; false    ; end
+      def component_mixin ; Frame::PartComponents::HasMonthOfQuarter ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasMonthOfSchemePrecision ; end
+
+      def &(time)
+        month_offs = time.month - 1
+        ( month_offs % 3 ) + 1
+      end
+    end
+
+    MonthOfQuarter = MonthOfQuarterClass.instance
+
+
+    class DayOfMonthClass < AbstractPart
+      include Singleton
+
+      def symbol ; :day_of_month ; end
+      def subdivision ; Units::Day   ; end
+      def scope       ; Units::Month ; end
+      def default_for_unit? ; true ; end
+      def component_mixin ; Frame::PartComponents::HasDayOfMonth ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasDayOfSchemePrecision ; end
+
+      def &(time)
+        time.day
+      end
+    end
+
+    DayOfMonth = DayOfMonthClass.instance
+
+
+    class DayOfYearClass < AbstractPart
+      include Singleton
+
+      def symbol ; :day_of_year ; end
+      def subdivision ; Units::Day   ; end
+      def scope       ; Units::Year ; end
+      def default_for_unit? ; false ; end
+      def component_mixin ; Frame::PartComponents::HasDayOfYear ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasDayOfSchemePrecision ; end
+
+      def &(time)
+        time.yday
+      end
+    end
+
+    DayOfYear = DayOfYearClass.instance
+
+
+    class DayOfQuarterClass < AbstractPart
+      include Singleton
+
+      def symbol ; :day_of_quarter ; end
+      def subdivision ; Units::Day     ; end
+      def scope       ; Units::Quarter ; end
+      def default_for_unit? ; false ; end
+      def component_mixin ; Frame::PartComponents::HasDayOfQuarter ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasDayOfSchemePrecision ; end
+
+      def &(time)
+        month_offs = time.month - 1
+        qtr_offs = month_offs / 3
+        qtr_start_mo = ( qtr_offs * 3 ) + 1
+        qtr_start_time = Time.new( time.year, qtr_start_mo, 1)
+        time.yday - qtr_start_time.yday + 1
+      end
+    end
+
+    DayOfQuarter = DayOfQuarterClass.instance
+
+
+    class HourOfDayClass < AbstractPart
+      include Singleton
+
+      def symbol ; :hour_of_day ; end
+      def subdivision ; Units::Hour ; end
+      def scope       ; Units::Day  ; end
+      def default_for_unit? ; false ; end
+      def component_mixin ; Frame::PartComponents::HasHourOfDay ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasHourOfSchemePrecision ; end
+
+      def &(time)
+        time.hour
+      end
+    end
+
+    HourOfDay = HourOfDayClass.instance
+
+
+    class MinuteOfHourClass < AbstractPart
+      include Singleton
+
+      def symbol ; :minute_of_hour ; end
+      def subdivision ; Units::Minute ; end
+      def scope       ; Units::Hour   ; end
+      def default_for_unit? ; true ; end
+      def component_mixin ; Frame::PartComponents::HasMinuteOfHour ; end
+      def scheme_scoped_precision_mixin ; Frame::Precisions::HasMinuteOfSchemePrecision ; end
+
+      def &(time)
+        time.min
+      end
+    end
+
+    MinuteOfHour = MinuteOfHourClass.instance
+
+  end
+
+end

data/lib/time_scales/time_struct.rb

@@ -0,0 +1,68 @@
+module TimeScales
+
+  class TimeStruct < Struct.new(
+    :year,
+    :month,
+    :day,
+    :hour,
+    :minute,
+  )
+
+    def normalize
+      return unless year && day
+      self.month ||= 1
+      if month == 1 && day > 31
+        self.month = 2
+        self.day -= 31
+      end
+      feb_days = days_in_feb_of_year
+      if month == 2 && day > feb_days
+        self.month = 3
+        self.day -= feb_days
+      end
+      if month == 3 && day > 31
+        self.month  = 4
+        self.day -= 31
+      end
+      if month == 4 && day > 30
+        self.month = 5
+        self.day -= 30
+      end
+      if month == 5 && day > 31
+        self.month = 6
+        self.day -= 31
+      end
+      if month == 6 && day > 30
+        self.month = 7
+        self.day -= 30
+      end
+      if month == 7 && day > 31
+        self.month = 8
+        self.day -= 31
+      end
+      if month == 8 && day > 31
+        self.month = 9
+        self.day -= 31
+      end
+      if month == 9 && day > 30
+        self.month = 10
+        self.day -= 30
+      end
+      if month == 10 && day > 31
+        self.month = 11
+        self.day -= 31
+      end
+      if month == 11 && day > 30
+        self.month = 12
+        self.day -= 30
+      end
+    end
+
+    def days_in_feb_of_year
+      t = Time.new(year, 3, 1)
+      t.yday - 32
+    end
+
+  end
+
+end

data/lib/time_scales/units.rb

@@ -0,0 +1,101 @@
+module TimeScales
+
+  module Units
+
+    class AbstractUnit
+      def to_time_scales_unit
+        self
+      end
+
+      def ===(other)
+        self == other || symbol == other
+      end
+
+      def symbol
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      # Rough order of magnitude of subdivision unit size.
+      # 1.407 times the base-2 logarithm of approximate number of
+      # seconds per unit, then round to nearest integer.
+      def scale
+        raise NotImplementedError, "Subclass responsibility"
+      end
+
+      def name
+        @name ||= /::([^:]+)Class$/.match( self.class.name )[1]
+      end
+    end
+
+    class SchemeClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :scheme ; end
+      def scale  ;  9999   ; end
+    end
+
+    Scheme = SchemeClass.instance
+
+
+    class YearClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :year ; end
+      def scale  ;  35   ; end
+    end
+
+    Year = YearClass.instance
+
+
+    class QuarterClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :quarter ; end
+      def scale  ;  32      ; end
+    end
+
+    Quarter = QuarterClass.instance
+
+
+    class MonthClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :month ; end
+      def scale  ;  30    ; end
+    end
+
+    Month = MonthClass.instance
+
+
+    class DayClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :day ; end
+      def scale  ;  23  ; end
+    end
+
+    Day = DayClass.instance
+
+
+    class HourClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :hour ; end
+      def scale  ;  17   ; end
+    end
+
+    Hour = HourClass.instance
+
+
+    class MinuteClass < AbstractUnit
+      include Singleton
+
+      def symbol ; :minute ; end
+      def scale  ;  8      ; end
+    end
+
+    Minute = MinuteClass.instance
+
+  end
+
+end