vident-typed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cbddabe6bfb2a7023b558f6d901a017a40684f20626590768a10128b34bb97db
+  data.tar.gz: 1ead57f91090163f0fcc901438f57d1d753aa91913e33c7ac49579f5fc5b5867
+SHA512:
+  metadata.gz: 66a1b29c91d37b3007c8b2d1d0862e5db94b97151c7304337bb802e6f6cffa88871a528678ffc00d3ed089423d454a271c1bfd9f7dd1854f5d205d805500877d
+  data.tar.gz: ee959f7e2968242d3f3b8a3e0ccf04c7fe162256f5b14b9705ed208208de63755bc052bc9d80e805cb0902b2c12c9799ca449e5f5c88aff6ff8ee28eccbec101

data/README.md

@@ -0,0 +1,28 @@
+# Vident::Typed
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "vident-typed"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install vident-typed
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/lib/tasks/vident/typed_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :vident_typed do
+#   # Task goes here
+# end

data/lib/vident/typed/attributes.rb

@@ -0,0 +1,236 @@
+require "vident/typed/version"
+require "vident/typed/engine"
+
+module Vident
+  module Typed
+    module Attributes
+      extend ActiveSupport::Concern
+
+      # TODO: better handling of when either class.schema is undefined (as no attributes configured) or when
+      # other methods ar called before prepare_attributes is called
+      def prepare_attributes(attributes)
+        @__attributes = self.class.schema.new(**attributes)
+      end
+
+      def attributes
+        @__attributes.attributes
+      end
+
+      def attribute_names
+        @attribute_names ||= self.class.attribute_names
+      end
+
+      def attribute(key)
+        if Rails.env.development? && !key?(key)
+          raise StandardError, "Attribute #{key} not found in #{self.class.name}"
+        end
+        @__attributes.attributes[key]
+      end
+      alias_method :[], :attribute
+
+      def key?(key)
+        self.class.schema.attribute_names.include?(key)
+      end
+
+      def to_hash
+        @__attributes.to_h
+      end
+
+      class_methods do
+        def inherited(subclass)
+          subclass.instance_variable_set(:@schema, @schema.clone)
+          subclass.instance_variable_set(:@attribute_ivar_names, @attribute_ivar_names.clone)
+          super
+        end
+
+        def attribute_names
+          schema.attribute_names
+        end
+
+        def attribute_metadata(key)
+          schema.schema.key(key).meta
+        end
+
+        attr_reader :schema, :attribute_ivar_names
+
+        def attribute(name, signature = :any, **options, &converter)
+          strict = !options[:convert]
+          signatures = extract_member_type_and_subclass(signature, options)
+          type_info = map_primitive_to_dry_type(signatures, strict, converter)
+          type_info = set_constraints(type_info, options)
+          type_info = set_metadata(type_info, signatures, options)
+          define_on_schema(name, type_info, options)
+        end
+
+        private
+
+        def set_constraints(type_info, options)
+          type_info = constrain_nil(type_info, options)
+          type_info = constrain_blank(type_info, options)
+          type_info = set_default(type_info, options)
+          constrain_inclusion(type_info, options)
+        end
+
+        def constrain_nil(type_info, options)
+          if allows_nil?(options)
+            type_info.optional.meta(required: false)
+          else
+            type_info
+          end
+        end
+
+        def constrain_blank(type_info, options)
+          if allows_blank?(options)
+            type_info
+          else
+            type_info.constrained(filled: true)
+          end
+        end
+
+        def set_default(type_info, options)
+          default = options[:default]
+
+          if default.is_a?(Proc)
+            type_info.default(default.freeze)
+          elsif !default.nil?
+            type_info.default(->(_) { default }.freeze)
+          else
+            type_info
+          end
+        end
+
+        def constrain_inclusion(type_info, options)
+          if options[:in]
+            type_info.constrained(included_in: options[:in].freeze)
+          else
+            type_info
+          end
+        end
+
+        def set_metadata(type_info, signatures, options)
+          metadata = {typed_attribute_type: signatures, typed_attribute_options: options}
+          type_info.meta(**metadata)
+        end
+
+        def delegates?(options)
+          options[:delegates] != false
+        end
+
+        def define_on_schema(attribute_name, type_info, options)
+          @attribute_ivar_names ||= {}
+          @attribute_ivar_names[attribute_name] = :"@#{attribute_name}"
+          define_attribute_delegate(attribute_name) if delegates?(options)
+          @schema ||= const_set(:TypedSchema, Class.new(TypedNilingStruct))
+          @schema.attribute attribute_name, type_info
+        end
+
+        def define_attribute_delegate(attr_name)
+          # Define reader & presence check method
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{attr_name}
+          @__attributes.attributes[:#{attr_name}]
+        end
+
+        def #{attr_name}?
+          send(:#{attr_name}).present?
+        end
+          RUBY
+        end
+
+        def allows_nil?(options)
+          return true unless options
+          allow_nil = options[:allow_nil]
+          return false if allow_nil == false
+          allow_nil || allows_blank?(options)
+        end
+
+        def allows_blank?(options)
+          return true unless options
+          allow_blank = options[:allow_blank]
+          allow_blank.nil? ? true : allow_blank
+        end
+
+        def map_primitive_to_dry_type(signatures, strict, converter)
+          types = signatures.map do |type, subtype|
+            dry_type = dry_type_from_primary_type(type, strict, converter)
+            if subtype && dry_type.respond_to?(:of)
+              subtype_info = dry_type_from_primary_type(subtype, strict, converter)
+              # Sub types of collections currently can be nil - this should be an option
+              dry_type.of(subtype_info.optional.meta(required: false))
+            else
+              dry_type
+            end
+          end
+          types.reduce(:|)
+        end
+
+        def extract_member_type_and_subclass(signature, options)
+          case signature
+          when Set
+            signature.flat_map { |s| extract_member_type_and_subclass(s, options) }
+          when Array
+            [[Array, signature.first]]
+          else
+            [[signature, options[:type] || options[:sub_type]]]
+          end
+        end
+
+        def dry_type_from_primary_type(type, strict, converter)
+          # If a converter is provided, we should use it to coerce the value
+          if converter && !strict && !type.is_a?(Symbol)
+            return Types.Constructor(type) do |value|
+              next value if value.is_a?(type)
+
+              converter.call(value).tap do |new_value|
+                unless new_value.is_a?(type)
+                  raise ArgumentError, "Type conversion proc did not convert #{value} to #{type}"
+                end
+              end
+            end
+          end
+
+          if type == :any
+            Types::Nominal::Any
+          elsif type == Integer
+            strict ? Types::Strict::Integer : Types::Params::Integer
+          elsif type == BigDecimal
+            strict ? Types::Strict::Decimal : Types::Params::Decimal
+          elsif type == Float
+            strict ? Types::Strict::Float : Types::Params::Float
+          elsif type == Numeric
+            if strict
+              Types::Strict::Float | Types::Strict::Integer | Types::Strict::Decimal
+            else
+              Types::Params::Float | Types::Params::Integer | Types::Params::Decimal
+            end
+          elsif type == Symbol
+            strict ? Types::Strict::Symbol : Types::Coercible::Symbol
+          elsif type == String
+            strict ? Types::Strict::String : Types::Coercible::String
+          elsif type == Time
+            strict ? Types::Strict::Time : Types::Params::Time
+          elsif type == Date
+            strict ? Types::Strict::Date : Types::Params::Date
+          elsif type == Array
+            strict ? Types::Strict::Array : Types::Params::Array
+          elsif type == Hash
+            strict ? Types::Strict::Hash : Types::Coercible::Hash
+          elsif type == :boolean
+            strict ? Types::Strict::Bool : Types::Params::Bool
+          elsif strict
+            # when strict create a Nominal type with a is_a? constraint, otherwise create a Nominal type which constructs
+            # values using the default constructor, `new`.
+            Types.Instance(type)
+          else
+            # dry calls this when initialising the Type. Check if type of input is correct or create new instance
+            Types.Constructor(type) do |value|
+              next value if value.is_a?(type)
+
+              type.new(**value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vident/typed/component.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Vident
+  module Typed
+    module Component
+      extend ActiveSupport::Concern
+
+      included do
+        include Vident::Base
+        include Vident::Typed::Attributes
+
+        attribute :id, String, delegates: false
+        attribute :html_options, Hash, delegates: false
+        attribute :element_tag, Symbol, delegates: false
+
+        # StimulusJS support
+        attribute :controllers, Array, default: [], delegates: false
+        attribute :actions, Array, default: [], delegates: false
+        attribute :targets, Array, default: [], delegates: false
+        attribute :data_maps, Array, default: [], delegates: false
+
+        # TODO normalise the syntax of defining actions, controllers, etc
+        attribute :named_classes, Hash, delegates: false
+      end
+
+      def initialize(attrs = {})
+        before_initialise(attrs)
+        prepare_attributes(attrs)
+        # The attributes need to also be set as ivars
+        attributes.each do |attr_name, attr_value|
+          instance_variable_set(self.class.attribute_ivar_names[attr_name], attr_value)
+        end
+        after_initialise
+        super()
+      end
+    end
+  end
+end

data/lib/vident/typed/engine.rb

@@ -0,0 +1,17 @@
+module Vident
+  module Typed
+    class Engine < ::Rails::Engine
+      lib_path = File.expand_path("../../../../lib/", __FILE__)
+      config.autoload_paths << lib_path
+      config.eager_load_paths << lib_path
+
+      config.before_initialize do
+        Rails.autoloaders.each do |autoloader|
+          autoloader.inflector.inflect(
+            "version" => "VERSION"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/vident/typed/typed_niling_struct.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Vident
+  module Typed
+    # A dry struct that is loose about keys provided on initialization. It sets them to nil if not provided.
+    # It is strict about types but not about provided keys
+    class TypedNilingStruct < ::Dry::Struct
+      # convert string keys to symbols
+      transform_keys(&:to_sym)
+
+      # resolve default types on nil
+      transform_types do |type|
+        if type.default?
+          type.constructor { |value| value.nil? ? ::Dry::Types::Undefined : value }
+        else
+          type
+        end
+      end
+
+      class << self
+        def check_schema_duplication(new_keys)
+          # allow overriding keys
+        end
+      end
+    end
+  end
+end

data/lib/vident/typed/types.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Vident
+  module Typed
+    module Types
+      include ::Dry.Types
+
+      StrippedString = Types::String.constructor(&:strip)
+      BooleanDefaultFalse = Types::Bool.default(false)
+      BooleanDefaultTrue = Types::Bool.default(true)
+      HashDefaultEmpty = Types::Hash.default({}.freeze)
+    end
+  end
+end

data/lib/vident/typed/version.rb

@@ -0,0 +1,5 @@
+module Vident
+  module Typed
+    VERSION = "0.1.0"
+  end
+end

data/lib/vident/typed.rb

@@ -0,0 +1,10 @@
+require "vident/typed/version"
+require "vident/typed/engine"
+
+require "dry-struct"
+
+module Vident
+  module Typed
+    # Your code goes here...
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: vident-typed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephen Ierodiaconou
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: vident
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Vident with typed attributes
+email:
+- stevegeek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/tasks/vident/typed_tasks.rake
+- lib/vident/typed.rb
+- lib/vident/typed/attributes.rb
+- lib/vident/typed/component.rb
+- lib/vident/typed/engine.rb
+- lib/vident/typed/typed_niling_struct.rb
+- lib/vident/typed/types.rb
+- lib/vident/typed/version.rb
+homepage: https://github.com/stevegeek/vident-typed
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/stevegeek/vident-typed
+  source_code_uri: https://github.com/stevegeek/vident-typed
+  changelog_uri: https://github.com/stevegeek/vident-typed/blob/main/CHANGELOG.md
+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: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Vident with typed attributes
+test_files: []