drymm 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8f12bd0894d16b195930e4bea3fa4e752483cb2c92f942b90318999951f0ff9
+  data.tar.gz: c50dc6947861850fcaa539690209b559dd74458f9d3a3dfe37e8e43ba4a39fea
+SHA512:
+  metadata.gz: 66f843c85fc7bed6d84c1fc333f3b7c9a1168a806ba589c8cf985d99b543522d9fb568ded67efa28375e5e1a393f263542db7f05a8a54f0fe9e744047d69cbc0
+  data.tar.gz: 573fa9341ef612207a5c97dbd06d5f8c116b9c438865b92f0d50ff05ac8f63f129566f12bd128dbf1490bc376fd221f185f240f8ece13bae9ab215d734008c8a

data/README.md

@@ -0,0 +1,38 @@
+# Drym¹m² is for (¹)meta (²)mapping
+
+Drymm represents entities provided by `Dry::Logic` & `Dry::Types` as a `Dry::Struct` classes under a `Drymm::Shapes` namespace.
+
+The core feature of `Drymm::Shapes` is an ability to cast an AST produced by that entities and structurize it for the following serialization. Also it provides an interface to load serialized data and compile it back  the Type or Logic entity.
+
+The casts perform by declaring expecting shapes under a specific `Drymm::Shapes::Branch` without any conditional code but with a significant amount of recursion. Shapes composed into `Dry::Struct::Sum` and handled by `Concurrent::AtomicReference` which are in front of the casting behaviour.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add drymm
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install drymm
+
+## Usage
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/estum/drymm. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/estum/drymm/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Drymm project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/estum/drymm/blob/main/CODE_OF_CONDUCT.md).

data/drymm.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/drymm/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "drymm"
+  spec.authors       = ["estum"]
+  spec.email         = ["anton.estum@gmail.com"]
+  spec.license       = "MIT"
+  spec.version       = Drymm::VERSION
+
+  spec.summary       = "Universal meta mapper for dry-logic & dry-types."
+  spec.description   = "Drymm maps entities from Dry::Logic & Dry::Types into structs for a serialization purpose."
+  spec.homepage      = "https://github.com/estum/drymm"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "drymm.gemspec", "lib/**/*"]
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = "https://github.com/estum/drymm"
+  spec.metadata["changelog_uri"]     = "https://github.com/estum/drymm/blob/main/CHANGELOG.md"
+
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.add_runtime_dependency "concurrent-ruby"
+  spec.add_runtime_dependency "concurrent-ruby-ext"
+  spec.add_runtime_dependency "dry-core"
+  spec.add_runtime_dependency "dry-inflector"
+  spec.add_runtime_dependency "dry-logic"
+  spec.add_runtime_dependency "dry-monads"
+  spec.add_runtime_dependency "dry-struct"
+  spec.add_runtime_dependency "dry-types"
+  spec.add_runtime_dependency "dry-types-tuple", ">= 0.1.4"
+  spec.add_runtime_dependency "zeitwerk"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/dry/logic/builder/context_predicate_name.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Dry
+  module Logic
+    module Builder
+      # @api private
+      class Context
+        # Defines custom predicate
+        #
+        # @name [Symbol] Name of predicate
+        # @Context [Proc]
+        def predicate(name, context = nil, &block)
+          singleton_class.undef_method(name) if singleton_class.method_defined?(name)
+
+          predicate = Rule::Predicate.new(context || block)
+
+          define_singleton_method(name) do |*args|
+            predicate.curry(*args)
+          end
+        end
+
+        # Defines methods for operations and predicates
+        def initialize
+          Operations.constants(false).each do |name|
+            next if Dry::Logic::Builder::IGNORED_OPERATIONS.include?(name)
+
+            operation = Operations.const_get(name)
+
+            define_singleton_method(name.downcase) do |*args, **kwargs, &block|
+              operation.new(*call(&block), *args, **kwargs)
+            end
+          end
+
+          Predicates::Methods.instance_methods(false).each do |name|
+            predicate(name, Predicates[name]) unless Dry::Logic::Builder::IGNORED_PREDICATES.include?(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/printer/visit_sum_constructors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Printer
+      alias visit_sum_constructors visit_composition
+    end
+  end
+end

data/lib/drymm/container.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "dry/core/version"
+
+module Drymm
+  # @api private
+  module Container
+    if Dry::Core::VERSION >= "1.0.0"
+      include Dry::Core::Container::Mixin
+    else
+      require "dry/container"
+      include Dry::Container::Mixin
+    end
+
+    # @private
+    def self.extended(base)
+      Dry::Core::Container::Mixin.extended(base)
+    end
+
+    private
+
+    def alias_item(new_name, old_name)
+      register new_name, memoize: true do
+        resolve(old_name)
+      end
+    end
+  end
+end

data/lib/drymm/inflector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module Drymm
+  # @api private
+  class Inflector < Dry::Inflector
+    def initialize(root_file)
+      super() do |inflections|
+        inflections.acronym "AST"
+        yield(inflections) if block_given?
+      end
+      namespace     = File.basename(root_file, ".rb")
+      lib_dir       = File.dirname(root_file)
+      @version_file = File.join(lib_dir, namespace, "version.rb")
+    end
+
+    def camelize(basename, abspath)
+      abspath == @version_file ? "VERSION" : super(basename)
+    end
+  end
+end

data/lib/drymm/repos/fn_repo.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Drymm
+  # @api private
+  module FnRepo
+    extend Container
+
+    register :ary_wrap do |input|
+      Drymm["rules.ary"][input] ? input : [input]
+    end
+
+    register :logic_builder do |fn|
+      Dry::Logic::Builder.call(&fn)
+    end
+
+    register :type_identifier do |name|
+      Drymm.inflector.underscore(Drymm.inflector.demodulize(name)).to_sym
+    end
+  end
+end

data/lib/drymm/repos/rules_repo.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Drymm
+  # @api private
+  module RulesRepo
+    extend Container
+
+    register :const,
+             proc { key(name: 0) { case?(Drymm["types.const"]) } },
+             call: false
+
+    register :ary,
+             proc { array? },
+             call: false
+
+    register :node,
+             proc { array? & min_size?(1) & key(name: 0) { negation { array? } } },
+             call: false
+
+    register :as_ast,
+             proc { respond_to?(:to_ast) },
+             call: false
+  end
+end

data/lib/drymm/repos/types_repo.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Drymm
+  # @api private
+  module TypesRepo
+    extend Container
+
+    register :any, Dry::Types["any"]
+
+    register :ary, Dry::Types["array"]
+
+    register :bool, Dry::Types["bool"]
+
+    register :hash, Dry::Types["hash"]
+
+    register :opts, (Dry::Types["hash"].default { Drymm::EMPTY_OPTS })
+    alias_item :meta, :opts
+
+    register :sym, Dry::Types["coercible.symbol"]
+
+    register :str, Dry::Types["coercible.string"]
+
+    T = method def self.t(member)
+          return member if !member.is_a?(String) && !member.is_a?(Symbol)
+
+          resolve(member) { member }
+        end
+
+    Array = method def self.array(member)
+              t(:ary_wrap).of t(member)
+            end
+
+    Tuple = method def self.tuple(*members)
+              Dry::Types::Tuple.build_unsplat(members)
+            end
+
+    Constrained = method def self.constrained(member, rule)
+                    Dry::Types::Constrained.new(t(member), rule: rule)
+                  end
+
+    register "sum.types", proc { Shapes::Types.sum }, memoize: false
+
+    register "sum.rules", proc { Shapes::Logic.sum }, memoize: false
+
+    register "variadic.any", proc { Array[:any] }, memoize: true
+
+    register "variadic.types", proc { Array["sum.types"] }, memoize: false
+
+    register "variadic.rules", proc { Array["sum.rules"] }, memoize: false
+
+    register :fn, proc { Shapes::Fn.sum }, memoize: false
+
+    register :const, proc { Shapes::Const }, memoize: false
+    alias_item :class, :const
+
+    register :ast, proc { constrained(:any, Drymm["rules.as_ast"]) }, memoize: true
+
+    register :ary_wrap, proc { T[:ary] << Drymm["fn.ary_wrap"] }, memoize: true
+  end
+end

data/lib/drymm/shapes/ast_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # AST-related methods mixin
+    module ASTMethods
+      extend Mix
+
+      # Fold data back into the plain AST
+      # @return [Array]
+      def to_ast
+        type, *node = attributes.values_at(*self.class.keys_order)
+        node = recursive_ast(node)
+        node = node[0] if node.size == 1
+        [type, node]
+      end
+
+      # Compile an instance back to original object
+      # @see ClassMethods#compiler
+      # @see ClassMethods#compiler_registry
+      # @return [Object]
+      def compile
+        self.class.compiler.call([to_ast])[0]
+      end
+
+      private
+
+      def recursive_ast(node)
+        case node
+        when Array
+          node.map { |item| recursive_ast(item) }
+        when Hash
+          node.transform_values { |item| recursive_ast(item) }
+        when Drymm["types.ast"]
+          node.to_ast
+        else
+          node
+        end
+      end
+
+      # @api private
+      module ClassMethods
+        # @abstract
+        #   Should be overriden in subclasses to return specific compiler
+        # @param registry [container]
+        # @return [#call]
+        def compiler(registry = compiler_registry())
+          raise NotImplementedError
+        end
+
+        # @abstract
+        #   Should be overriden in subclasses to return specific registry
+        # @return [container]
+        def compiler_registry
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/drymm/shapes/atomic_type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # @api private
+    class AtomicType < Concurrent::AtomicReference
+      include Dry::Types::Type
+      include Dry::Types::Builder
+      include Dry::Types::Decorator
+      include Dry::Equalizer(:type, inspect: false, immutable: false)
+
+      def initialize(initial_type = Drymm::Undefined)
+        Drymm::Undefined.map(initial_type) do
+          set(initial_type)
+        end
+      end
+
+      alias type get
+
+      def to_s
+        Dry::Types::PRINTER.(get) { get.to_s }
+      end
+
+      alias inspect to_s
+
+      def respond_to_missing?(method_name, include_private = true)
+        get.respond_to?(method_name, include_private) || super
+      end
+
+      def method_missing(method_name, *args, **opts, &blk)
+        value = get
+
+        if value.respond_to?(method_name, true)
+          value.send(method_name, *args, **opts, &blk)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/drymm/shapes/branch.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # {Drymm::Shapes}'s class interface mixin, designed to extend
+    # an abstract __subclass__ of {Drymm::Shapes::Node}, creating a kind of
+    # Shape's branch or, in other words, derivative, to enclose specific namespace.
+    module Branch
+      # @api private
+      # Defines {sum} class attribute when extended.
+      private_class_method def self.extended(base)
+        base.defines :tuple_right
+        base.tuple_right true
+        base.private_class_method :auto_tuple
+      end
+
+      # @api private
+      # Flattens the 1st level of the input array.
+      def coerce_tuple(input)
+        super(input.flatten(1))
+      end
+
+      # @api private
+      def auto_tuple(*keys)
+        keys_order(keys_order | keys)
+        index = schema.keys.map { |t| [t.name, t.type] }.to_h
+        key_type, *node_types = index.values_at(*keys_order)
+        if tuple_right
+          tuple Tuple(key_type, Tuple(*node_types))
+        else
+          tuple Tuple(key_type, *node_types)
+        end
+      end
+
+      def retuple
+        auto_tuple!(*keys_order)
+      end
+
+      def auto_tuple!(*keys)
+        remove_instance_variable(:@keys_order) if instance_variable_defined?(:@keys_order)
+        remove_instance_variable(:@tuple) if instance_variable_defined?(:@tuple)
+        keys_order []
+        auto_tuple(*keys)
+      end
+
+      private
+
+      # Shorthand method to build a tuple
+      # @return [Dry::Types::Tuple]
+      def Tuple(*args)
+        Drymm::TypesRepo.tuple(*args)
+      end
+    end
+  end
+end

data/lib/drymm/shapes/const.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # The intermediary shape class to handle bidirectional
+    # serialization of classes & modules, referenced in the node's AST.
+    #
+    # @example Wraps
+    #   Drymm::Shapes::Const[Dry]
+    #   # => #<Drymm::Shapes::Const name='Dry'>
+    #
+    #   Drymm::Shapes::Const[name: 'Dry'].to_literal
+    #   # => Dry
+    class Const < Node
+      attribute :type, (type_identifier(:const).default { :const })
+      attribute :name, Drymm["types.str"]
+
+      include Dry.Equalizer(:name, immutable: true)
+
+      # Constantize by name
+      # @return [Class, Module]
+      def to_literal
+        ::Object.const_get(name)
+      end
+
+      alias to_ast to_literal
+
+      class << self
+        # @!method call(input, &block)
+        #   @overload call(class_or_module_literal)
+        #     @param class_or_module_literal [Class, Module]
+        #   @overload call(hash)
+        #     @param hash [Hash { :type => :const, :name => String }]
+        #   @return [self]
+
+        # @return [Class(Module)]
+        def primitive
+          ::Module
+        end
+
+        # @param input [Any]
+        # @return [true] if the input is an instance of {Module} class.
+        def primitive?(input)
+          input.is_a?(primitive)
+        end
+
+        # @api private
+        def call_unsafe(input)
+          return super unless primitive?(input)
+
+          super(name: input)
+        end
+
+        # @api private
+        def call_safe(input, &block)
+          return super unless primitive?(input)
+
+          super(name: input, &block)
+        end
+
+        # @api private
+        def try(input, &block)
+          return super unless primitive?(input)
+
+          super(name: input, &block)
+        end
+      end
+    end
+  end
+end

data/lib/drymm/shapes/fn.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # Namespace of function shapes, i.e. procs or methods, used by {Dry::Types}
+    module Fn
+      extend SumEnclosure
+
+      # @abstract
+      #   Abstract node branch class for shapes of {Dry::Types::Constructor::Function}
+      class FnNode < Node
+        abstract
+        extend Summarize
+
+        attribute :type, type_enum(:id, :callable, :method)
+
+        def self.namespace
+          Fn
+        end
+
+        # @return [::Dry::Logic::Predicates]
+        def self.compiler_registry
+          ::Dry::Types.container
+        end
+
+        # @return [::Dry::Logic::RuleCompiler]
+        def self.compiler(registry = compiler_registry())
+          ::Dry::Types::Compiler.new(registry)
+        end
+
+        def compile
+          self.class.compiler.compile_fn(to_ast)
+        end
+      end
+
+      sum.set FnNode
+
+      # Represents functions, stored in {Dry::Types::FnContainer}
+      class ID < FnNode
+        attribute :type, type_identifier(:id)
+        attribute :id, Drymm["types.str"]
+      end
+
+      # Represent callable objects but not an internal procs
+      class Callable < FnNode
+        attribute :type, type_identifier(:callable)
+        attribute :callable, Drymm["types.any"]
+
+        # @!attribute callable [r]
+        #   @return [#call]
+      end
+
+      # Represents a method calls
+      class Method < FnNode
+        attribute :type, type_identifier(:method)
+        attribute :target, Drymm["types.const"] | Drymm["types.any"]
+        attribute :name, Drymm["types.sym"]
+
+        def to_ast
+          super.flatten(1)
+        end
+      end
+    end
+  end
+end

data/lib/drymm/shapes/json_methods.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Drymm
+  module Shapes
+    # JSON serialization methods mixin.
+    module JSONMethods
+      extend Mix
+
+      # Dumps the instance to a JSON string.
+      # @param pretty [Hash]
+      # @return [String]
+      def to_json(pretty: nil)
+        if pretty
+          JSON.pretty_generate(to_hash, pretty)
+        else
+          JSON.fast_generate(to_hash)
+        end
+      end
+
+      # @api private
+      module ClassMethods
+        # Parse JSON to a shape node
+        def from_json(payload)
+          call(JSON.parse(payload, symbolize_names: true))
+        end
+      end
+    end
+  end
+end