time_scales 0.1.0

data/lib/time_scales/frame/null_frame.rb

@@ -0,0 +1,9 @@
+module TimeScales
+  module Frame
+
+    class NullFrame < Frame::Base
+      include Singleton
+    end
+
+  end
+end

data/lib/time_scales/frame/part_components.rb

@@ -0,0 +1,258 @@
+module TimeScales
+  module Frame
+
+    module PartComponents
+
+      module HasYearOfScheme
+        def self.included(other)
+          other.extend HasYearOfScheme::ClassMixin
+        end
+
+        attr_reader :year_of_scheme
+
+        alias year year_of_scheme
+
+        private
+
+        def _initialize(args_array)
+          super
+          @year_of_scheme = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.year = (struct.year || 1) + year_of_scheme - 1
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::YearOfScheme
+          end
+        end
+      end
+
+      module HasMonthOfYear
+        def self.included(other)
+          other.extend HasMonthOfYear::ClassMixin
+        end
+
+        attr_reader :month_of_year
+
+        alias month month_of_year
+
+        private
+
+        def _initialize(args_array)
+          super
+          @month_of_year = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.month = (struct.month || 1) + month_of_year - 1
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::MonthOfYear
+          end
+        end
+      end
+
+      module HasDayOfMonth
+        def self.included(other)
+          other.extend HasDayOfMonth::ClassMixin
+        end
+
+        attr_reader :day_of_month
+
+        alias day day_of_month
+
+        private
+
+        def _initialize(args_array)
+          super
+          @day_of_month = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.day = (struct.day || 1) + day_of_month - 1
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::DayOfMonth
+          end
+        end
+      end
+
+      module HasDayOfYear
+        def self.included(other)
+          other.extend HasDayOfYear::ClassMixin
+        end
+
+        attr_reader :day_of_year
+
+        alias day day_of_year
+
+        private
+
+        def _initialize(args_array)
+          super
+          @day_of_year = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.day = (struct.day || 1) + day_of_year - 1
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::DayOfYear
+          end
+        end
+      end
+
+      module HasHourOfDay
+        def self.included(other)
+          other.extend HasHourOfDay::ClassMixin
+        end
+
+        attr_reader :hour_of_day
+
+        alias hour hour_of_day
+
+        private
+
+        def _initialize(args_array)
+          super
+          @hour_of_day = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.hour = struct.hour.to_i + hour_of_day
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::HourOfDay
+          end
+        end
+      end
+
+      module HasMinuteOfHour
+        def self.included(other)
+          other.extend HasMinuteOfHour::ClassMixin
+        end
+
+        attr_reader :minute_of_hour
+
+        alias minute minute_of_hour
+
+        private
+
+        def _initialize(args_array)
+          super
+          @minute_of_hour = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.minute = struct.minute.to_i + minute_of_hour
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::MinuteOfHour
+          end
+        end
+      end
+
+      module HasMonthOfQuarter
+        def self.included(other)
+          other.extend HasMonthOfQuarter::ClassMixin
+        end
+
+        attr_reader :month_of_quarter
+
+        alias month month_of_quarter
+
+        private
+
+        def _initialize(args_array)
+          super
+          @month_of_quarter = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          struct.month = (struct.month || 1) + month_of_quarter - 1
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::MonthOfQuarter
+          end
+        end
+      end
+
+      module HasQuarterOfYear
+        def self.included(other)
+          other.extend HasQuarterOfYear::ClassMixin
+        end
+
+        attr_reader :quarter_of_year
+
+        alias quarter quarter_of_year
+
+        private
+
+        def _initialize(args_array)
+          super
+          @quarter_of_year = ensure_fixnum( args_array.shift )
+        end
+
+        def prepare_time_struct(struct)
+          to_month =
+            (struct.month || 1) +
+            3 * (quarter_of_year - 1)
+          if to_month > 12
+            struct.year = (struct.year || 1) + 1
+            to_month -= 12
+            struct.month = to_month
+          else
+            struct.month = to_month
+          end
+          super
+        end
+
+        module ClassMixin
+          protected
+
+          def _parts
+            super << Parts::QuarterOfYear
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/time_scales/frame/part_def.rb

@@ -0,0 +1,45 @@
+module TimeScales
+  module Frame
+
+    class PartDef
+      attr_reader :key, :value, :part
+
+      def initialize(key, value=nil)
+        @key   = key
+        @value = value
+      end
+
+      def scale
+        possible_parts.first.scale
+      end
+
+      def outer_scope!
+        @part = possible_parts.length == 1 ?
+          possible_parts.first :
+          possible_parts.detect { |part| part.default_for_unit? }
+      end
+
+      def component_of!(scope)
+        @part = possible_parts.detect { |part|
+          scope.subdivision === part.scope
+        }
+      end
+
+      private
+
+      def possible_parts
+        @possible_parts ||= begin
+          parts = Parts.all.select { |part| part === key }
+          if parts.empty?
+            parts = Parts.all.select { |part| part.subdivision === key }
+          end
+          if parts.empty?
+            raise NoPartOrUnitForKeyError, "No part or unit matches key #{key.inspect}"
+          end
+          parts
+        end
+      end
+    end
+
+  end
+end

data/lib/time_scales/frame/part_defs.rb

@@ -0,0 +1,53 @@
+module TimeScales
+  module Frame
+
+    class PartDefs
+
+      class << self
+        private :new
+
+        def from_key_value_map(kvm)
+          part_defs = kvm.map { |part_key, value|
+            PartDef.new( part_key, value )
+          }
+          new( part_defs )
+        end
+
+        def from_keys(part_keys)
+          part_defs = part_keys.map { |key| PartDef.new(key) }
+          new( part_defs )
+        end
+      end
+
+      def initialize(part_defs)
+        @part_defs = part_defs
+      end
+
+      def parts
+        @parts ||= assembly_sequence.map { |pd| pd.part }
+      end
+
+      def part_values
+        assembly_sequence.map { |pd| pd.value }
+      end
+
+      private
+
+      attr_reader :part_defs
+
+      def assembly_sequence
+        return [] if part_defs.empty?
+        @assembly_sequence ||= begin
+          seq = part_defs.sort_by { |ps| -ps.scale }
+          seq.first.outer_scope!
+          seq[0..-2].zip( seq[1..-1] ).each do |a,b|
+            b.component_of! a.part
+          end
+          seq
+        end
+      end
+
+    end
+
+  end
+end

data/lib/time_scales/frame/precisions.rb

@@ -0,0 +1,83 @@
+module TimeScales
+  module Frame
+
+    module Precisions
+
+      module HasYearOfSchemePrecision
+        def succ_begin_time
+          @end_time ||= Time.new( begin_time.year + 1 )
+        end
+      end
+
+      module Has_N_MonthsOfSchemePrecision
+        def succ_begin_time
+          @succ_begin_time ||= begin
+            succ_y = year_of_scheme
+            succ_m = begin_time.month + n_months_precision
+            if succ_m > 12
+              succ_y += 1 ; succ_m = 1
+            end
+            Time.new( succ_y, succ_m )
+          end
+        end
+
+        private
+
+        # Precision unit size in months. A year must be divisible
+        # by this value.
+        def n_months_precision
+          raise NotImplementedError, "Subclass responsibility"
+        end
+      end
+
+      module HasMonthOfSchemePrecision
+        include Has_N_MonthsOfSchemePrecision
+
+        private
+
+        def n_months_precision
+          1
+        end
+      end
+
+      module HasQuarterOfSchemePrecision
+        include Has_N_MonthsOfSchemePrecision
+
+        private
+
+        def n_months_precision
+          3
+        end
+      end
+
+      module HasDayOfSchemePrecision
+        # Gets us to the early part of the next day, regardless
+        # of DST handling, leap seconds, etc.
+        SECONDS_IN_26_HOURS = 60 * 60 * 26
+
+        def succ_begin_time
+          t = begin_time + SECONDS_IN_26_HOURS
+          @succ_begin_time ||= Time.new(t.year, t.month, t.day)
+        end
+      end
+
+      module HasHourOfSchemePrecision
+        SECONDS_PER_HOUR = 60 * 60
+
+        def succ_begin_time
+          @succ_begin_time ||= begin_time + SECONDS_PER_HOUR
+        end
+      end
+
+      module HasMinuteOfSchemePrecision
+        SECONDS_PER_MINUTE = 60
+
+        def succ_begin_time
+          @succ_begin_time ||= begin_time + SECONDS_PER_MINUTE
+        end
+      end
+
+    end
+
+  end
+end