ovirt_metrics 1.4.0 → 3.0.2

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/date_time.rb

@@ -1,21 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class DateTime < Type::DateTime # :nodoc:
-          def cast_value(value)
-            case value
-            when 'infinity' then ::Float::INFINITY
-            when '-infinity' then -::Float::INFINITY
-            when / BC$/
-              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
-              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
-            else
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/decimal.rb

@@ -1,13 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Decimal < Type::Decimal # :nodoc:
-          def infinity(options = {})
-            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/enum.rb

@@ -1,19 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Enum < Type::Value # :nodoc:
-          def type
-            :enum
-          end
-
-          private
-
-          def cast_value(value)
-            value.to_s
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/hstore.rb

@@ -1,59 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Hstore < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
-
-          def type
-            :hstore
-          end
-
-          def deserialize(value)
-            if value.is_a?(::String)
-              ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == 'NULL' ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
-                [k, v]
-              }]
-            else
-              value
-            end
-          end
-
-          def serialize(value)
-            if value.is_a?(::Hash)
-              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
-            else
-              value
-            end
-          end
-
-          def accessor
-            ActiveRecord::Store::StringKeyedHashAccessor
-          end
-
-          private
-
-          HstorePair = begin
-            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-          end
-
-          def escape_hstore(value)
-            if value.nil?
-              'NULL'
-            else
-              if value == ""
-                '""'
-              else
-                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/inet.rb

@@ -1,13 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Inet < Cidr # :nodoc:
-          def type
-            :inet
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/json.rb

@@ -1,10 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Json < Type::Internal::AbstractJson
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/jsonb.rb

@@ -1,23 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Jsonb < Json # :nodoc:
-          def type
-            :jsonb
-          end
-
-          def changed_in_place?(raw_old_value, new_value)
-            # Postgres does not preserve insignificant whitespaces when
-            # round-tripping jsonb columns. This causes some false positives for
-            # the comparison here. Therefore, we need to parse and re-dump the
-            # raw value here to ensure the insignificant whitespaces are
-            # consistent with our encoder's output.
-            raw_old_value = serialize(deserialize(raw_old_value))
-            super(raw_old_value, new_value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/money.rb

@@ -1,39 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Money < Type::Decimal # :nodoc:
-          def type
-            :money
-          end
-
-          def scale
-            2
-          end
-
-          def cast_value(value)
-            return value unless ::String === value
-
-            # Because money output is formatted according to the locale, there are two
-            # cases to consider (note the decimal separators):
-            #  (1) $12,345,678.12
-            #  (2) $12.345.678,12
-            # Negative values are represented as follows:
-            #  (3) -$2.55
-            #  (4) ($2.55)
-
-            value.sub!(/^\((.+)\)$/, '-\1') # (4)
-            case value
-            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, '')
-            when /^-?\D+[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
-            end
-
-            super(value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/point.rb

@@ -1,43 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Point < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
-
-          def type
-            :point
-          end
-
-          def cast(value)
-            case value
-            when ::String
-              if value[0] == '(' && value[-1] == ')'
-                value = value[1...-1]
-              end
-              cast(value.split(','))
-            when ::Array
-              value.map { |v| Float(v) }
-            else
-              value
-            end
-          end
-
-          def serialize(value)
-            if value.is_a?(::Array)
-              "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
-            else
-              super
-            end
-          end
-
-          private
-
-          def number_for_point(number)
-            number.to_s.gsub(/\.0$/, '')
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/rails_5_1_point.rb

@@ -1,50 +0,0 @@
-module ActiveRecord
-  Point = Struct.new(:x, :y)
-
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Rails51Point < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
-
-          def type
-            :point
-          end
-
-          def cast(value)
-            case value
-            when ::String
-              if value[0] == '(' && value[-1] == ')'
-                value = value[1...-1]
-              end
-              x, y = value.split(",")
-              build_point(x, y)
-            when ::Array
-              build_point(*value)
-            else
-              value
-            end
-          end
-
-          def serialize(value)
-            if value.is_a?(ActiveRecord::Point)
-              "(#{number_for_point(value.x)},#{number_for_point(value.y)})"
-            else
-              super
-            end
-          end
-
-          private
-
-          def number_for_point(number)
-            number.to_s.gsub(/\.0$/, '')
-          end
-
-          def build_point(x, y)
-            ActiveRecord::Point.new(Float(x), Float(y))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/range.rb

@@ -1,93 +0,0 @@
-require 'active_support/core_ext/string/filters'
-
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Range < Type::Value # :nodoc:
-          attr_reader :subtype, :type
-          delegate :user_input_in_time_zone, to: :subtype
-
-          def initialize(subtype, type = :range)
-            @subtype = subtype
-            @type = type
-          end
-
-          def type_cast_for_schema(value)
-            value.inspect.gsub('Infinity', '::Float::INFINITY')
-          end
-
-          def cast_value(value)
-            return if value == 'empty'
-            return value unless value.is_a?(::String)
-
-            extracted = extract_bounds(value)
-            from = type_cast_single extracted[:from]
-            to = type_cast_single extracted[:to]
-
-            if !infinity?(from) && extracted[:exclude_start]
-              raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
-            end
-            ::Range.new(from, to, extracted[:exclude_end])
-          end
-
-          def serialize(value)
-            if value.is_a?(::Range)
-              from = type_cast_single_for_database(value.begin)
-              to = type_cast_single_for_database(value.end)
-              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
-            else
-              super
-            end
-          end
-
-          def ==(other)
-            other.is_a?(Range) &&
-              other.subtype == subtype &&
-              other.type == type
-          end
-
-          def map(value) # :nodoc:
-            new_begin = yield(value.begin)
-            new_end = yield(value.end)
-            ::Range.new(new_begin, new_end, value.exclude_end?)
-          end
-
-          private
-
-          def type_cast_single(value)
-            infinity?(value) ? value : @subtype.deserialize(value)
-          end
-
-          def type_cast_single_for_database(value)
-            infinity?(value) ? '' : @subtype.serialize(value)
-          end
-
-          def extract_bounds(value)
-            from, to = value[1..-2].split(',')
-            {
-              from:          (value[1] == ',' || from == '-infinity') ? infinity(negative: true) : from,
-              to:            (value[-2] == ',' || to == 'infinity') ? infinity : to,
-              exclude_start: (value[0] == '('),
-              exclude_end:   (value[-1] == ')')
-            }
-          end
-
-          def infinity(negative: false)
-            if subtype.respond_to?(:infinity)
-              subtype.infinity(negative: negative)
-            elsif negative
-              -::Float::INFINITY
-            else
-              ::Float::INFINITY
-            end
-          end
-
-          def infinity?(value)
-            value.respond_to?(:infinite?) && value.infinite?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/specialized_string.rb

@@ -1,15 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class SpecializedString < Type::String # :nodoc:
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/type_map_initializer.rb

@@ -1,109 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        # This class uses the data from PostgreSQL pg_type table to build
-        # the OID -> Type mapping.
-        #   - OID is an integer representing the type.
-        #   - Type is an OID::Type object.
-        # This class has side effects on the +store+ passed during initialization.
-        class TypeMapInitializer # :nodoc:
-          def initialize(store)
-            @store = store
-          end
-
-          def run(records)
-            nodes = records.reject { |row| @store.key? row['oid'].to_i }
-            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
-            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r'.freeze }
-            enums, nodes = nodes.partition { |row| row['typtype'] == 'e'.freeze }
-            domains, nodes = nodes.partition { |row| row['typtype'] == 'd'.freeze }
-            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in'.freeze }
-            composites, nodes = nodes.partition { |row| row['typelem'].to_i != 0 }
-
-            mapped.each     { |row| register_mapped_type(row)    }
-            enums.each      { |row| register_enum_type(row)      }
-            domains.each    { |row| register_domain_type(row)    }
-            arrays.each     { |row| register_array_type(row)     }
-            ranges.each     { |row| register_range_type(row)     }
-            composites.each { |row| register_composite_type(row) }
-          end
-
-          def query_conditions_for_initial_load(type_map)
-            known_type_names = type_map.keys.map { |n| "'#{n}'" }
-            known_type_types = %w('r' 'e' 'd')
-            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
-              WHERE
-                t.typname IN (%s)
-                OR t.typtype IN (%s)
-                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
-                OR t.typelem != 0
-            SQL
-          end
-
-          private
-          def register_mapped_type(row)
-            alias_type row['oid'], row['typname']
-          end
-
-          def register_enum_type(row)
-            register row['oid'], OID::Enum.new
-          end
-
-          def register_array_type(row)
-            register_with_subtype(row['oid'], row['typelem'].to_i) do |subtype|
-              OID::Array.new(subtype, row['typdelim'])
-            end
-          end
-
-          def register_range_type(row)
-            register_with_subtype(row['oid'], row['rngsubtype'].to_i) do |subtype|
-              OID::Range.new(subtype, row['typname'].to_sym)
-            end
-          end
-
-          def register_domain_type(row)
-            if base_type = @store.lookup(row["typbasetype"].to_i)
-              register row['oid'], base_type
-            else
-              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
-            end
-          end
-
-          def register_composite_type(row)
-            if subtype = @store.lookup(row['typelem'].to_i)
-              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
-            end
-          end
-
-          def register(oid, oid_type = nil, &block)
-            oid = assert_valid_registration(oid, oid_type || block)
-            if block_given?
-              @store.register_type(oid, &block)
-            else
-              @store.register_type(oid, oid_type)
-            end
-          end
-
-          def alias_type(oid, target)
-            oid = assert_valid_registration(oid, target)
-            @store.alias_type(oid, target)
-          end
-
-          def register_with_subtype(oid, target_oid)
-            if @store.key?(target_oid)
-              register(oid) do |_, *args|
-                yield @store.lookup(target_oid, *args)
-              end
-            end
-          end
-
-          def assert_valid_registration(oid, oid_type)
-            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
-            oid.to_i
-          end
-        end
-      end
-    end
-  end
-end