Module: Temporalize

Defined in:
lib/temporalize.rb,
lib/temporalize/formats.rb,
lib/temporalize/seconds.rb,
lib/temporalize/version.rb,
lib/temporalize/configuration.rb

Defined Under Namespace

Modules: Formats Classes: Configuration, Error, Seconds

Constant Summary collapse

VERSION = 
"0.1.0"

Class Method Summary collapse

Class Method Details

.configuration ⇒ Object 



63
64
65
 
# File 'lib/temporalize.rb', line 63

def self.configuration
  @configuration ||= Configuration.new
end

.configure {|configuration| ... } ⇒ Object

Yields:



67
68
69
 
# File 'lib/temporalize.rb', line 67

def self.configure
  yield(configuration) if block_given?
end

.temporalize(klass, attribute, **options) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/temporalize.rb', line 12

def self.temporalize(klass, attribute, **options)
  column = options[:column] || "#{attribute}_in_seconds".to_sym
  default_format = options[:format] || configuration.default_format

  # Enhanced column name detection
  uses_milliseconds = if options.key?(:milliseconds)
                        options[:milliseconds]
                      else
                        column_name = column.to_s
                        column_name.end_with?('_in_milliseconds', '_in_ms', '_milliseconds', '_ms')
                      end

  klass.class_eval do
    define_method(attribute) do |**opts|
      value = read_attribute(column)
      return nil if value.nil?

      if uses_milliseconds
        seconds = value / 1000
        milliseconds = value % 1000
        Temporalize::Seconds.new(seconds, opts[:format] || default_format, milliseconds)
      else
        Temporalize::Seconds.new(value, opts[:format] || default_format)
      end
    end

    define_method("#{attribute}=") do |value|
      numeric_value = case value
                      when Temporalize::Seconds then value.seconds
                      when Numeric
                        if uses_milliseconds
                          (value.to_f * 1000).to_i
                        else
                          value.to_i
                        end
                      when nil then return write_attribute(column, nil)
                      else
                        raise ArgumentError, "Invalid duration value: #{value.inspect}"
                      end

      value_to_store = if uses_milliseconds && value.is_a?(Temporalize::Seconds)
                         numeric_value * 1000
                       else
                         numeric_value
                       end

      write_attribute(column, value_to_store)
    end
  end
end