drymm 0.2.0

data/lib/drymm/shapes/logic.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # # Shapes namespace for Dry::Logic
+    module Logic
+      extend SumEnclosure
+
+      # @abstract
+      #   Abstract node branch class for shapes of {Dry::Logic}
+      class Rule < Node
+        abstract
+        extend Branch
+        extend Summarize
+
+        def self.namespace
+          Logic
+        end
+
+        # @return [::Dry::Logic::Predicates]
+        def self.compiler_registry
+          ::Dry::Logic::Predicates
+        end
+
+        # @return [::Dry::Logic::RuleCompiler]
+        def self.compiler(registry = compiler_registry())
+          ::Dry::Logic::RuleCompiler.new(registry)
+        end
+      end
+
+      sum.set Rule
+
+      # @see Dry::Logic::Predicate::Rule
+      class Predicate < Rule
+        attribute :type, type_identifier
+        attribute :name, Drymm["types.sym"]
+        attribute :args, Drymm["types.variadic.any"]
+      end
+
+      # @see Dry::Logic::Operations::Check
+      class Check < Rule
+        attribute :type, type_identifier
+        attribute :keys, Drymm["types.variadic.any"]
+        attribute :rule, Drymm["types.sum.rules"]
+      end
+
+      # @see Dry::Logic::Operations::Unary
+      class Unary < Rule
+        tuple_right false
+        attribute :type, type_enum(:each, :not, :negation)
+        attribute :rule, Drymm["types.sum.rules"]
+
+        def self.coerce_tuple((type, rule))
+          { type: type, rule: rule }
+        end
+      end
+
+      # @see Dry::Logic::Operations::Attr
+      # @see Dry::Logic::Operations::Key
+      class RoutedUnary < Rule
+        attribute :type, type_enum(:attr, :key)
+        attribute :path, Drymm["types.any"]
+        attribute :rule, Drymm["types.sum.rules"]
+      end
+
+      # @see Dry::Logic::Operations::Binary
+      class Grouping < Rule
+        tuple_right false
+        attribute :type, type_enum(:and, :or, :xor, :set)
+        attribute :rules, Drymm["types.variadic.rules"]
+
+        def to_ast
+          [type, rules.map(&:to_ast)]
+        end
+
+        def self.coerce_tuple((type, rules))
+          { type: type, rules: rules }
+        end
+      end
+
+      # @see Dry::Logic::Operations::Implication
+      class BinaryComposition < Rule
+        attribute :type, type_enum(:implication)
+        attribute :left, Drymm["types.sum.rules"]
+        attribute :right, Drymm["types.sum.rules"]
+      end
+    end
+  end
+end

data/lib/drymm/shapes/node.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # @abstract
+    #   {Dry::Struct} abstract subclass, extended with {::Dry::Tuple::StructClassInterface}
+    class Node < Dry::Struct
+      abstract
+
+      extend Dry::Tuple::StructClassInterface
+      include Dry::Core::Constants
+      include JSONMethods
+      include ASTMethods
+
+      class << self
+        # @overload type_identifier(klass)
+        #   Generates identifier from the given class name
+        #   @param klass [Class]
+        # @overload type_identifier(name)
+        #   Coerces the given name to symbol and uses it as a node type identifier
+        #   @param name [#to_sym]
+        # @overload type_identifier(list)
+        #   Builds {Dry::Types::Enum} from the given list of values
+        #   @param list [Array]
+        # @return [Dry::Types::Type]
+        #   coercible symbol type with specific value — node type identifier
+        #   (declared, for example, as `type` in {Drymm::Shape::LogicNode.inherited})
+        # @note
+        #   To hook the assigned type identifier for specific subclass, just override
+        #   this method.
+        # @example Hook the type value
+        #   class Something < Drymm::S::Node
+        #     def self.type_identifier(*)
+        #       super(:hooked)
+        #     end
+        #   end
+        def type_identifier(input = self)
+          case input
+          when ::String, ::Symbol
+            Drymm["types.sym"].constrained(eql: input.to_sym)
+          when ::Array
+            Drymm["types.sym"].enum(*input)
+          when ::Module
+            type_identifier(Drymm["fn.type_identifier"][input.name])
+          else
+            raise ArgumentError
+          end
+        end
+
+        # Shorthand to declare type as a enum
+        # @param input [Array<Symbol>]
+        # @return [Dry::Types[Enum<Symbol>]]
+        def type_enum(*input)
+          type_identifier(input)
+        end
+
+        # @api private
+        # Invokes Dry::Tuple::StructClassInterface#auto_tuple each time an
+        # attribute is declared.
+        def define_accessors(keys)
+          super
+          auto_tuple(*keys)
+        end
+      end
+
+      private_class_method :define_accessors
+    end
+  end
+end

data/lib/drymm/shapes/sum_enclosure.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # @api private
+    module SumEnclosure
+      include Dry::Types::Type
+      include Dry::Types::Meta
+
+      # @api private
+      def sum
+        @sum ||= AtomicType.new
+      end
+
+      # @!method call(input, &block)
+      #   @overload call(type: :id, id:)
+      #     @param id [Symbol, String]
+      #   @overload call(type: :callable, callable:)
+      #     @param callable [#call]
+      #   @overload call(type: :method, target:, name:)
+      #     @param target [#(name)] namespace
+      #     @param name [Symbol, String]
+      #   @return [self]
+
+      # @api private
+      def call_unsafe(input)
+        @sum.call(input)
+      end
+
+      # @api private
+      def call_safe(input, &block)
+        @sum.call(input, &block)
+      end
+
+      # @api private
+      def try(input, &block)
+        @sum.try(input, &block)
+      end
+    end
+  end
+end

data/lib/drymm/shapes/summarize.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # @api private
+    module Summarize
+      private
+
+      # @api private
+      def inherited(subclass)
+        super
+        namespace.sum.try_update! do |current|
+          if current == abstract_class
+            subclass
+          else
+            current | subclass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/drymm/shapes/types.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Drymm
+  module Shapes
+    # # Shapes namespace for Dry::Types
+    module Types
+      extend SumEnclosure
+
+      # @abstract
+      #   Abstract node branch class for shapes of {Dry::Types}
+      class Type < Node
+        abstract
+        extend Branch
+        extend Summarize
+
+        def self.namespace
+          Types
+        end
+
+        # @return [::Dry::Logic::Predicates]
+        def self.compiler_registry
+          ::Dry::Types
+        end
+
+        # @return [::Dry::Logic::RuleCompiler]
+        def self.compiler(registry = compiler_registry())
+          ::Dry::Types::Compiler.new(registry)
+        end
+
+        def compile
+          self.class.compiler.call(to_ast)
+        end
+      end
+
+      sum.set Type
+
+      # @see Dry::Types::Any
+      class Any < Type
+        tuple_right false
+        attribute :type, type_identifier
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Array
+      class Array < Type
+        attribute :type, type_identifier
+        attribute :member, Drymm["types.sum.types"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::JSON
+      # @see Dry::Types::Params
+      class CoercibleArray < Type
+        attribute :type, type_enum(:json_array, :params_array)
+        attribute :member, Drymm["types.sum.types"]
+      end
+
+      # @see Dry::Types::JSON
+      # @see Dry::Types::Params
+      class CoercibleHash < Type
+        attribute :type, type_enum(:json_hash, :params_hash)
+        attribute :keys, Drymm["types.variadic.types"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Composition
+      class Composition < Type
+        attribute :type, type_enum(:implication, :intersection, :transition, :sum)
+        attribute :left, Drymm["types.sum.types"]
+        attribute :right, Drymm["types.sum.types"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Constrained
+      class Constrained < Type
+        attribute :type, type_identifier
+        attribute :base, Drymm["types.sum.types"]
+        attribute :rule, Drymm["types.sum.rules"]
+      end
+
+      # @see Dry::Types::Constructor
+      class Constructor < Type
+        attribute :type, type_identifier
+        attribute :base, Drymm["types.sum.types"]
+        attribute :fn, Drymm["types.fn"]
+      end
+
+      # @see Dry::Types::Enum
+      class Enum < Type
+        attribute :type, type_identifier
+        attribute :base, Drymm["types.sum.types"]
+        attribute :mapping, Drymm["types.hash"]
+      end
+
+      # @see Dry::Types::Hash
+      class Hash < Type
+        attribute :type, type_identifier
+        attribute :options, Drymm["types.opts"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Schema::Key
+      class Key < Type
+        attribute :type, type_identifier
+        attribute :name, Drymm["types.any"]
+        attribute :required, Drymm["types.bool"]
+        attribute :base, Drymm["types.sum.types"]
+      end
+
+      # @see Dry::Types::Lax
+      class Lax < Type
+        tuple_right false
+        attribute :type, type_identifier
+        attribute :base, Drymm["types.sum.types"]
+
+        def self.coerce_tuple((type, base))
+          { type: type, base: base }
+        end
+      end
+
+      # @see Dry::Types::Map
+      class Map < Type
+        attribute :type, type_identifier
+        attribute :key_type, Drymm["types.sum.types"]
+        attribute :value_type, Drymm["types.sum.types"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Nominal
+      class Nominal < Type
+        attribute :type, type_identifier
+        attribute :base, Drymm["types.const"]
+        attribute :meta, Drymm["types.meta"]
+      end
+
+      # @see Dry::Types::Schema
+      class Schema < Type
+        attribute :type, type_identifier
+        attribute :keys, Drymm["types.variadic.types"]
+        attribute :options, Drymm["types.opts"]
+        attribute :meta, Drymm["types.meta"]
+      end
+    end
+  end
+end

data/lib/drymm/shapes.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Drymm
+  # The core Shapes namespace
+  module Shapes
+    include Dry::Core::Constants
+
+    # @api private
+    module Mix
+      private
+
+      def included(base)
+        base.extend(const_get(:ClassMethods))
+      end
+    end
+
+    class << self
+      def sum
+        Drymm["sum"]
+      end
+
+      def call(input)
+        sum[input]
+      end
+
+      alias [] call
+    end
+
+    extend JSONMethods::ClassMethods
+  end
+end

data/lib/drymm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Drymm
+  VERSION = "0.2.0"
+end

data/lib/drymm.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "drymm/version"
+require "zeitwerk"
+require "dry/core/constants"
+require "dry/logic"
+require "dry/logic/predicates"
+require "dry/logic/builder"
+require "dry/types"
+require "dry/struct"
+require "dry/monads/all"
+require "dry/tuple"
+
+# Load patches for dry-rb gems if need
+
+unless Dry::Types::Printer.method_defined?(:visit_sum_constructors)
+  require_relative "dry/types/printer/visit_sum_constructors"
+end
+
+unless Dry::Logic::Builder::Context.instance_method(:predicate).parameters.include?(%i[opt context])
+  require_relative "dry/logic/builder/context_predicate_name"
+end
+
+require_relative "drymm/inflector"
+
+# # 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 (for example,
+# into JSON). Also it provides an interface to load serialized data and compile it back
+# to the Type or Logic entity.
+#
+# The casts perform by declaring expecting shapes under a specific {Drymm::Shapes::Branch}
+# namespace without any conditional code but with a significant amount of recursion.
+# Declared shapes composed into {Dry::Struct::Sum} which are in front of the casting behaviour.
+module Drymm
+  class << self
+    # @!visibility private
+
+    def loader
+      @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+        if $PROGRAM_NAME == "bin/console"
+          loader.enable_reloading
+          loader.log!
+        end
+        loader.tag = "drymm"
+        loader.inflector = Drymm::Inflector.new(__FILE__)
+        loader.ignore "#{__dir__}/dry"
+        loader.collapse "#{__dir__}/drymm/repos"
+      end
+    end
+
+    # @return [Drymm::Inflector]
+    def inflector
+      loader.inflector
+    end
+  end
+
+  loader.setup
+
+  include Dry::Core::Constants
+
+  extend Container
+
+  # @!method self.[](key)
+  #   @param [String, Symbol] key
+  #   @return [mixed]
+
+  # @!method self.resolve(key)
+  #   @param [String, Symbol] key
+  #   @return [mixed]
+
+  merge Drymm::RulesRepo, namespace: :rules
+  merge Drymm::FnRepo, namespace: :fn
+  merge Drymm::TypesRepo, namespace: :types
+
+  logic_builder = self["fn.logic_builder"]
+
+  keys.grep(/^rules/).each do |key|
+    decorate key, with: logic_builder
+  end
+
+  register :sum, memoize: true do
+    (
+      resolve("types.sum.rules") |
+      resolve("types.sum.types")
+    ).meta(recursive: "poly")
+  end
+end