alchemrest 3.1.0

data/lib/alchemrest/transforms/constraint/is_uuid.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class IsUuid < MatchesRegex
+        REGEX = /\A((?:\h{8})-(?:\h{4})-(?:\h{4})-(?:\h{4})-(?:\h{12}))\z/
+
+        def initialize
+          super(REGEX)
+        end
+
+        def description
+          "is a UUID string"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint/less_than.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class LessThan < self
+        include Concord.new(:value)
+
+        def meets_conditions?(input)
+          input < value
+        end
+
+        def description
+          "less than #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint/less_than_or_eq.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class LessThanOrEq < self
+        include Concord.new(:value)
+
+        def meets_conditions?(input)
+          input <= value
+        end
+
+        def description
+          "less than or equal to #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint/matches_regex.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class MatchesRegex < self
+        include Concord.new(:regex)
+
+        def meets_conditions?(input)
+          input.match?(regex)
+        end
+
+        def description
+          "matches #{regex.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint/max_length.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class MaxLength < self
+        include Concord.new(:max_length)
+
+        def meets_conditions?(input)
+          input.length <= max_length
+        end
+
+        def description
+          "max length of #{max_length}"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint/min_length.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Constraint
+      class MinLength < self
+        include Concord.new(:min_length)
+
+        def meets_conditions?(input)
+          input.length >= min_length
+        end
+
+        def description
+          "min length of #{min_length}"
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    # The Alchemrest::Transforms::Constraint class is an abstract base that all other constraints should inherit from
+    # A constraint is basically just a predicate with metadata. The `meets_conditions?` method is the actual predicate,
+    # and description is a human-readable phrase that describes that predicate. We recommend using a phrase that will
+    # read well in a sentence like "<input> does not meet the constraint <description>", since that is how it will
+    # display in error messages
+    class Constraint
+      include AbstractType
+
+      abstract_method :meets_conditions?
+      abstract_method :description
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint_builder/for_number.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class ConstraintBuilder
+      class ForNumber < self
+        CONSTRAINT_METHODS = %i(greater_than less_than greater_than_or_eq less_than_or_eq positive non_negative integer).freeze
+
+        def greater_than(...) = apply_constraint(Constraint::GreaterThan.new(...))
+
+        def less_than(...) = apply_constraint(Constraint::LessThan.new(...))
+
+        def greater_than_or_eq(...) = apply_constraint(Constraint::GreaterThanOrEq.new(...))
+
+        def less_than_or_eq(...) = apply_constraint(Constraint::LessThanOrEq.new(...))
+
+        def positive = apply_constraint(Constraint::GreaterThan.new(0))
+
+        def non_negative = apply_constraint(Constraint::GreaterThanOrEq.new(0))
+
+        def integer = apply_constraint(Constraint::IsInstanceOf.new(Integer))
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint_builder/for_string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class ConstraintBuilder
+      class ForString < self
+        CONSTRAINT_METHODS = %i(max_length min_length matches in must_be_uuid).freeze
+
+        def max_length(...) = apply_constraint(Constraint::MaxLength.new(...))
+
+        def min_length(...) = apply_constraint(Constraint::MinLength.new(...))
+
+        def matches(...) = apply_constraint(Constraint::MatchesRegex.new(...))
+
+        def in(...) = apply_constraint(Constraint::InList.new(...))
+
+        def must_be_uuid = apply_constraint(Constraint::IsUuid.new)
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/constraint_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class ConstraintBuilder
+      include Concord.new(:constrainable)
+
+      private
+
+      def apply_constraint(constraint)
+        constrainable.where(constraint)
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/date_transform.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module Alchemrest
+  module Transforms
+    class DateTransform < Morpher::Transform
+      def call(input)
+        if input.instance_of?(String)
+          begin
+            success(Date.iso8601(input))
+          rescue ArgumentError
+            not_a_valid_iso_date_string(input)
+          end
+        else
+          not_a_valid_iso_date_string(input)
+        end
+      end
+
+      def not_a_valid_iso_date_string(input)
+        failure(
+          error(
+            message: "Expected #{input} to be an iso date string",
+            input: input,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/enum.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class Enum < Morpher::Transform
+      include Concord.new(:values)
+
+      private_constant(*constants(false))
+
+      def call(input)
+        case values
+          when ::Hash
+            evaluate_hash(input)
+          when ::Array
+            evaluate_array(input)
+          else
+            failure_error(input)
+        end
+      end
+
+      private
+
+      def evaluate_array(input)
+        if values.include?(input)
+          success(input)
+        elsif input.is_a?(String) && values.include?(input.to_sym)
+          success(input.to_sym)
+        else
+          failure_error(input)
+        end
+      end
+
+      def evaluate_hash(input)
+        value = values[input]
+        if value
+          success(value)
+        else
+          failure_error(input)
+        end
+      end
+
+      def failure_error(input)
+        failure(
+          error(
+            message: "Expected: enum value from #{values} but got: #{input.inspect}",
+            input: input,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/epoch_time.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module Alchemrest
+  module Transforms
+    class EpochTime < Morpher::Transform
+      include Concord.new(:unit)
+
+      def call(input)
+        if input.is_a?(Integer)
+          as_seconds = case unit
+                         when :seconds
+                           input
+                         when :milliseconds
+                           input / 1000
+                         else
+                           raise "Invalid unit #{unit}"
+                       end
+          success(Time.at(as_seconds).in_time_zone("UTC"))
+        else
+          failure(
+            error(
+              message: "Expected #{input} to be an epoch integer",
+              input: input,
+            ),
+        )
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_chain.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    module FromChain
+      def self.number
+        FromNumber.new
+      end
+
+      def self.string
+        FromString.new
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_number/to_type_transform_registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class FromNumber
+      class ToTypeTransformRegistry < BaseToTypeTransformRegistry
+        def build_transforms
+          {
+            Money => {
+              cents: [MoneyTransform.new(:cents)],
+              dollars: [MoneyTransform.new(:dollars)],
+            },
+          }
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_number.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class FromNumber < FromType
+      OVERRIDES = { type: T.any(Integer, Float) }.freeze
+      CONSTRAINT_BUILDER_CLASS = ConstraintBuilder::ForNumber
+
+      def initialize(args = {})
+        super(**args, **OVERRIDES)
+      end
+
+      def where(constraint_or_description = nil, &block)
+        if constraint_or_description
+          super
+        elsif block
+          raise ArgumentError, "Must provide a constraint or description"
+        else
+          self
+        end
+      end
+
+      def output_type_name
+        "Number"
+      end
+
+      delegate(*CONSTRAINT_BUILDER_CLASS::CONSTRAINT_METHODS, to: :constraint_builder)
+
+      private
+
+      def constraint_builder
+        CONSTRAINT_BUILDER_CLASS.new(self)
+      end
+
+      def transform
+        Sequence.new([
+          JsonNumber.new,
+          validate_constraints,
+        ])
+      end
+
+      memoize def to_type_transform_registry
+        ToTypeTransformRegistry.new(self)
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_string/to_type_transform_registry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class FromString
+      class ToTypeTransformRegistry < BaseToTypeTransformRegistry
+        def build_transforms
+          {
+            Time => ToType::FromStringToTimeSelector.new(from),
+            Date => [DateTransform.new],
+            BigDecimal => [ToDecimal.new],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_string.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class FromString < FromType
+      OVERRIDES = { type: String }.freeze
+      CONSTRAINT_BUILDER_CLASS = ConstraintBuilder::ForString
+
+      def initialize(args = {})
+        super(**args, **OVERRIDES)
+      end
+
+      def where(constraint_or_description = nil, &block)
+        if constraint_or_description
+          super
+        elsif block
+          raise ArgumentError, "Must provide a constraint or description"
+        else
+          self
+        end
+      end
+
+      delegate(*CONSTRAINT_BUILDER_CLASS::CONSTRAINT_METHODS, to: :constraint_builder)
+
+      private
+
+      def constraint_builder
+        CONSTRAINT_BUILDER_CLASS.new(self)
+      end
+
+      def to_type_transform_registry
+        ToTypeTransformRegistry.new(self)
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_type/empty_to_type_transform_registry.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class FromType
+      class EmptyToTypeTransformRegistry < BaseToTypeTransformRegistry
+        # mutant:disable
+        def build_transforms
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/from_type.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    # Base class for transforms where we want to validate that the input is a particular
+    # type before operating on it. Additional validations can be chained off by use of the
+    # #where method. On success this transform will return the input, unchanged. For a transform
+    # that will actually change the input into something else, you can call #to and pass a block
+    # which will return a `ToType` transform that will run this transform, and then your block.
+    class FromType < Morpher::Transform
+      include Alchemrest::Transforms::Constrainable.new(additional_attributes: %i(type))
+      include Adamantium::Mutable
+      DEFAULTS = { constraints: [] }.freeze
+
+      def initialize(args)
+        super(**DEFAULTS.merge(args))
+      end
+
+      def output_type
+        OutputType.new(sorbet_type: type, constraints:)
+      end
+
+      def output_type_name
+        type.name
+      end
+
+      def call(input)
+        transform.call(input)
+      end
+
+      def to(type, &block)
+        if block.nil?
+          to_type_transform_registry.resolve(type)
+        else
+          ToType.using(to: type, from: self, &block)
+        end
+      rescue Alchemrest::NoRegisteredTransformError
+        raise ArgumentError,
+          "No transform registered to transform #{output_type.sorbet_type} to #{type}. Perhaps you should use the block form?"
+      end
+
+      def array
+        Typed.new(transform: super(), output_type: output_type.with(sorbet_type: T::Array[output_type.sorbet_type]))
+      end
+
+      def maybe
+        Typed.new(transform: super(), output_type: output_type.with(sorbet_type: T.nilable(output_type.sorbet_type)))
+      end
+
+      private
+
+      memoize def to_type_transform_registry
+        EmptyToTypeTransformRegistry.new(self)
+      end
+
+      def transform
+        Sequence.new([
+          Primitive.new(type),
+          validate_constraints,
+        ])
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/iso_time.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module Alchemrest
+  module Transforms
+    class IsoTime < Morpher::Transform
+      include Anima.new(:to_timezone, :require_offset)
+
+      def call(input)
+        return not_a_valid_iso_string(input) unless input.instance_of?(String)
+        return missing_required_offset(input) unless has_offset?(input) || !require_offset
+
+        begin
+          success(parse(input))
+        rescue ArgumentError
+          not_a_valid_iso_string(input)
+        end
+      end
+
+      private
+
+      def parse(input)
+        if to_timezone
+          ActiveSupport::TimeZone[to_timezone].iso8601(input)
+        else
+          Time.iso8601(input)
+        end
+      end
+
+      def has_offset?(input)
+        parts = input.split("T")
+        time = parts.last
+        # checking for an offset
+
+        /[Z+-]/.match?(time)
+      end
+
+      def missing_required_offset(input)
+        failure(
+          error(
+            message: "Expected #{input} to have a valid ISO timezone offset",
+            input: input,
+          ),
+        )
+      end
+
+      def not_a_valid_iso_string(input)
+        failure(
+          error(
+            message: "Expected #{input} to be iso datetime string",
+            input: input,
+          ),
+      )
+      end
+    end
+  end
+end

data/lib/alchemrest/transforms/json_number.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module Transforms
+    class JsonNumber < Morpher::Transform
+      def call(input)
+        if input.instance_of?(Integer) || input.instance_of?(Float)
+          success(input)
+        else
+          failure_error(input)
+        end
+      end
+
+      private
+
+      def failure_error(input)
+        failure(
+          error(
+            message: "Expected: Float, Integer but got #{input.class}",
+            input:,
+          ),
+        )
+      end
+    end
+  end
+end