sober_swag 0.21.0 → 0.22.0

data/lib/sober_swag/reporting/input/converting/date.rb

@@ -0,0 +1,30 @@
+module SoberSwag
+  module Reporting
+    module Input
+      module Converting
+        ##
+        # Convert via a date.
+        #
+        # Note: unlike the swagger spec, we first try to convert
+        # rfc8601, then try rfc3339.
+        Date = (
+          SoberSwag::Reporting::Input::Text
+               .new
+               .mapped { |str|
+            begin
+              ::Date.rfc3339(str)
+            rescue ArgumentError
+              Report::Value.new(['was not an RFC 3339 date string'])
+            end
+          } |
+          SoberSwag::Reporting::Input::Text
+            .new
+            .mapped do |str|
+            ::Date.iso8601(str)
+          rescue ArgumentError
+            Report::Value.new(['was not an ISO8601 date string'])
+          end).format('date')
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/converting/date_time.rb

@@ -0,0 +1,28 @@
+module SoberSwag
+  module Reporting
+    module Input
+      module Converting
+        ##
+        # Convert via a date.
+        DateTime =
+          SoberSwag::Reporting::Input::Text
+          .new
+          .mapped { |str|
+            begin
+              ::DateTime.rfc3339(str)
+            rescue ArgumentError
+              Report::Value.new(['was not an RFC 3339 date-time string'])
+            end
+          }.or(
+            SoberSwag::Reporting::Input::Text
+              .new
+              .mapped do |str|
+              ::DateTime.iso8601(str)
+            rescue ArgumentError
+              Report::Value.new(['was not an ISO8601 date-time string'])
+            end
+          ).format('date-time')
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/converting/decimal.rb

@@ -0,0 +1,24 @@
+module SoberSwag
+  module Reporting
+    module Input
+      module Converting
+        ##
+        # Parse a decimal.
+        Decimal =
+          (SoberSwag::Reporting::Input::Number.new.mapped(&:to_d).format(:decimal) |
+          SoberSwag::Reporting::Input::Text
+          .new
+          .format('decimal')
+          .mapped do |v|
+            BigDecimal(v)
+          rescue ArgumentError
+            Report::Value.new('was not a decimal')
+          end).described(<<~MARKDOWN).referenced('SoberSwag.Converting.Decimal')
+            Decimal formatted input.
+            Will either convert a JSON number to a decimal, or accept a string representation.
+            The string representation allows for greater precision.
+          MARKDOWN
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/converting/integer.rb

@@ -0,0 +1,19 @@
+module SoberSwag
+  module Reporting
+    module Input
+      module Converting
+        Integer =
+          (SoberSwag::Reporting::Input.number.format('integer').mapped(&:to_i)) |
+          (SoberSwag::Reporting::Input.text.format('integer').mapped do |v|
+            Integer(v)
+          rescue ArgumentError
+            Report::Value.new(['was not an integer string'])
+          end).described(<<~MARKDOWN).referenced('SoberSwag.Converting.Integer')
+            Integer formatted input.
+
+            With either convert a JSON number to an integer, or accept a string representation of an integer.
+          MARKDOWN
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/converting.rb

@@ -0,0 +1,16 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Namespace for things that can do conversion.
+      # These are really just compound types that kinda look nice.
+      module Converting
+        autoload(:Decimal, 'sober_swag/reporting/input/converting/decimal')
+        autoload(:Date, 'sober_swag/reporting/input/converting/date')
+        autoload(:DateTime, 'sober_swag/reporting/input/converting/date_time')
+        autoload(:Bool, 'sober_swag/reporting/input/converting/bool')
+        autoload(:Integer, 'sober_swag/reporting/input/converting/integer')
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/defer.rb

@@ -0,0 +1,29 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Resolve circular references by deferring the loading of an input.
+      class Defer < Base
+        def initialize(other_lazy)
+          @other_lazy = other_lazy
+        end
+
+        attr_reader :other_lazy
+
+        def other
+          return @other if defined?(@other)
+
+          @other = other_lazy.call
+        end
+
+        def call(input)
+          other.call(input)
+        end
+
+        def swagger_schema
+          other.swagger_schema
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/described.rb

@@ -0,0 +1,38 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Node for things with descriptions.
+      # This describes the *type*, not the *object key*.
+      class Described < Base
+        def initialize(input, description)
+          @input = input
+          @description = description
+        end
+
+        ##
+        # @return [Interface] base input
+        attr_reader :input
+
+        ##
+        # @return [String] description of input
+        attr_reader :description
+
+        def call(value)
+          input.call(value)
+        end
+
+        def swagger_schema
+          val, other = input.swagger_schema
+          merged =
+            if val.key?(:$ref)
+              { allOf: [val] }
+            else
+              val
+            end.merge(description: description)
+          [merged, other]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/dictionary.rb

@@ -0,0 +1,37 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Dictionary types: string keys, something else as a value.
+      class Dictionary < Base
+        def self.of(input_type)
+          new(input_type)
+        end
+
+        def initialize(value_input)
+          @value_input = value_input
+        end
+
+        attr_reader :value_input
+
+        def call(value)
+          return Report::Base.new(['was not an object']) unless value.is_a?(Hash)
+
+          bad, good = value.map { |k, v|
+            [k, value_input.call(v)]
+          }.compact.partition { |(_, v)| v.is_a?(Report::Base) }
+
+          return Report::Object.new(bad.to_h) if bad.any?
+
+          good.to_h
+        end
+
+        def swagger_schema
+          schema, found = value_input.swagger_schema
+
+          [{ type: :object, additionalProperties: schema }, found]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/either.rb

@@ -0,0 +1,51 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Parses either one input, or another.
+      # Left-biased.
+      class Either < Base
+        ##
+        # @param lhs [Base] an input we will try first
+        # @param rhs [Base] an input we will try second
+        def initialize(lhs, rhs)
+          @lhs = lhs
+          @rhs = rhs
+        end
+
+        ##
+        # @return [Base] parser for LHS
+        attr_reader :lhs
+        ##
+        # @return [Base] parser for RHS
+        attr_reader :rhs
+
+        def call(value)
+          maybe_lhs = lhs.call(value)
+
+          return maybe_lhs unless maybe_lhs.is_a?(Report::Base)
+
+          maybe_rhs = rhs.call(value)
+
+          return maybe_rhs unless maybe_rhs.is_a?(Report::Base)
+
+          Report::Either.new(maybe_lhs, maybe_rhs)
+        end
+
+        def swagger_schema
+          lhs_val, lhs_set = lhs.swagger_schema
+          rhs_val, rhs_set = rhs.swagger_schema
+
+          val = { oneOf: defs_for(lhs_val) + defs_for(rhs_val) }
+          [val, lhs_set.merge(rhs_set)]
+        end
+
+        private
+
+        def defs_for(schema)
+          schema[:oneOf] || [schema]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/enum.rb

@@ -0,0 +1,44 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Specify that a value must be included in a list of possible values.
+      class Enum < Base
+        def initialize(input, values)
+          @input = input
+          @values = values
+        end
+
+        ##
+        # @return [Interface] base type
+        attr_reader :input
+
+        ##
+        # @return [Array<String>] acceptable types
+        attr_reader :values
+
+        def call(value)
+          inner = input.call(value)
+
+          return inner if inner.is_a?(Report::Base)
+
+          return Report::Value.new(['was not an acceptable enum member']) unless values.include?(inner)
+
+          inner
+        end
+
+        def swagger_schema
+          schema, found = input.swagger_schema
+
+          merged =
+            if schema.key?(:$ref)
+              { allOf: [schema] }
+            else
+              schema
+            end.merge(enum: values)
+          [merged, found]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/format.rb

@@ -0,0 +1,39 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Specify that something must match a particular format.
+      # Note: said format is just a string.
+      class Format < Base
+        def initialize(input, format)
+          @input = input
+          @format = format
+        end
+
+        ##
+        # @return [Interface]
+        attr_reader :input
+
+        ##
+        # @return [String]
+        attr_reader :format
+
+        def call(object)
+          input.call(object)
+        end
+
+        def swagger_schema
+          schema, found = input.swagger_schema
+
+          merged =
+            if schema.key?(:$ref)
+              { allOf: [schema] }
+            else
+              schema
+            end.merge(format: format)
+          [merged, found]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/interface.rb

@@ -0,0 +1,87 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Module for interface methods.
+      module Interface
+        ##
+        # Make a new input that is either this type or the argument.
+        #
+        # @argument other [Interface] other input type
+        # @return [Either] this input, or some other input.
+        def or(other)
+          Either.new(self, other)
+        end
+
+        ##
+        # @see {#or}
+        def |(other)
+          Either.new(self, other)
+        end
+
+        ##
+        # This, or null.
+        #
+        # @return [Either] an either type of this or nil.
+        def optional
+          self | Null.new
+        end
+
+        ##
+        # A list of this input.
+        #
+        # @return [List] the new input.
+        def list
+          List.new(self)
+        end
+
+        def referenced(name)
+          Referenced.new(self, name)
+        end
+
+        def format(format)
+          Format.new(self, format)
+        end
+
+        def described(desc)
+          Described.new(self, desc)
+        end
+
+        def enum(*cases)
+          Enum.new(self, cases)
+        end
+
+        ##
+        # Map a function after this input runs.
+        #
+        # @return [Mapped] the new input.
+        def mapped(&block)
+          Mapped.new(self, block)
+        end
+
+        def call!(value)
+          res = call(value)
+          raise Report::Error.new(res) if res.is_a?(Report::Base) # rubocop:disable Style/RaiseArgs
+
+          res
+        end
+
+        def swagger_path_schema
+          raise InvalidSchemaError::InvalidForPathError.new(self) # rubocop:disable Style/RaiseArgs
+        end
+
+        def swagger_query_schema
+          raise InvalidSchemaError::InvalidForQueryError.new(self) # rubocop:disable Style/RaiseArgs
+        end
+
+        def add_schema_key(base, addition)
+          if base.key?(:$ref)
+            { allOf: [base] }.merge(addition)
+          else
+            base.merge(addition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/list.rb

@@ -0,0 +1,44 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Class to parse an array, where each element has the same type.
+      #
+      # Called List to avoid name conflicts.
+      class List < Base
+        ##
+        # @param element [Base] the parser for elements
+        def initialize(element)
+          @element = element
+        end
+
+        ##
+        # @return [Base] the parser for elements
+        attr_reader :element
+
+        def call(value)
+          return Report::Value.new(['was not an array']) unless value.is_a?(Array)
+
+          # obtain a hash of indexes => errors
+          errs = {}
+          # yes, side effects in a map are evil, but we avoid traversal twice
+          mapped = value.map.with_index do |item, idx|
+            element.call(item).tap { |e| errs[idx] = e if e.is_a?(Report::Base) }
+          end
+
+          if errs.any?
+            Report::List.new(errs)
+          else
+            mapped
+          end
+        end
+
+        def swagger_schema
+          schema, found = element.swagger_schema
+
+          [{ type: 'list', items: schema }, found]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/mapped.rb

@@ -0,0 +1,36 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Apply a mapping function over an input.
+      class Mapped < Base
+        ##
+        # @param mapper [#call] the mapping function
+        # @param input [Base] the base input
+        def initialize(input, mapper)
+          @mapper = mapper
+          @input = input
+        end
+
+        ##
+        # @return [#call] mapping function
+        attr_reader :mapper
+        ##
+        # @return [Base] base input
+        attr_reader :input
+
+        def call(value)
+          val = input.call(value)
+
+          return val if val.is_a?(Report::Base)
+
+          mapper.call(val)
+        end
+
+        def swagger_schema
+          input.swagger_schema
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/merge_objects.rb

@@ -0,0 +1,72 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Merge two object types together, in an allof stype relationship
+      class MergeObjects < Base
+        def initialize(parent, child)
+          @parent = parent
+          @child = child
+        end
+
+        ##
+        # @return [Interface] parent type
+        attr_reader :parent
+
+        ##
+        # @return [Interface] child type
+        attr_reader :child
+
+        def call(value)
+          parent_attrs = parent.call(value)
+
+          return parent_attrs if parent_attrs.is_a?(Report::Value)
+
+          # otherwise, object type, so we want to get a full error report
+
+          child_attrs = child.call(value)
+
+          return child_attrs if child_attrs.is_a?(Report::Value)
+
+          merge_results(parent_attrs, child_attrs)
+        end
+
+        def swagger_schema
+          parent_schema, parent_found = parent.swagger_schema
+          child_schema, child_found = child.swagger_schema
+
+          [
+            {
+              allOf: (parent_schema[:allOf] || [parent_schema]) + (child_schema[:allOf] || [child_schema])
+            },
+            parent_found.merge(child_found)
+          ]
+        end
+
+        def swagger_path_schema
+          parent.swagger_path_schema + child.swagger_path_schema
+        end
+
+        def swagger_query_schema
+          parent.swagger_query_schema + child.swagger_query_schema
+        end
+
+        private
+
+        def merge_results(par, chi) # rubocop:disable Metrics/MethodLength
+          if par.is_a?(Report::Base)
+            if chi.is_a?(Report::Base)
+              Report::MergedObject.new(par, chi)
+            else
+              par
+            end
+          elsif chi.is_a?(Report::Base)
+            chi
+          else
+            par.to_h.merge(chi.to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/null.rb

@@ -0,0 +1,34 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Null input values.
+      # Validates that the input is null.
+      class Null < Base
+        def call(value)
+          return nil if value.nil?
+
+          Report::Value.new(['was not nil'])
+        end
+
+        def hash
+          [self.class.hash, 1].hash
+        end
+
+        def eql?(other)
+          other.class == self.class
+        end
+
+        def <=>(other)
+          eql?(other) ? 0 : nil
+        end
+
+        include Comparable
+
+        def swagger_schema
+          [{ type: 'null' }, {}]
+        end
+      end
+    end
+  end
+end

data/lib/sober_swag/reporting/input/number.rb

@@ -0,0 +1,19 @@
+module SoberSwag
+  module Reporting
+    module Input
+      ##
+      # Parse some kind of number.
+      class Number < Base
+        def call(input)
+          return Report::Value.new(['is not a number']) unless input.is_a?(Numeric)
+
+          input
+        end
+
+        def swagger_schema
+          [{ type: 'number' }, {}]
+        end
+      end
+    end
+  end
+end