bm-typed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28fd1838d9a1659a003182955c8bb7d72e15cd231a0d68ab536373b188d200dc
+  data.tar.gz: f40f3685b87a1271f2d516ca9b0718f5543da5422f106bf27d81f42404bf6dfc
+SHA512:
+  metadata.gz: d9d8e1a676753700e5301b84ebc14d0c63593958b6ff71e997e08d9053049956a34700bd566441b96e0048918bd6ad95bae7fae723be1d9c031edc36c59dee50
+  data.tar.gz: e28ef39291fb44dd1f75e72773288c12d61c77aeab0d0d6be97aa4567e342bc0491dbbb731410a406113f23fbe191b7654f97730502f9dd41b8d951eaa3e1e22

data/lib/typed/builder.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'dry-logic'
+require 'dry/logic/rule_compiler'
+require 'dry/logic/predicates'
+
+module Typed
+    module Builder
+        # Entrypoint
+        def self.any
+            AnyHandler.instance
+        end
+
+        Result = ::Struct.new(:ok, :value, :message)
+        class Result
+            attr_reader :ok, :value
+
+            def initialize(ok, value, message)
+                @ok = ok
+                @value = value
+                @failure_block = message
+            end
+
+            def message
+                @message ||= @failure_block.call
+            end
+
+            class << self
+                def success(value)
+                    new(true, value, nil)
+                end
+
+                def failure(&failure_block)
+                    new(false, nil, failure_block)
+                end
+            end
+        end
+
+        module BaseType
+            def nullable
+                Typed.null | self
+            end
+
+            def missable
+                Typed.value(Undefined) | self
+            end
+
+            def default(new_value = Typed::Undefined, &block)
+                call(new_value) unless block
+                block ||= -> { new_value }
+                DefaultType.new(self) { call(block.call) }
+            end
+
+            def instance(expected_class)
+                dry_constrained(type: expected_class)
+            end
+
+            def enum(*values)
+                dry_constrained(included_in: values.map { |value| call(value) })
+            end
+
+            def |(other)
+                expected_type other
+
+                SumType.new(self, other)
+            end
+
+            def constructor(input: Typed.any, swallow: [], &block)
+                expected_type(input)
+                return self unless block_given?
+
+                CoerceType.new(input, self, swallow, &block)
+            end
+
+            def dry_constrained(**options)
+                predicate = ::Dry::Logic::RuleCompiler.new(::Dry::Logic::Predicates).call(
+                    options.map { |key, val|
+                        ::Dry::Logic::Rule::Predicate.new(
+                            ::Dry::Logic::Predicates[:"#{key}?"]
+                        ).curry(val).to_ast
+                    }
+                ).reduce(:and)
+
+                constrained do |value|
+                    "#{value.inspect} violates #{predicate}" unless predicate.call(value).success?
+                end
+            end
+
+            def constrained(&constraint)
+                return self unless constraint
+
+                ConstrainedType.new(self, &constraint)
+            end
+
+            def call(*args)
+                result = process((args + [Typed::Undefined]).first)
+                return result.value if result.ok
+
+                raise InvalidValue, result.message
+            end
+
+            def process(value)
+                Typed::Builder::Result.success(value)
+            end
+
+            private
+
+            def expected_type(type)
+                raise InvalidType, "Not a Typed type: #{type.inspect}" unless type.is_a?(BaseType)
+            end
+        end
+
+        class ArrayType
+            include BaseType
+
+            def initialize(element_type)
+                @element_type = element_type
+            end
+
+            def process(value)
+                return Result.failure { "Invalid collection: #{value.inspect}" } unless value.respond_to?(:each)
+
+                new_value = []
+
+                value.each do |element|
+                    element_result = element_type.process(element)
+                    return element_result unless element_result.ok
+
+                    new_value << element_result.value
+                end
+
+                Result.success(new_value)
+            end
+
+            private
+
+            attr_reader :base_type, :element_type
+        end
+
+        class ConstrainedType
+            include BaseType
+
+            def initialize(base_type, &constraint)
+                @base_type = base_type
+                @constraint = constraint
+            end
+
+            def process(value)
+                result = base_type.process(value)
+                return result unless result.ok
+
+                error = constraint.call(result.value)
+                return result unless error
+
+                Result.failure { error }
+            end
+
+            private
+
+            attr_reader :base_type, :constraint
+        end
+
+        class DefaultType
+            include BaseType
+
+            def initialize(base_type, &default_value)
+                @base_type = base_type
+                @default_value = default_value
+            end
+
+            def process(value)
+                new_value = Typed::Undefined.equal?(value) ? default_value.call : value
+                base_type.process(new_value)
+            end
+
+            private
+
+            attr_reader :default_value, :base_type
+        end
+
+        class SumType
+            include BaseType
+
+            def initialize(type_a, type_b)
+                @type_a = type_a
+                @type_b = type_b
+            end
+
+            def process(value)
+                result = type_a.process(value)
+                return result if result.ok
+
+                type_b.process(value)
+            end
+
+            private
+
+            attr_reader :type_a, :type_b
+        end
+
+        class CoerceType
+            include BaseType
+
+            def initialize(input_type, return_type, swallow, &coercion)
+                @input_type = input_type
+                @return_type = return_type
+                @coercion = coercion
+                @swallow = swallow
+            end
+
+            def process(value)
+                # No coercion needed
+                passthrough_result = return_type.process(value)
+                return passthrough_result if passthrough_result.ok
+
+                # Check input_type enables this coercion
+                input_result = input_type.process(value)
+
+                if input_result.ok
+                    coerced_value =
+                        begin
+                            coercion.call(input_result.value)
+                        rescue *swallow
+                            input_result.value
+                        end
+                    return return_type.process(coerced_value)
+                end
+
+                passthrough_result
+            end
+
+            private
+
+            attr_reader :input_type, :return_type, :coercion, :swallow
+        end
+    end
+end

data/lib/typed/struct.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Typed
+    class Struct
+        # TODO: This has nothing to do in this gem, should be moved to application
+        class Updater
+            attr_reader :params, :target
+
+            def initialize(target, params)
+                @target = target
+                @params = params
+            end
+
+            def assign(from, to: from, &value_builder)
+                check_from(from)
+                return unless params.key?(from)
+
+                input_value = params[from]
+                default_getter = proc { input_value }
+                processed_value = (value_builder || default_getter).call(input_value)
+                target.send("#{to}=", processed_value)
+            end
+
+            private
+
+            def check_from(from)
+                return if params.class.schema.key?(from)
+
+                raise "Key #{from.inspect} does not exist on #{params.class}"
+            end
+        end
+
+        class << self
+            include Builder::BaseType
+
+            def attribute(name, type = Typed.any)
+                expected_type(type)
+
+                name = name.to_sym
+
+                raise Typed::InvalidType, "Property already defined: #{name}" if typed_attributes.key?(name)
+
+                typed_attributes[name] = type
+                define_method(name) { @_data.fetch(name) { Typed::Undefined } }
+            end
+
+            def schema
+                @schema ||= ancestors.select { |a| Typed::Struct > a }.reverse.reduce({}) { |acc, clazz|
+                    acc.merge(clazz.typed_attributes)
+                }.freeze
+            end
+
+            def allow_extra_keys(new_flag)
+                define_singleton_method(:allow_extra_keys?) { new_flag }
+            end
+
+            def allow_extra_keys?
+                true
+            end
+
+            def typed_attributes
+                @typed_attributes ||= {}
+            end
+
+            def process(data)
+                result = parse_as_hash(data)
+                result.ok ? Typed::Builder::Result.success(new(result)) : result
+            end
+
+            def parse_as_hash(input_data)
+                return Typed::Builder::Result.success(input_data.to_h) if input_data.is_a?(self)
+
+                # TODO: remove this hack
+                unless input_data.is_a?(::Hash) || input_data.class.name == 'ActionController::Parameters'
+                    return Typed::Builder::Result.failure { "Expected Hash, got #{input_data.inspect}" }
+                end
+
+                # Start by creating a new "clean" hash from input
+                # This way, we can easily handle some variants (ActionController::Parameters, ...)
+                clean_data = Hash.new { ::Typed::Undefined }
+                input_data.each { |key, value| clean_data[key.to_sym] = value }
+
+                # Check presence of extra keys
+                extra_property = (clean_data.keys - schema.keys).first
+                if extra_property && !allow_extra_keys?
+                    return Typed::Builder::Result
+                        .failure("Unknown property '#{extra_property}' of #{inspect}")
+                end
+
+                # Construct the final hash which will be stored internally to represent
+                # Struct's data.
+                output = schema.each_with_object({}) { |(name, type), acc|
+                    result = type.process(clean_data[name])
+
+                    unless result.ok
+                        return Typed::Builder::Result.failure {
+                            "Invalid property '#{name}' of #{inspect}: #{result.message}"
+                        }
+                    end
+
+                    acc[name] = result.value unless Typed::Undefined.equal?(result.value)
+                }.freeze
+
+                Typed::Builder::Result.success(output)
+            end
+        end
+
+        def updater(target)
+            Updater.new(target, self)
+        end
+
+        def inspect
+            attrs = self.class.schema.keys.map { |key| " #{key}=#{@_data[key].inspect}" }.join
+            "#<#{self.class.name || self.class.inspect}#{attrs}>"
+        end
+
+        def to_h
+            @_data
+        end
+
+        def [](key)
+            raise Typed::InvalidType, "Unknown property: #{key.inspect}" unless self.class.schema.key?(key)
+
+            @_data.fetch(key) { Typed::Undefined }
+        end
+
+        def ==(other)
+            return true if other.equal?(self)
+            return false unless other.instance_of?(self.class)
+
+            @_data == other.instance_variable_get(:@_data)
+        end
+
+        def hash
+            @_data.hash
+        end
+
+        def key?(key)
+            @_data.key?(key)
+        end
+
+        def initialize(input_data = {})
+            case input_data
+            when Typed::Builder::Result then initialize_from_result(input_data)
+            else initialize_from_result(self.class.parse_as_hash(input_data))
+            end
+        end
+
+        private
+
+        def initialize_from_result(result)
+            raise Typed::InvalidValue, result.message unless result.ok
+
+            @_data = result.value
+        end
+    end
+end

data/lib/typed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Typed
+    VERSION = '0.1.0'
+end

data/lib/typed.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'typed/builder'
+require 'typed/struct'
+require 'typed/version'
+require 'uri'
+require 'active_support/time'
+
+module Typed
+    class InvalidValue < TypeError; end
+    class InvalidType < TypeError; end
+
+    class << self
+        include Typed::Builder::BaseType
+
+        def array(element_type = Typed.any)
+            expected_type(element_type)
+
+            Typed::Builder::ArrayType.new(element_type)
+        end
+
+        def any
+            self
+        end
+
+        def null
+            value(nil)
+        end
+
+        def value(expected_value)
+            dry_constrained(eql: call(expected_value))
+        end
+    end
+
+    # Undefined is both:
+    # - A placeholder used to represent an undefined value.
+    # - The type used to represent this placeholder.
+    module Undefined
+        class << self
+            include Typed::Builder::BaseType
+
+            def process(value)
+                if Undefined.equal?(value)
+                    Typed::Builder::Result.success(value)
+                else
+                    Typed::Builder::Result.failure { 'Expected value undefined' }
+                end
+            end
+        end
+    end
+
+    module Strict
+        String = Typed.instance(::String)
+        Symbol = Typed.instance(::Symbol)
+        Int = Typed.instance(::Integer)
+        Float = Typed.instance(::Float)
+        Date = Typed.instance(::Date)
+        True = Typed.value(true)
+        False = Typed.value(false)
+        Boolean = True | False
+        Time = Typed.instance(::Time)
+        DateTime = Typed.instance(::DateTime)
+    end
+
+    String = Strict::String.constructor(input: Strict::Int | Strict::Float | Strict::Symbol, &:to_s)
+
+    Float = Strict::Float.constructor(
+        input: Strict::String | Strict::Int,
+        swallow: [TypeError, ArgumentError]
+    ) { |value| Float(value) }
+
+    Int = Strict::Int
+        .constructor(
+            input: Strict::String,
+            swallow: [TypeError, ArgumentError]
+        ) { |value| Integer(value) }
+        .constructor(
+            input: Float,
+            swallow: [TypeError, ArgumentError]
+        ) { |value|
+            parsed = Integer(value)
+            parsed == value ? parsed : value
+        }
+
+    Date = Strict::Date
+        .constructor(
+            input: String,
+            swallow: [TypeError, ArgumentError, RangeError]
+        ) { |value| ::Date.parse(value) }
+        .constructor(input: Typed.instance(::Time), &:to_date)
+
+    Boolean = Strict::Boolean.constructor(input: String) { |value|
+        { 'true' => true, 'false' => false }.fetch(value) { value }
+    }
+
+    Time = (Strict::DateTime | Strict::Time)
+        .constructor(input: String, swallow: [TypeError, ArgumentError]) { |value|
+            ::ActiveSupport::TimeZone['UTC'].parse(value)
+        }
+        .constructor(input: Int | Float, swallow: [TypeError, ArgumentError]) { |value| ::Time.at(value) }
+
+    UUID = String.dry_constrained(format: /\A[a-f\d]{8}(-[a-f\d]{4}){3}-[a-f\d]{12}\z/)
+        .constructor(input: String, &:downcase)
+
+    URL = String.dry_constrained(format: URI::DEFAULT_PARSER.make_regexp(%w[http https]))
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: bm-typed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Frederic Terrazzoni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: dry-logic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+description: A dry-types/dry-struct alternative making the difference between undefined
+  and nil
+email:
+- frederic.terrazzoni@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/typed.rb
+- lib/typed/builder.rb
+- lib/typed/struct.rb
+- lib/typed/version.rb
+homepage: https://github.com/getbannerman/typed
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A dry-types/dry-struct alternative making the difference between undefined
+  and nil
+test_files: []