infer-type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d42e183dada37127aec852bd61db28217f0f3cd2
+  data.tar.gz: 4d7944e9b781eb03cdc2ecd60babec1a76c2394c
+SHA512:
+  metadata.gz: 6bc5121ea29c3fbd4b5002f1f46d6a25a713edbc730c219766125e54747ddb730b1bc2a6cbd7bcca9871be704cd1f205abc9781751f47a6975df1ebdd8f0075a
+  data.tar.gz: 01a7fd3195f626a76c21e568d5bab630b6c01f5bd60e29ca1f792819b7e6502bed5ac7614d3cef1419e7509b07809dcfe1e51fe4a665974cbd0a6dbb0eeee023

data/lib/infer_type/parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module InferType
+	# Base class for parsers
+	class Parser
+		class << self
+			# Method to specify or retrieve the type this parser detects
+			def detects(type = nil)
+				if type
+					raise ArgumentError, "detects cannot be String" if type == String
+					raise ArgumentError, "detects must be a Class" unless type.is_a?(Class)
+					@detects = type
+				end
+
+				@detects
+			end
+		end
+
+		# Subclasses must implement this method
+		def parse(_str)
+			raise NotImplementedError
+		end
+
+		private
+
+		# Methods to create success and failure results
+		def success(value)
+			InferType::Success.new(
+				value: value,
+				parser: self.class
+			)
+		end
+
+		def failure
+			InferType::Failure.new(parser: self.class)
+		end
+	end
+end
+

data/lib/infer_type/parsers/date.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "date"
+
+module InferType
+	module Parsers
+		class DateParser < InferType::Parser
+			detects Date
+
+			DATE_FORMAT = %r<
+				\A
+				(?<date>
+					(?<year>  \d{4}   ) -
+					(?<month> [0-1]\d ) -
+					(?<day>   [0-3]\d )
+				)
+				\z
+			>x.freeze
+
+			def parse(str)
+				candidate = str.strip
+				return failure if candidate.empty?
+				
+				# Looks like a Date
+				return failure unless match = candidate.match(DATE_FORMAT)
+
+				# Pre-validate to avoid Date.new being too lax
+
+				# Attempt to parse the date
+				year = match['year'].to_i
+				month = match['month'].to_i
+				day = match['day'].to_i
+				return failure unless Date.valid_date?(year, month, day)
+
+				# Attempt conversion
+				begin
+					value = Date.new(year, month, day)
+					return failure unless value.year == year && value.month == month && value.day == day
+				rescue ArgumentError
+					return failure
+				end
+
+				success(value)
+			end
+		end
+	end
+end
+

data/lib/infer_type/parsers/false.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InferType
+	module Parsers
+		class FalseParser < InferType::Parser
+			detects FalseClass
+
+			FALSE_STRINGS = ['false', 'no', 'off', 'n'].freeze
+
+			# If true, only use the first false string
+			STRICT = true
+
+			# If true, case sensitive
+			CASE_SENSITIVE = false
+
+			def parse(str)
+				candidate = str.strip
+				candidate = candidate.downcase if !CASE_SENSITIVE
+				return failure if candidate.empty?
+
+				if STRICT
+					return success(false) if candidate == FALSE_STRINGS.first
+				else
+					return success(false) if FALSE_STRINGS.include?(candidate)
+				end
+
+				failure
+			end
+		end
+	end
+end

data/lib/infer_type/parsers/float.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module InferType
+	module Parsers
+		class FloatParser < InferType::Parser
+			detects Float
+
+			# If false, "1" is NOT considered a Float (must be "1.0" etc.)
+			ALLOW_INTEGER = true
+
+			# Allow exponential notation like 1e3 or 1.5E-2
+			ALLOW_EXPONENTIAL = true
+
+			# Allow special values: NaN, Infinity
+			ALLOW_SPECIAL_VALUES = false
+
+			FLOAT_NO_EXP_REGEX = /\A[+-]?(?:\d+\.\d*|\.\d+)\z/
+			FLOAT_WITH_EXP_REGEX = /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)[eE][+-]?\d+\z/
+
+			def parse(str)
+				candidate = str.strip
+				return failure if candidate.empty?
+
+				# Check for exact special value string
+				if ["NaN", "Infinity", "-Infinity"].include?(candidate)
+					if ALLOW_SPECIAL_VALUES
+						return success(Float(candidate))
+					else
+						return failure
+					end
+				end
+
+				# Check for integer if allowed
+				if ALLOW_INTEGER
+					InferType::Parsers::IntegerParser.new.parse(candidate).tap do |result|
+						if result.parsed
+							# Return it as a float
+							return success(result.value.to_f)
+						end
+					end
+				end
+
+				# Check for float format
+				looks_float_no_exp = !candidate.match(FLOAT_NO_EXP_REGEX).nil?
+				looks_float_with_exp = ALLOW_EXPONENTIAL && !candidate.match(FLOAT_WITH_EXP_REGEX).nil?
+				looks_float = looks_float_no_exp || looks_float_with_exp
+
+				return failure unless looks_float
+
+				# Attempt conversion
+				begin
+					value = Float(candidate)
+				rescue ArgumentError
+					return failure
+				end
+
+				success(value)
+			end
+		end
+	end
+end

data/lib/infer_type/parsers/integer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module InferType
+	module Parsers
+		class IntegerParser < InferType::Parser
+			detects Integer
+
+			# Allow numbers with leading zeros like "00001" = 1
+			ALLOW_LEADING_ZERO = true
+
+			# Allow leading plus sign
+			ALLOW_LEADING_PLUS = true
+
+			INTEGER_REGEX = /\A-?\d+\z/
+
+			def parse(str)
+				candidate = str.strip
+				return failure if candidate.empty?
+
+				# Prepare the candidate for parsing
+				candidate = clean(candidate)
+
+				# Should now match integer format
+				return failure unless !candidate.match(INTEGER_REGEX).nil?
+
+				# Attempt conversion
+				begin
+					value = Integer(candidate, 10)
+					return failure unless value.to_s == candidate
+				rescue ArgumentError
+					return failure
+				end
+
+				success(value)
+			end
+
+			private
+
+			def clean(str)
+				clean = str.dup.strip
+				return clean if clean.empty?
+
+				# Remove leading +
+				if ALLOW_LEADING_PLUS
+					clean = clean.sub(/\A\+/, '')
+				end
+
+				# Preserve a single zero when the string is all zeros
+				if !clean.match(/\A-?0+\z/).nil?
+					return '0' # -0 is equivalent to 0
+				end
+
+				# Remove leading zeros
+				if ALLOW_LEADING_ZERO
+					clean = clean.sub(/\A(-)?0+/, '\1')
+				end
+
+				clean
+			end
+		end
+	end
+end
+

data/lib/infer_type/parsers/nil.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InferType
+	module Parsers
+		class NilParser < InferType::Parser
+			detects NilClass
+
+			NIL_STRINGS = ['nil', 'null', 'nothing', 'undefined', 'none'].freeze
+
+			# If true, only use the first nil string
+			STRICT = true
+
+			# If true, case sensitive
+			CASE_SENSITIVE = false
+
+			def parse(str)
+				candidate = str.strip
+				candidate = candidate.downcase if !CASE_SENSITIVE
+				return failure if candidate.empty?
+
+				if STRICT
+					return success(nil) if candidate == NIL_STRINGS.first
+				else
+					return success(nil) if NIL_STRINGS.include?(candidate)
+				end
+
+				failure
+			end
+		end
+	end
+end

data/lib/infer_type/parsers/time.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "time"
+require "date"
+
+module InferType
+	module Parsers
+		class TimeParser < InferType::Parser
+			detects Time
+
+			# If timezone offset is missing from a Time string, assume UTC
+			# If false, the system's local timezone will be used
+			DEFAULT_UTC = true
+
+			TIME_FORMAT = %r<
+				\A
+				(?<date>
+					(?<year>   \d{4}   ) -
+					(?<month>  [0-1]\d ) -
+					(?<day>    [0-3]\d )
+				)
+				(T|\s)
+				(?<time>
+					(?<hour>     [0-2]\d ) \:
+					(?<minute>   [0-5]\d )
+					(\:
+						(?<second> [0-5]\d )
+						([\.,]
+							(?<subs> \d{1,9} )
+						)?
+					)?
+				)
+				(?<offset>
+					(?<sign>   [+\-]   )
+					(?<offh>   [0-2]\d ) \:?
+					(?<offm>   [0-5]\d )
+					|
+					(?<offz>  Z | \s?UTC )
+				)?
+				\z
+			>x.freeze
+
+			def parse(str)
+				candidate = str.strip
+				return failure if candidate.empty?
+				
+				# Looks like a Time
+				return failure unless match = candidate.match(TIME_FORMAT)
+				
+				# Pre-validate to avoid Time.new being too lax
+
+				# Attempt to parse date
+				year = match['year'].to_i
+				month = match['month'].to_i
+				day = match['day'].to_i
+				return failure unless Date.valid_date?(year, month, day)
+
+				# Attempt to parse time
+				hour = match['hour'].to_i
+				minute = match['minute'].to_i
+				return failure unless hour.between?(0, 23) && minute.between?(0, 59)
+				if match['second']
+					second = match['second'].to_i
+					return failure unless second.between?(0, 59)
+				else
+					second = 0
+				end
+
+				# Add on subseconds if they were present
+				if match['subs']
+					begin
+						subs = ("0." + match['subs']).to_f
+						second += subs
+					rescue ArgumentError
+						return failure
+					end
+				end
+
+				# Was there an offset?
+				if match['offset'] && !match['offz']	
+					sign = match['sign']
+					offh = match['offh'].to_i
+					offm = match['offm'].to_i
+					return failure unless (offh.between?(0, 13) && offm.between?(0, 59)) || (offh == 14 && offm == 0) # maximum 14 hour offsets
+				else
+					if DEFAULT_UTC || match['offz']
+						sign = "+"
+						offh = 0
+						offm = 0
+					end
+				end
+				if sign && offh && offm
+					offset = format("%<sign>s%<offh>02d:%<offm>02d", sign: sign, offh: offh, offm: offm)
+				else
+					offset = nil
+				end
+
+				# Attempt conversion
+				begin
+					args = [year, month, day, hour, minute, second]
+					args << offset if offset
+					value = Time.new(*args)
+					return failure unless value.year == year && value.mon == month && value.day == day
+					return failure unless value.hour == hour && value.min == minute
+					return failure unless second.to_r == value.sec + value.subsec
+					return failure unless value.utc_offset == (offh * 3600 + offm * 60) * (sign == "-" ? -1 : 1) if offset
+				rescue ArgumentError
+					return failure
+				end
+
+				success(value)
+			end
+		end
+	end
+end
+

data/lib/infer_type/parsers/true.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InferType
+	module Parsers
+		class TrueParser < InferType::Parser
+			detects TrueClass
+
+			TRUE_STRINGS = ['true', 'yes', 'on', 'y'].freeze
+
+			# If true, only use the first true string
+			STRICT = true
+
+			# If true, case sensitive
+			CASE_SENSITIVE = false
+
+			def parse(str)
+				candidate = str.strip
+				candidate = candidate.downcase if !CASE_SENSITIVE
+				return failure if candidate.empty?
+
+				if STRICT
+					return success(true) if candidate == TRUE_STRINGS.first
+				else
+					return success(true) if TRUE_STRINGS.include?(candidate)
+				end
+
+				failure
+			end
+		end
+	end
+end

data/lib/infer_type/registry.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module InferType
+	class Registry
+		def initialize
+			@parsers = []
+		end
+
+		def parsers
+			@parsers.dup
+		end
+
+		def parser_for_type(type)
+			@parsers.find { |parser| parser.detects == type }
+		end
+
+		# Methods to manage parser registration
+		def register(parser_class)
+			validate_parser_class!(parser_class)
+
+			type = parser_class.detects
+			existing_index = @parsers.index { |parser| parser.detects == type }
+
+			if existing_index
+				old = @parsers[existing_index]
+				@parsers[existing_index] = parser_class
+				return old
+			end
+
+			# Last registered has lowest priority
+			@parsers << parser_class
+			nil
+		end
+
+		def deregister(parser_classes)
+			Array(parser_classes).each do |klass|
+				@parsers.delete(klass)
+			end
+		end
+
+		# Methods to manage parser priority
+		def prioritize(*items)
+			reorder(items, to_front: true)
+		end
+
+		def deprioritize(*items)
+			reorder(items, to_front: false)
+		end
+
+		private
+
+		# Ensure parser class being registered is valid
+		def validate_parser_class!(parser_class)
+			unless parser_class.is_a?(Class) && parser_class < InferType::Parser
+				raise ArgumentError, "Parser must subclass InferType::Parser"
+			end
+
+			type = parser_class.detects
+			raise ArgumentError, "Parser must declare the type it detects" if type.nil?
+
+			unless type.is_a?(Class) && !type.is_a?(String)
+				raise ArgumentError, "Parser must detect a Class (other than String)"
+			end
+
+			unless parser_class.instance_methods(false).include?(:parse)
+				raise ArgumentError, "Parser must define #parse(str)"
+			end
+
+			arity = parser_class.instance_method(:parse).arity
+			unless arity == 1 || arity == -2
+				raise ArgumentError, "#parse must accept exactly one argument"
+			end
+		end
+
+		# Normalize parser class or type to parser class
+		def normalize(items)
+			Array(items).map do |item|
+				if item.is_a?(Class) && item < InferType::Parser
+					item
+				elsif item.is_a?(Class)
+					parser = parser_for_type(item)
+					raise KeyError, "No parser registered for type #{item}" if parser.nil?
+					parser
+				else
+					raise ArgumentError, "Expected parser class or type class"
+				end
+			end
+		end
+
+		# Reorder parsers to front or back
+		def reorder(items, to_front:)
+			targets = normalize(items)
+			remaining = @parsers.reject { |p| targets.include?(p) }
+
+			@parsers =
+				if to_front
+					targets + remaining
+				else
+					remaining + targets
+				end
+		end
+	end
+end
+

data/lib/infer_type/result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module InferType
+	class Result
+		attr_reader :parsed, :value, :parser
+		def initialize(parsed: nil, value: nil, parser: nil)
+			@parsed = parsed
+			@value = value
+			@parser = parser
+		end
+	end
+
+	class Success < Result
+		def initialize(value: nil, parser: nil)
+			raise TypeError, "Parser returned a type other than the type it detects" if !value.is_a?(parser.detects)
+			super(parsed: true, value: value, parser: parser)
+		end
+	end
+
+	class Failure < Result
+		def initialize(parser: nil)
+			super(parsed: false, parser: parser)
+		end
+	end
+end
+

data/lib/infer_type.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "infer_type/result"
+require_relative "infer_type/parser"
+require_relative "infer_type/registry"
+
+module InferType
+	class << self
+
+		# Whether to strip input strings before parsing
+		STRIP = true
+
+		# Primary method to parse a string into a type
+		def parse(_input, *allowed_types)
+			raise ArgumentError, "Can only parse Strings" unless _input.is_a?(String)
+
+			# Prepare the string
+			str = _input.dup
+			str = str.strip if STRIP
+
+			# Select appropriate parsers
+			parsers = select_parsers(allowed_types)
+
+			# Try each parser
+			parsers.each do |parser_class|
+				result = parser_class.new.parse(str)
+				raise TypeError, "Parser (#{parser_class}) must return a Result object using success(value) or failure() methods" unless result.is_a?(InferType::Result)
+				# Return as soon as one succeeds
+				return result.value if result.parsed
+			end
+
+			# All parsers failed: return the original input
+			_input
+		end
+
+		# Parser registration methods
+		def register(parser_class)
+			registry.register(parser_class)
+		end
+
+		def deregister(parser_classes)
+			registry.deregister(parser_classes)
+		end
+		alias unregister deregister
+
+		def prioritise(*items)
+			registry.prioritize(*items)
+		end
+		alias prioritize prioritise
+
+		def deprioritise(*items)
+			registry.deprioritize(*items)
+		end
+		alias deprioritize deprioritise
+		alias unprioritise deprioritise
+		alias unprioritize deprioritise
+
+		private
+
+		def registry
+			@registry ||= InferType::Registry.new
+		end
+
+		# Select parsers in priority order
+		def select_parsers(allowed_types)
+			all = registry.parsers
+			return all if allowed_types.empty?
+
+			# Allowed types have been specified
+			allowed_types = allowed_types.flatten
+			type_priority = {}
+
+			allowed_types.each_with_index do |type, index|
+				parser = registry.parser_for_type(type)
+				raise KeyError, "No parser registered for class #{type}" if parser.nil?
+				type_priority[type] = index
+			end
+
+			selected = all.select { |parser| type_priority.key?(parser.detects) }
+
+			# Override registry priority using allowed_types order
+			selected.sort_by { |parser| type_priority[parser.detects] }
+		end
+	end
+end
+
+# Load all built-in parsers
+Dir.glob(File.join(__dir__, "infer_type/parsers/*.rb")).each do |file|
+	require_relative file
+end
+
+InferType.register(InferType::Parsers::IntegerParser)
+InferType.register(InferType::Parsers::FloatParser)
+InferType.register(InferType::Parsers::TrueParser)
+InferType.register(InferType::Parsers::FalseParser)
+InferType.register(InferType::Parsers::NilParser)
+InferType.register(InferType::Parsers::DateParser)
+InferType.register(InferType::Parsers::TimeParser)
+

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: infer-type
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Convincible
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.17.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.17.3
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+description: If a string is a representation of another class, such as "1", converts
+  it to that other class. Works for basic Ruby types and can be extended.
+email:
+- development@convincible.media
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/infer_type.rb
+- lib/infer_type/parser.rb
+- lib/infer_type/parsers/date.rb
+- lib/infer_type/parsers/false.rb
+- lib/infer_type/parsers/float.rb
+- lib/infer_type/parsers/integer.rb
+- lib/infer_type/parsers/nil.rb
+- lib/infer_type/parsers/time.rb
+- lib/infer_type/parsers/true.rb
+- lib/infer_type/registry.rb
+- lib/infer_type/result.rb
+homepage: https://github.com/ConvincibleMedia/infer-type
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.0
+signing_key:
+specification_version: 4
+summary: Convert strings to other classes by inference.
+test_files: []