jet-type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa0ae83d7ac14ae3dfa9a513e9767dab4ec2fbdca0c28a6383a7d3ea81414347
+  data.tar.gz: 4620b255cab2acb2563fa2ce71d9c75fb7fa80e131bc6a7127cba9613551e3fe
+SHA512:
+  metadata.gz: 86d97024d6cb5535cacc7714639b718dd96716fb00341da8474aeaf94b150102bcc7636d027dabcc425263e8fdefebfc2fc37543d75671338c4a226b710bbe7d
+  data.tar.gz: 8a4e0eecea09ce47a7c2204da5bf4ebf6e0d50f47484d80c621ad8229ed18beacf5629bdff6d6ee524a0412bb9bc5530dbf7f4517578857953d0a77f3e077113

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 Types: Safe Type Coercion for the Jet Toolkit
+
+TODO: Write.

data/lib/jet-type.rb

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

data/lib/jet/type.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "jet/core"
+require "jet/type/coercion"
+require "jet/type/version"
+
+module Jet
+  class Type
+    def self.with(type, *types, name: nil, &blk)
+      Jet.type_check!("`type`", type, Type)
+      new(
+        name || type.name,
+        *[type.types, types].flatten.uniq,
+        coercions: type.coercions,
+        filter: type.filter,
+        &blk
+      )
+    end
+
+    attr_reader :coercions, :name, :types
+
+    def initialize(name, *types, coercions: [], filter: nil, &blk)
+      @name = name.to_sym
+      @coercions = coercions.dup
+      @filter = filter
+      @types = Jet.type_check_each!("`types`", types, Class, Module)
+      instance_eval(&blk) if block_given?
+      @coercions.freeze
+    end
+
+    def call(input)
+      return process_output(input) if type_match?(input)
+
+      @coercions.each do |coercion|
+        result = coercion.(input)
+        return process_output(result.output) if result.success?
+        return result if result.failure? && result != :no_coercion_match
+      end
+
+      failure(input: input)
+    end
+
+    def filter(callable = nil, &blk)
+      return @filter unless callable || block_given?
+      @filter = Core.block_or_callable!(callable, &blk)
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{name}>"
+    end
+
+    def maybe
+      @maybe ||= maybe? ? self : self.class.with(self, NilClass)
+    end
+
+    def maybe?
+      types.include?(NilClass)
+    end
+
+    def to_sym
+      name
+    end
+
+    def type_match?(obj)
+      types.any? { |t| obj.is_a?(t) }
+    end
+
+    private
+
+    def coerce(at = :after, &blk)
+      coercion = Coercion.new(&blk)
+      if at == :before
+        @coercions = [coercion] + coercions
+      elsif at == :after
+        @coercions += [coercion]
+      else
+        raise ArgumentError, "`at` must equal :before or :after"
+      end
+    end
+
+    def failure(error = :type_coercion_failure, **context)
+      Result.failure([error, name], context.merge(types: types))
+    end
+
+    def process_output(output)
+      output &&= @filter ? @filter.(output) : output
+      return failure(output: output) unless type_match?(output)
+      Result.success(output)
+    end
+  end
+end
+
+require "jet/core/instance_registry"
+require "jet/type/strict"
+require "jet/type/http"
+require "jet/type/json"

data/lib/jet/type/coercion.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Jet
+  class Type
+    class Coercion
+      def initialize(&blk)
+        raise ArgumentError, "no block given" unless block_given?
+        @checks = []
+        @matchers = []
+        instance_eval(&blk)
+        raise ArgumentError, "no `match` blocks given" if @matchers.empty?
+        @checks = @checks.freeze
+        @matchers.freeze
+        @transformer ||= proc { |input| input }
+      end
+
+      def call(input)
+        return Result.failure(:no_coercion_match, input: input) unless match?(input)
+
+        catch(:transformation_failure) do
+          check_output(input, instance_exec(input, &@transformer))
+        end
+      end
+
+      def check_output(input, output)
+        @checks.each do |(check, error)|
+          return coercion_check_failure(output, input, error) unless check.(output, input)
+        end
+        Result.success(output, input: input)
+      end
+
+      def coercion_check_failure(output, input, error)
+        Result.failure(:coercion_check_failure, errors: error, input: input, output: output)
+      end
+
+      def match?(output)
+        @matchers.any? { |blk| blk.(output) }
+      end
+
+      def transformation_failure(input, *errors)
+        Result.failure(:transformation_failure, errors: errors, input: input)
+      end
+
+      def transformation_failure!(*args)
+        throw :transformation_failure, transformation_failure(*args)
+      end
+
+      private
+
+      def check(error = nil, &blk)
+        @checks += [[blk, error]]
+      end
+
+      def match(&blk)
+        @matchers += [blk]
+      end
+
+      def transform(&blk)
+        @transformer = blk
+      end
+    end
+  end
+end

data/lib/jet/type/http.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Jet
+  class Type
+    module HTTP
+      extend Core::InstanceRegistry
+      type Type
+
+      module Matcher
+        Numeric = proc do |input|
+          input.is_a?(::String) && input.match?(/\A-?\d+(\.\d+)?\Z/)
+        end
+      end
+
+      DATE_PATTERN = /\d{4}(-\d{2}){2}/.freeze
+      TIME_PATTERN = /(\d{2}:){2}\d{2}(\.0{1-3})?(Z?|[-+]\d{2}:\d{2})?/.freeze
+      DATETIME_PATTERN = /#{DATE_PATTERN}[ T]#{TIME_PATTERN}/.freeze
+
+      FALSE_VALUES = %w[0 f false F FALSE n no N NO].freeze
+      TRUE_VALUES = %w[1 t true T TRUE y yes Y YES].freeze
+
+      Boolean = Type.with(Strict::Boolean) do
+        coerce do
+          match { |input| TRUE_VALUES.any? { |v| input == v } }
+          transform { true }
+        end
+
+        coerce do
+          match { |input| FALSE_VALUES.any? { |v| input == v } }
+          transform { false }
+        end
+      end
+
+      Date = Type.with(Strict::Date) do
+        coerce do
+          match { |input| input.is_a?(String) && input.match?(/\A#{DATE_PATTERN}\Z/) }
+
+          transform do |input|
+            args = input.split("-").map(&:to_i)
+            transformation_failure!(input, :invalid_date) unless ::Date.valid_date?(*args)
+            ::Date.new(*args)
+          end
+        end
+      end
+
+      Decimal = Type.with(Strict::Decimal) do
+        coerce do
+          match(&Matcher::Numeric)
+          transform { |input| BigDecimal(input) }
+        end
+      end
+
+      Float = Type.with(Strict::Float) do
+        coerce do
+          match(&Matcher::Numeric)
+          transform(&:to_f)
+        end
+      end
+
+      Integer = Type.with(Strict::Integer) do
+        coerce do
+          match { |input| input.is_a?(::String) && input.match?(/\A-?\d+(\.0+)?\Z/) }
+          transform(&:to_i)
+        end
+      end
+
+      Time = Type.with(Strict::Time) do
+        coerce do
+          match { |input| input.is_a?(String) && input.match?(/\A#{DATETIME_PATTERN}\Z/) }
+
+          transform do |input|
+            date, time = input.split(/[ T]/)
+            date_args = date.split("-").map(&:to_i)
+            transformation_failure!(input, :invalid_date) unless ::Date.valid_date?(*date_args)
+
+            h = time[0..1].to_i
+            transformation_failure!(input, :invalid_hours) if h > 24
+            m = time[3..4].to_i
+            transformation_failure!(input, :invalid_minutes) if m > 59
+            s = time[6..7].to_i
+            transformation_failure!(input, :invalid_seconds) if s > 59
+
+            offset =
+              if (idx = time.index(/[-+]/))
+                time[idx..-1].tap do |o|
+                  transformation_failure!(input, :invalid_utc_offest) if
+                    !%w[00 15 30 45].include?(o[4..5]) || o[1..2].to_i > 12
+                end
+              else
+                "+00:00"
+              end
+
+            ::Time.new(*date_args, h, m, s, offset)
+          end
+        end
+      end
+
+      register(
+        **Strict.to_h,
+        boolean: Boolean,
+        date: Date,
+        decimal: Decimal,
+        float: Float,
+        integer: Integer,
+        time: Time
+      ).freeze
+    end
+  end
+end

data/lib/jet/type/json.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Jet
+  class Type
+    module JSON
+      extend Core::InstanceRegistry
+      type Type
+
+      module Matcher
+        SUPPORTED_NUMERICS = [::BigDecimal, ::Float, ::Integer].freeze
+
+        Numeric = proc do |input|
+          SUPPORTED_NUMERICS.any? { |type| input.is_a?(type) }
+        end
+      end
+
+      Decimal = Type.with(HTTP::Decimal) do
+        coerce(:before) do
+          match(&Matcher::Numeric)
+          transform do |input|
+            case input
+            when ::Float
+              BigDecimal(input, ::Float::DIG)
+            else
+              BigDecimal(input)
+            end
+          end
+        end
+      end
+
+      Float = Type.with(Strict::Float) do
+        coerce do
+          match(&Matcher::Numeric)
+          transform(&:to_f)
+        end
+      end
+
+      Integer = Type.with(Strict::Integer) do
+        coerce do
+          match(&Matcher::Numeric)
+          transform(&:to_i)
+          check(:number_too_precise) { |output, input| input == output }
+        end
+      end
+
+      register(
+        **HTTP.to_h,
+        decimal: Decimal,
+        float: Float,
+        integer: Integer
+      ).freeze
+    end
+  end
+end

data/lib/jet/type/strict.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "time"
+
+module Jet
+  class Type
+    module Strict
+      extend Core::InstanceRegistry
+      type Type
+
+      [
+        Array = Type.new(:array, ::Array),
+        Boolean = Type.new(:boolean, TrueClass, FalseClass),
+        Date = Type.new(:date, ::Date),
+        Decimal = Type.new(:decimal, BigDecimal),
+        Float = Type.new(:float, ::Float),
+        Hash = Type.new(:hash, ::Hash),
+        Integer = Type.new(:integer, ::Integer),
+        String = Type.new(:string, ::String),
+        Time = Type.new(:time, ::Time)
+      ].map { |t| [t.name, t] }.to_h.tap { |types| register(types).freeze }
+    end
+  end
+end

data/lib/jet/type/version.rb

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

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: jet-type
+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-core
+  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: Safe type coercion for the Jet Toolkit.
+email:
+- joshua@epicbanality.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/jet-type.rb
+- lib/jet/type.rb
+- lib/jet/type/coercion.rb
+- lib/jet/type/http.rb
+- lib/jet/type/json.rb
+- lib/jet/type/strict.rb
+- lib/jet/type/version.rb
+homepage: https://github.com/binarypaladin/jet-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.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: Safe type coercion for the Jet Toolkit.
+test_files: []