tdiary 5.1.1 → 5.1.2

data/vendor/bundle/ruby/2.7.0/gems/sequel-5.29.0/lib/sequel/plugins/single_table_inheritance.rb

@@ -1,256 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Plugins
-    # The single_table_inheritance plugin allows storing all objects
-    # in the same class hierarchy in the same table.  It makes it so
-    # subclasses of this model only load rows related to the subclass,
-    # and when you retrieve rows from the main class, you get instances
-    # of the subclasses (if the rows should use the subclasses's class).
-    #
-    # By default, the plugin assumes that the +sti_key+ column (the first
-    # argument to the plugin) holds the class name as a string.  However,
-    # you can override this by using the <tt>:model_map</tt> option and/or
-    # the <tt>:key_map</tt> option.
-    #   
-    # You should only load this plugin in the parent class, not in the subclasses.
-    #   
-    # You shouldn't call set_dataset in the model after applying this
-    # plugin, otherwise subclasses might use the wrong dataset. You should
-    # make sure this plugin is loaded before the subclasses. Note that since you
-    # need to load the plugin before the subclasses are created, you can't use
-    # direct class references in the plugin class.  You should specify subclasses
-    # in the plugin call using class name strings or symbols, see usage below.
-    #   
-    # Usage:
-    #
-    #   # Use the default of storing the class name in the sti_key
-    #   # column (:kind in this case)
-    #   class Employee < Sequel::Model
-    #     plugin :single_table_inheritance, :kind
-    #   end
-    #
-    #   # Have subclasses inherit from the appropriate class
-    #   class Staff < Employee; end
-    #   class Manager < Employee; end
-    #
-    #   # You can also use many different options to configure the plugin:
-    #
-    #   # Using integers to store the class type, with a :model_map hash
-    #   # and an sti_key of :type
-    #   Employee.plugin :single_table_inheritance, :type,
-    #     model_map: {1=>:Staff, 2=>:Manager}
-    #
-    #   # Using non-class name strings
-    #   Employee.plugin :single_table_inheritance, :type,
-    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager}
-    #
-    #   # By default the plugin sets the respective column value
-    #   # when a new instance is created.
-    #   Staff.create.type == 'line staff'
-    #   Manager.create.type == 'supervisor'
-    #
-    #   # You can customize this behavior with the :key_chooser option.
-    #   # This is most useful when using a non-bijective mapping.
-    #   Employee.plugin :single_table_inheritance, :type,
-    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager},
-    #     key_chooser: lambda{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger'}
-    #
-    #   # Using custom procs, with :model_map taking column values
-    #   # and yielding either a class, string, symbol, or nil, 
-    #   # and :key_map taking a class object and returning the column
-    #   # value to use
-    #   Employee.plugin :single_table_inheritance, :type,
-    #     model_map: :reverse.to_proc,
-    #     key_map: lambda{|klass| klass.name.reverse}
-    #
-    #   # You can use the same class for multiple values.
-    #   # This is mainly useful when the sti_key column contains multiple values
-    #   # which are different but do not require different code.
-    #   Employee.plugin :single_table_inheritance, :type,
-    #     model_map: {'staff' => "Staff",
-    #                  'manager' => "Manager",
-    #                  'overpayed staff' => "Staff",
-    #                  'underpayed staff' => "Staff"}
-    #
-    # One minor issue to note is that if you specify the <tt>:key_map</tt>
-    # option as a hash, instead of having it inferred from the <tt>:model_map</tt>,
-    # you should only use class name strings as keys, you should not use symbols
-    # as keys.
-    module SingleTableInheritance
-      # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
-      def self.configure(model, key, opts=OPTS)
-        model.instance_exec do
-          @sti_key_array = nil
-          @sti_key = key 
-          @sti_dataset = dataset
-          @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
-          @sti_key_map = if km = opts[:key_map]
-            if km.is_a?(Hash)
-              h = Hash.new do |h1,k| 
-                unless k.is_a?(String)
-                  h1[k.to_s]
-                else
-                  []
-                end
-              end
-              km.each do |k,v|
-                h[k.to_s] = [] unless h.key?(k.to_s)
-                h[k.to_s].push( *Array(v) )
-              end
-              h
-            else
-              km
-            end
-          elsif sti_model_map.is_a?(Hash)
-            h = Hash.new do |h1,k| 
-              unless k.is_a?(String)
-                h1[k.to_s]
-              else
-                []
-              end
-            end
-            sti_model_map.each do |k,v|
-              h[v.to_s] = [] unless h.key?(v.to_s)
-              h[v.to_s] << k
-            end
-            h
-          else
-            lambda{|klass| klass.name.to_s}
-          end
-          @sti_key_chooser = opts[:key_chooser] || lambda{|inst| Array(inst.model.sti_key_map[inst.model]).last }
-
-          @dataset = @dataset.with_row_proc(model.method(:sti_load))
-        end
-      end
-
-      module ClassMethods
-        # The base dataset for STI, to which filters are added to get
-        # only the models for the specific STI subclass.
-        attr_reader :sti_dataset
-
-        # The column name holding the STI key for this model
-        attr_reader :sti_key
-
-        # Array holding keys for all subclasses of this class, used for the
-        # dataset filter in subclasses. Nil in the main class.
-        attr_reader :sti_key_array
-
-        # A hash/proc with class keys and column value values, mapping
-        # the class to a particular value given to the sti_key column.
-        # Used to set the column value when creating objects, and for the
-        # filter when retrieving objects in subclasses.
-        attr_reader :sti_key_map
-
-        # A hash/proc with column value keys and class values, mapping
-        # the value of the sti_key column to the appropriate class to use.
-        attr_reader :sti_model_map
-
-        # A proc which returns the value to use for new instances.
-        # This defaults to a lookup in the key map.
-        attr_reader :sti_key_chooser
-
-        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
-
-        # Freeze STI information when freezing model class.  Note that
-        # because of how STI works, you should not freeze an STI subclass
-        # until after all subclasses of it have been created.
-        def freeze
-          @sti_key_array.freeze if @sti_key_array
-          @sti_key_map.freeze if @sti_key_map.is_a?(Hash)
-          @sti_model_map.freeze if @sti_model_map.is_a?(Hash)
-
-          super
-        end
-
-        # Copy the necessary attributes to the subclasses, and filter the
-        # subclass's dataset based on the sti_kep_map entry for the class.
-        def inherited(subclass)
-          super
-          key = Array(sti_key_map[subclass]).dup
-          sti_subclass_added(key)
-          rp = dataset.row_proc
-          subclass.set_dataset(sti_subclass_dataset(key), :inherited=>true)
-          subclass.instance_exec do
-            @dataset = @dataset.with_row_proc(rp)
-            @sti_key_array = key
-            self.simple_table = nil
-          end
-        end
-
-        # Return an instance of the class specified by sti_key,
-        # used by the row_proc.
-        def sti_load(r)
-          sti_class_from_sti_key(r[sti_key]).call(r)
-        end
-
-        # Return the sti class based on one of the keys from sti_model_map.
-        def sti_class_from_sti_key(key)
-          sti_class(sti_model_map[key])
-        end
-
-        # Make sure that all subclasses of the parent class correctly include 
-        # keys for all of their descendant classes.
-        def sti_subclass_added(key)
-          if sti_key_array
-            key_array = Array(key)
-            Sequel.synchronize{sti_key_array.push(*key_array)}
-            superclass.sti_subclass_added(key)
-          end
-        end
-
-        private
-
-        # Extend the sti dataset with the module when extending the main
-        # dataset.
-        def dataset_extend(mod, opts=OPTS)
-          @sti_dataset = @sti_dataset.with_extend(mod)
-          super
-        end
-
-        # If calling set_dataset manually, make sure to set the dataset
-        # row proc to one that handles inheritance correctly.
-        def set_dataset_row_proc(ds)
-          if @dataset
-            ds.with_row_proc(@dataset.row_proc)
-          else
-            super
-          end
-        end
-
-        # Return a class object.  If a class is given, return it directly.
-        # Treat strings and symbols as class names.  If nil is given or
-        # an invalid class name string or symbol is used, return self.
-        # Raise an error for other types.
-        def sti_class(v)
-          case v
-          when String, Symbol
-            constantize(v) rescue self
-          when nil
-            self
-          when Class
-            v
-          else
-            raise(Error, "Invalid class type used: #{v.inspect}")
-          end
-        end
-
-        # Use the given dataset for the subclass, with key being the allowed
-        # values for the sti_kind field.
-        def sti_subclass_dataset(key)
-          sti_dataset.where(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>Sequel.delay{Sequel.synchronize{key}})
-        end
-      end
-
-      module InstanceMethods
-        # Set the sti_key column based on the sti_key_map.
-        def before_validation
-          if new? && model.sti_key && !self[model.sti_key]
-            set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
-          end
-          super
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/sequel-5.29.0/lib/sequel/plugins/subclasses.rb

@@ -1,77 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Plugins
-    # The subclasses plugin keeps track of all subclasses of the
-    # current model class.  Direct subclasses are available via the
-    # subclasses method, and all descendent classes are available via the
-    # descendents method:
-    #
-    #   c = Class.new(Sequel::Model)
-    #   c.plugin :subclasses
-    #   sc1 = Class.new(c)
-    #   sc2 = Class.new(c)
-    #   ssc1 = Class.new(sc1)
-    #   c.subclasses    # [sc1, sc2]
-    #   sc1.subclasses  # [ssc1]
-    #   sc2.subclasses  # []
-    #   ssc1.subclasses # []
-    #   c.descendents   # [sc1, ssc1, sc2]
-    #
-    # You can also finalize the associations and then freeze the classes
-    # in all descendent classes.  Doing so is a recommended practice after
-    # all models have been defined in production and testing, and this makes
-    # it easier than keeping track of the classes to finalize and freeze
-    # manually:
-    #
-    #   c.freeze_descendants
-    #
-    # You can provide a block when loading the plugin, and it will be called
-    # with each subclass created:
-    #
-    #   a = []
-    #   Sequel::Model.plugin(:subclasses){|sc| a << sc}
-    #   class A < Sequel::Model; end
-    #   class B < Sequel::Model; end
-    #   a # => [A, B]
-    module Subclasses
-      # Initialize the subclasses instance variable for the model.
-      def self.apply(model, &block)
-        model.instance_variable_set(:@subclasses, [])
-        model.instance_variable_set(:@on_subclass, block)
-      end
-
-      module ClassMethods
-        # Callable object that should be called with every descendent
-        # class created.
-        attr_reader :on_subclass
-
-        # All subclasses for the current model.  Does not
-        # include the model itself.
-        attr_reader :subclasses
-
-        # All descendent classes of this model.
-        def descendents
-          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendents)}.flatten
-        end
-
-        # Freeze all descendent classes.  This also finalizes the associations for those
-        # classes before freezing.
-        def freeze_descendents
-          descendents.each(&:finalize_associations).each(&:freeze)
-        end
-
-        Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
-
-        # Add the subclass to this model's current subclasses,
-        # and initialize a new subclasses instance variable
-        # in the subclass.
-        def inherited(subclass)
-          super
-          Sequel.synchronize{subclasses << subclass}
-          on_subclass.call(subclass) if on_subclass
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/sequel-5.29.0/lib/sequel/timezones.rb

@@ -1,249 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  @application_timezone = nil
-  @database_timezone = nil
-  @typecast_timezone = nil
-  
-  # Sequel doesn't pay much attention to timezones by default, but you can set it
-  # handle timezones if you want.  There are three separate timezone settings, application_timezone,
-  # database_timezone, and typecast_timezone.  All three timezones have getter and setter methods.
-  # You can set all three timezones to the same value at once via <tt>Sequel.default_timezone=</tt>.
-  #
-  # The only timezone values that are supported by default are <tt>:utc</tt> (convert to UTC),
-  # <tt>:local</tt> (convert to local time), and +nil+ (don't convert).  If you need to
-  # convert to a specific timezone, or need the timezones being used to change based
-  # on the environment (e.g. current user), you need to use the +named_timezones+ extension (and use
-  # +DateTime+ as the +datetime_class+). Sequel also ships with a +thread_local_timezones+ extensions
-  # which allows each thread to have its own timezone values for each of the timezones.
-  module Timezones
-    # The timezone you want the application to use.  This is the timezone
-    # that incoming times from the database and typecasting are converted to.
-    attr_reader :application_timezone
-    
-    # The timezone for storage in the database.  This is the
-    # timezone to which Sequel will convert timestamps before literalizing them
-    # for storage in the database.  It is also the timezone that Sequel will assume
-    # database timestamp values are already in (if they don't include an offset).
-    attr_reader :database_timezone
-    
-    # The timezone that incoming data that Sequel needs to typecast
-    # is assumed to be already in (if they don't include an offset).
-    attr_reader :typecast_timezone
-  
-    %w'application database typecast'.each do |t|
-      class_eval("def #{t}_timezone=(tz); @#{t}_timezone = convert_timezone_setter_arg(tz) end", __FILE__, __LINE__)
-    end
-  
-    # Convert the given +Time+/+DateTime+ object into the database timezone, used when
-    # literalizing objects in an SQL string.
-    def application_to_database_timestamp(v)
-      convert_output_timestamp(v, Sequel.database_timezone)
-    end
-
-    # Converts the object to the given +output_timezone+.
-    def convert_output_timestamp(v, output_timezone)
-      if output_timezone
-        if v.is_a?(DateTime)
-          case output_timezone
-          when :utc
-            v.new_offset(0)
-          when :local
-            v.new_offset(local_offset_for_datetime(v))
-          else
-            convert_output_datetime_other(v, output_timezone)
-          end
-        else
-          case output_timezone
-          when :utc
-            v.getutc
-          when :local
-            v.getlocal
-          else
-            convert_output_time_other(v, output_timezone)
-          end
-        end
-      else
-        v
-      end
-    end
-    
-    # Converts the given object from the given input timezone to the
-    # +application_timezone+ using +convert_input_timestamp+ and
-    # +convert_output_timestamp+.
-    def convert_timestamp(v, input_timezone)
-      begin
-        if v.is_a?(Date) && !v.is_a?(DateTime)
-          # Dates handled specially as they are assumed to already be in the application_timezone
-          if datetime_class == DateTime
-            DateTime.civil(v.year, v.month, v.day, 0, 0, 0, application_timezone == :local ? Rational(Time.local(v.year, v.month, v.day).utc_offset, 86400) : 0)
-          else
-            Time.public_send(application_timezone == :utc ? :utc : :local, v.year, v.month, v.day)
-          end
-        else
-          convert_output_timestamp(convert_input_timestamp(v, input_timezone), application_timezone)
-        end
-      rescue InvalidValue
-        raise
-      rescue => e
-        raise convert_exception_class(e, InvalidValue)
-      end
-    end
-    
-    # Convert the given object into an object of <tt>Sequel.datetime_class</tt> in the
-    # +application_timezone+.  Used when converting datetime/timestamp columns
-    # returned by the database.
-    def database_to_application_timestamp(v)
-      convert_timestamp(v, Sequel.database_timezone)
-    end
-  
-    # Sets the database, application, and typecasting timezones to the given timezone. 
-    def default_timezone=(tz)
-      self.database_timezone = tz
-      self.application_timezone = tz
-      self.typecast_timezone = tz
-    end
-  
-    # Convert the given object into an object of <tt>Sequel.datetime_class</tt> in the
-    # +application_timezone+.  Used when typecasting values when assigning them
-    # to model datetime attributes.
-    def typecast_to_application_timestamp(v)
-      convert_timestamp(v, Sequel.typecast_timezone)
-    end
-
-    private
-
-    # Convert the given +DateTime+ to the given input_timezone, keeping the
-    # same time and just modifying the timezone.
-    def convert_input_datetime_no_offset(v, input_timezone)
-      case input_timezone
-      when nil, :utc
-        v # DateTime assumes UTC if no offset is given
-      when :local
-        offset = local_offset_for_datetime(v)
-        v.new_offset(offset) - offset
-      else
-        convert_input_datetime_other(v, input_timezone)
-      end
-    end
-
-    # Convert the given +DateTime+ to the given input_timezone that is not supported
-    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
-    # Can be overridden in extensions.
-    def convert_input_datetime_other(v, input_timezone)
-      raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
-    end
-    
-    # Convert the given +Time+ to the given input_timezone that is not supported
-    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
-    # Can be overridden in extensions.
-    def convert_input_time_other(v, input_timezone)
-      raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
-    end
-    
-    # Converts the object from a +String+, +Array+, +Date+, +DateTime+, or +Time+ into an
-    # instance of <tt>Sequel.datetime_class</tt>.  If given an array or a string that doesn't
-    # contain an offset, assume that the array/string is already in the given +input_timezone+.
-    def convert_input_timestamp(v, input_timezone)
-      case v
-      when String
-        v2 = Sequel.string_to_datetime(v)
-        if !input_timezone || Date._parse(v).has_key?(:offset)
-          v2
-        else
-          # Correct for potentially wrong offset if string doesn't include offset
-          if v2.is_a?(DateTime)
-            convert_input_datetime_no_offset(v2, input_timezone)
-          else
-            case input_timezone
-            when nil, :local
-              v2
-            when :utc
-              (v2 + v2.utc_offset).utc
-            else
-              convert_input_time_other((v2 + v2.utc_offset).utc, input_timezone)
-            end
-          end
-        end
-      when Array
-        y, mo, d, h, mi, s, ns, off = v
-        if datetime_class == DateTime
-          s += Rational(ns, 1000000000) if ns
-          if off
-            DateTime.civil(y, mo, d, h, mi, s, off)
-          else
-            convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
-          end
-        elsif off
-          s += Rational(ns, 1000000000) if ns
-          Time.new(y, mo, d, h, mi, s, (off*86400).to_i)
-        else
-          case input_timezone
-          when nil, :local
-            Time.local(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
-          when :utc
-            Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
-          else
-            convert_input_time_other(Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0)), input_timezone)
-          end
-        end
-      when Hash
-        ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
-        if (offset = (v[:offset] || v['offset']))
-          ary << offset
-        end
-        convert_input_timestamp(ary, input_timezone)
-      when Time
-        if datetime_class == DateTime
-          v.to_datetime
-        else
-          v
-        end
-      when DateTime
-        if datetime_class == DateTime
-          v
-        else
-          v.to_time
-        end
-      else
-        raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
-      end
-    end
-
-    # Convert the given +DateTime+ to the given output_timezone that is not supported
-    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
-    # Can be overridden in extensions.
-    def convert_output_datetime_other(v, output_timezone)
-      raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
-    end
-    
-    # Convert the given +Time+ to the given output_timezone that is not supported
-    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
-    # Can be overridden in extensions.
-    def convert_output_time_other(v, output_timezone)
-      raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
-    end
-    
-    # Convert the timezone setter argument.  Returns argument given by default,
-    # exists for easier overriding in extensions.
-    def convert_timezone_setter_arg(tz)
-      tz
-    end
-
-    # Takes a DateTime dt, and returns the correct local offset for that dt, daylight savings included, in fraction of a day.
-    def local_offset_for_datetime(dt)
-      time_offset_to_datetime_offset Time.local(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec).utc_offset
-    end
-
-    # Caches offset conversions to avoid excess Rational math.
-    def time_offset_to_datetime_offset(offset_secs)
-      if offset = Sequel.synchronize{@local_offsets[offset_secs]}
-        return offset
-      end
-      Sequel.synchronize{@local_offsets[offset_secs] = Rational(offset_secs, 86400)}
-    end
-  end
-
-  @local_offsets = {}
-  extend Timezones
-end