jet-contract 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fcbe0e6e51fb3e7a5f0938d993c0b95242e0ab3a0a2f61166e71f675c242066b
+  data.tar.gz: 802842c9c22218e87e0e57ccc24d7fc00b4f4028ec526a8a74eae6f97e36e81b
+SHA512:
+  metadata.gz: ea07b6d7c5786f3b196a4dd77c812dac7fe2d500b1c86d0a11276c9ec48b49e543d361be7358f2b4ce8a1ee892799c761cf82a2e76cf2579eab74443b4a9f929
+  data.tar.gz: 765fb5fcb4db348647445aa7d6e3fa282e8b6ac1fbab0d4923a285ab63c21442834d19438c66df88bded01f569d4f002dcfac134ad2c7e9f54e698644774def1

data/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2019 Joshua Hansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# Jet: A toolkit aimed at web apps.
+
+TODO: Write.

data/lib/jet-contract.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "jet/contract"

data/lib/jet/contract.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "jet/type"
+require "jet/contract/attribute"
+
+module Jet
+  class Contract
+    FLATTEN_ERROR_TYPES = %i[
+      contract_validation_failure
+      check_each_failure
+    ].freeze
+
+    @checks = Contract::Check::BuiltIn
+    @types = Type::JSON
+
+    class << self
+      attr_reader :checks, :types
+
+      def build(*args, &blk)
+        raise ArgumentError, "no block given" unless block_given?
+        Builder.new.tap { |b| b.instance_eval(&blk) }.call(*args)
+      end
+
+      def checks!(checks)
+        validate_registry!("checks", checks, Check, :eql)
+      end
+
+      def checks=(checks)
+        @checks = checks!(checks)
+      end
+
+      def types!(types)
+        case types
+        when :http
+          Type::HTTP
+        when :json
+          Type::JSON
+        when :strict
+          Type::Strict
+        else
+          validate_registry!("types", types, Type, :string)
+        end
+      end
+
+      def types=(types)
+        @types = types!(types)
+      end
+
+      private
+
+      def validate_registry!(name, registry, type, key)
+        return registry if registry.respond_to?(:[]) && registry[key].is_a?(type)
+        raise ArgumentError, "`#{name}` must be a registry of #{type}"
+      end
+    end
+
+    def initialize(attributes, keys_in: [String, Symbol], keys_out: :to_sym, **)
+      @attributes = Jet.type_check_hash!("`attributes`", attributes, Attribute)
+                       .transform_keys(&:to_s)
+
+      @opts = { keys_in: _keys_in(keys_in), keys_out: _keys_out(keys_out) }
+    end
+
+    def call(input, **)
+      results = check_attributes(filter_keys(input.to_h))
+      failure(results, input) || success(results)
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def attributes
+      @attributes.dup
+    end
+
+    def opts
+      @opts.dup
+    end
+
+    def rebuild(*args)
+      to_builder.(*args)
+    end
+
+    def to_builder
+      Builder.new(@attributes.transform_values(&:to_builder))
+    end
+
+    def with(*other_contracts, **opts)
+      Jet.type_check_each!("`other_contracts`", other_contracts, Contract)
+
+      self.class.new(
+        other_contracts.each_with_object(attributes) { |c, atts| atts.merge!(c.attributes) },
+        **self.opts.merge(opts)
+      )
+    end
+
+    private
+
+    def _keys_in(classes)
+      Array(classes).map do |c|
+        next String if c == :string
+        next Symbol if c == :symbol
+        Jet.type_check!(":keys_in element #{c}", Class, Module)
+        c
+      end.uniq
+    end
+
+    def _keys_out(key_type)
+      if [Symbol, :symbol, :to_sym].include?(key_type)
+        :to_sym
+      elsif [String, :string, :to_s].include?(key_type)
+        :to_s
+      else
+        raise ArgumentError, ":keys_out must equal either :symbol or :string"
+      end
+    end
+
+    def check_attributes(input)
+      @attributes.each_with_object({}) do |(k, att), h|
+        if input.key?(k)
+          h[k] = att.(input[k], k.to_sym)
+        else
+          next if att.optional?
+          h[k] = Result.failure(:key_missing_failure, at: k.to_sym)
+        end
+      end
+    end
+
+    def failure(results, input)
+      return unless results.values.any?(&:failure?)
+      Result.failure(
+        :contract_validation_failure,
+        errors: flatten_errors(results.values),
+        input: input
+      )
+    end
+
+    def filter_keys(input)
+      input.select { |k, _| @opts[:keys_in].any? { |t| k.is_a?(t) } }
+           .transform_keys(&:to_s)
+           .select { |k, _| attributes.keys.include?(k) }
+    end
+
+    def flatten_errors(results)
+      results.select(&:failure?).each_with_object([]) do |r, errs|
+        next errs.concat(flatten_errors(r.errors)) if FLATTEN_ERROR_TYPES.include?(r.output)
+        errs << r
+      end
+    end
+
+    def success(results)
+      results
+        .each_with_object({}) { |(k, r), h| h[k.send(opts[:keys_out])] = r.output }
+        .yield_self { |output| Result.success(output) }
+    end
+  end
+end
+
+require "jet/contract/builder"

data/lib/jet/contract/attribute.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "jet/contract/check"
+require "jet/contract/check/set"
+
+module Jet
+  class Contract
+    class Attribute
+      attr_reader :checks, :type
+
+      def self.build(*args, &blk)
+        raise ArgumentError, "no block given" unless block_given?
+        Builder.new.instance_eval(&blk).call(*args)
+      end
+
+      def initialize(type, checks = nil, contract: nil, each: nil, required: true, **)
+        @type = Jet.type_check!("`type`", type, Type)
+        @checks = Jet.type_check!("`checks`", checks, Check::Set, NilClass)
+
+        raise ArgumentError, "cannot set both :contract and :each" if contract && each
+
+        @opts = {
+          contract: Jet.type_check!(":contract", contract, Contract, NilClass),
+          each: Jet.type_check!(":each", each, Attribute, NilClass),
+          required: required ? true : false
+        }
+      end
+
+      def call(input, at = [])
+        coerce(input).yield_self { |r| result_at(Jet.failure?(r) ? r : check(r.output), at) }
+      end
+
+      def check(output)
+        return Result.success if output.nil?
+        checks&.(output)&.tap { |r| return r if r.failure? }
+        check_contract(output) || check_each(output) || Result.success(output)
+      end
+
+      def coerce(input)
+        type.(input)
+      end
+
+      def is?
+        !maybe?
+      end
+
+      def maybe?
+        type.maybe?
+      end
+
+      def optional?
+        !required?
+      end
+
+      def opts
+        @opts.dup
+      end
+
+      def required?
+        @opts[:required]
+      end
+
+      def to_builder
+        Builder.new(
+          checks: @checks&.to_builder,
+          contract: @opts[:contract]&.to_builder,
+          each: @opts[:each]&.to_builder,
+          is: is?,
+          required: required?,
+          type: type.name
+        )
+      end
+
+      def to_sym
+        name
+      end
+
+      private
+
+      def check_contract(output)
+        @opts[:contract]&.(output)
+      end
+
+      def check_each(output)
+        return unless @opts[:each]
+        results = output.map.with_index { |v, i| @opts[:each].(v).with(at: [i]) }
+        return Result.success(results.map(&:output)) if results.all?(&:success?)
+        Result.failure(
+          :check_each_failure,
+          errors: results.select(&:failure?),
+          input: output
+        )
+      end
+
+      def result_at(result, at)
+        new_at = Array(at) + Array(result.at)
+        result.with(
+          at: new_at,
+          errors: result.errors.map { |r| result_at(r, new_at) }
+        )
+      end
+    end
+  end
+end
+
+require "jet/contract/attribute/builder"

data/lib/jet/contract/attribute/builder.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Jet
+  class Contract
+    class Attribute
+      class Builder
+        def initialize(opts = {})
+          @opts = { required: true }.merge(opts)
+          checks(opts[:checks]) if opts[:checks]
+          contract(opts[:contract]) if opts[:contract]
+          each(*opts[:each]) if opts[:each]
+        end
+
+        def call(types = nil, checks = nil)
+          types = types.nil? ? Contract.types : Contract.types!(types)
+          checks = checks.nil? ? Contract.checks : Contract.checks!(checks)
+
+          Attribute.new(
+            type_with(types),
+            check_set_with(checks),
+            contract: @opts[:contract]&.(types, checks),
+            each: @opts[:each]&.(types, checks),
+            required: @opts[:required]
+          )
+        end
+
+        def checks(checks)
+          @opts[:checks] = checks.each_with_object([]) do |check, a|
+            case check
+            when Hash
+              check.each { |(k, v)| a << [k.to_sym, v] }
+            when Array
+              a << [check.first.to_sym].concat(check[1..-1])
+            else
+              a << [check.to_sym]
+            end
+          end
+          self
+        end
+
+        def contract(contract = nil, &blk)
+          raise ArgumentError, "cannot provide :contract if :each is set" if @opts[:each]
+          auto_type!("contract", :hash)
+          raise ArgumentError, "must provide either `contract` or a block" unless
+            !contract.nil? ^ block_given?
+
+          @opts[:contract] =
+            if block_given?
+              Contract::Builder.new.tap { |b| b.instance_eval(&blk) }
+            else
+              Jet.type_check!(":contract", contract, Contract, Contract::Builder)
+            end
+          self
+        end
+
+        def each(*args, &blk)
+          raise ArgumentError, "cannot provide :each if :contract is set" if @opts[:contract]
+          auto_type!("each", :array)
+          raise ArgumentError, "must provide either `args` or a block" unless
+            args.any? ^ block_given?
+
+          @opts[:each] =
+            if block_given?
+              self.class.new.instance_eval(&blk)
+            elsif args.size == 1 && args.first.is_a?(self.class)
+              args.first
+            else
+              self.class.new.is(*args)
+            end
+          self
+        end
+
+        def is(type, *checks)
+          @opts[:maybe] = false
+          type(type, *checks)
+          self
+        end
+
+        def maybe(type, *checks)
+          @opts[:maybe] = true
+          type(type, *checks)
+          self
+        end
+
+        def type(type, *checks)
+          @opts[:type] = Jet.type_check!("`type`", type, Symbol, Type).to_sym
+          checks(checks)
+          self
+        end
+
+        def opts
+          @opts.dup
+        end
+
+        private
+
+        def auto_type!(method, type)
+          type(type) unless @opts[:type]
+          raise ArgumentError, "##{method} can only be used with type :#{type}" unless
+            @opts[:type] == type
+          type
+        end
+
+        def check_set_with(checks)
+          return unless @opts[:checks]&.any?
+          Check::Set.new(*@opts[:checks].map { |name, *args| [checks[name]].concat(args) })
+        end
+
+        def type_with(types)
+          type = types.fetch(@opts[:type].to_sym)
+          return type.maybe if @opts[:maybe]
+          raise "#{type.inspect} is a maybe? type (hint: use #maybe instead of #is)" if
+            type.maybe?
+          type
+        end
+      end
+    end
+  end
+end

data/lib/jet/contract/builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jet
+  class Contract
+    class Builder
+      attr_reader :checks, :types
+
+      def initialize(attribute_builders = {})
+        @attribute_builders = attribute_builders.dup
+      end
+
+      def [](key)
+        @attribute_builders[key]
+      end
+
+      def call(*args)
+        Contract.new(@attribute_builders.transform_values { |ab| ab.(*args) })
+      end
+
+      def attribute_builders
+        @attribute_builders.dup
+      end
+      alias to_h attribute_builders
+
+      def optional(key)
+        attribute_builder(key, false)
+      end
+
+      def required(key)
+        attribute_builder(key, true)
+      end
+
+      private
+
+      def attribute_builder(key, required)
+        @attribute_builders[key.to_sym] = Attribute::Builder.new(required: required)
+      end
+    end
+  end
+end

data/lib/jet/contract/check.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Jet
+  class Contract
+    class Check
+      def self.[](key)
+        BuiltIn[key]
+      end
+
+      attr_reader :check, :name
+
+      def initialize(name, &check)
+        raise ArgumentError, "no block given" unless block_given?
+        @check = lambda(&check)
+        @name = name
+      end
+
+      def call(output, *args)
+        result = check.(output, *args)
+        return Result.success(output, args: args) if Jet.success?(result)
+        Result.failure(error(result), Jet.context(result, args: args, input: output))
+      end
+
+      def inspect
+        "#<#{self.class.name}:#{name}>"
+      end
+
+      def to_sym
+        name
+      end
+
+      private
+
+      def error(result)
+        [:check_failure, name].tap { |errors| errors << result.output if result }
+      end
+
+      module BuiltIn
+        extend Core::InstanceRegistry
+        type Check
+
+        [
+          Check.new(:any?, &:any?),
+          Check.new(:empty?, &:empty?),
+          Check.new(:eql) { |output, other| output == other },
+          Check.new(:gt) { |output, other| output > other },
+          Check.new(:gte) { |output, other| output >= other },
+          Check.new(:in) { |output, collection| collection.include?(output) },
+          Check.new(:lt) { |output, other| output < other },
+          Check.new(:lte) { |output, other| output <= other },
+          Check.new(:match) { |output, regex| output.match?(regex) },
+          Check.new(:max_size) { |output, size| output.size <= size },
+          Check.new(:min_size) { |output, size| output.size >= size },
+          Check.new(:negative?, &:negative?),
+          Check.new(:nin) { |output, collection| !collection.include?(output) },
+          Check.new(:not) { |output, other| output != other },
+          Check.new(:positive?, &:positive?),
+          Check.new(:size) do |output, size_or_range|
+            case size_or_range
+            when Range
+              return true if size_or_range.include?(output.size)
+              Result.failure(:range, max: size_or_range.max, min: size_or_range.min)
+            else
+              return true if output.size == size_or_range
+              Result.failure(:exact, size: size_or_range)
+            end
+          end
+        ].map { |c| [c.name, c] }.to_h.tap { |checks| register(checks).freeze }
+      end
+    end
+  end
+end

data/lib/jet/contract/check/set.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jet
+  class Contract
+    class Check
+      class Set
+        attr_reader :checks
+
+        def initialize(*checks)
+          @checks = []
+          checks.each { |c| add!(c) }
+          @checks.freeze
+        end
+
+        def call(output)
+          @checks.each do |(check, *args)|
+            check.(output, *args).tap { |r| return r if Jet.failure?(r) }
+          end
+          Result.success(output)
+        end
+
+        def to_builder
+          @checks.map { |(c, *args)| [c.name].concat(args) }
+        end
+
+        private
+
+        def add!(check)
+          case check
+          when Array
+            add_with_args!(check.first, *check[1..-1])
+          when Hash
+            check.each { |c, args| add_with_args!(c, args) }
+          when Check
+            add_with_args!(check)
+          else
+            Jet.type_check!(check.inspect, check, Array, Hash, Check)
+          end
+          @checks
+        end
+
+        def add_with_args!(check, *args)
+          Jet.type_check!(check.inspect, check, Check)
+          @checks << [check].concat(args)
+        end
+      end
+    end
+  end
+end

data/lib/jet/contract/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jet
+  class Contract
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    VERSION = [MAJOR, MINOR, TINY].join(".").freeze
+
+    def self.version
+      VERSION
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: jet-contract
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua
+- Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jet-type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+description: Input validation DSL and support classes for the Jet Toolkit.
+email:
+- joshua@epicbanality.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/jet-contract.rb
+- lib/jet/contract.rb
+- lib/jet/contract/attribute.rb
+- lib/jet/contract/attribute/builder.rb
+- lib/jet/contract/builder.rb
+- lib/jet/contract/check.rb
+- lib/jet/contract/check/set.rb
+- lib/jet/contract/version.rb
+homepage: https://github.com/binarypaladin/jet-contract
+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.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Input validation DSL and support classes for the Jet Toolkit.
+test_files: []