dialekt 0.1.0

data/lib/dialekt/model/scalar_property.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "docile"
+
+module Dialekt
+  module Model
+    # Base class for primitive DSL properties
+    class ScalarProperty < BasicProperty
+      def initialize(name:, type: nil, factory: nil, transformer: nil)
+        super(name: name, type: type, factory: factory, transformer: transformer)
+
+        @shapes = {}
+      end
+
+      def setup(owner:)
+        super
+
+        raise ArgumentError, "Missing type for property #{name} of #{owner}" if @shapes.empty? && @type.nil?
+
+        unless @shapes.key?(name)
+          @shapes[name] = BasicProperty::Shape.new(
+            name: name,
+            type: @type || owner.class.type_checker.union_type(types: @shapes.values.map(&:type)),
+            factory: @factory,
+            transformer: @transformer
+          )
+        end
+
+        property = self
+
+        @shapes.each_value do |shape|
+          owner.define_method(shape.name) do |value = EMPTY, &block|
+            property.access_value(shape: shape, target: self, value: value, &block)
+          end
+
+          owner.define_method(:"#{shape.name}=") do |value|
+            property.set_value(shape: shape, target: self, value: value)
+          end
+        end
+      end
+
+      def shape(name = nil, **options)
+        name = name&.to_sym || self.name
+
+        raise ArgumentError, "Property #{self.name} already has a shape called #{name}" if @shapes.key?(name)
+
+        options[:type] ||= @type
+        options[:factory] ||= @factory
+        options[:transformer] ||= @transformer
+
+        raise ArgumentError, "Missing shape for value #{name} of property #{self.name}" if options[:type].nil?
+
+        config = BasicProperty::Shape.new(name: name, **options)
+        @shapes[name] = config
+      end
+
+      def shapes
+        @shapes.dup.freeze
+      end
+
+      def shapes=(shapes)
+        shapes = shapes.values if shapes.is_a?(Hash)
+
+        raise ArgumentError, "Shapes must be an Enumerable" unless shapes.is_a?(Enumerable)
+
+        @shapes = shapes.map { |shape| [shape.name, shape] }.to_h
+      end
+    end
+  end
+end

data/lib/dialekt/model/set_property.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "docile"
+require "dry/inflector"
+
+module Dialekt
+  module Model
+    # Base class for DSL set accessors
+    class SetProperty < BasicProperty
+      class Entry
+        attr_reader :name, :value_type, :value_transformer
+
+        def initialize(name:, value_type:, value_transformer: nil)
+          @name = name.to_sym
+          @value_type = value_type
+          @value_transformer = value_transformer&.call_adapter
+        end
+
+        def to_s
+          result = StringIO.new
+          result << @name << " (" << self.class.base_name << ") {"
+          result << "value_type: " << @value_type.to_s
+          result << ", value_transformer: " << @value_transformer.source_info if @value_transformer
+          result << "}"
+
+          result.string
+        end
+      end
+
+      def initialize(
+        name:,
+        value_type: nil,
+        type: Set,
+        factory: -> { Set.new },
+        transformer: ->(value:) { value&.to_set }
+      )
+        super(
+          name: name,
+          type: type,
+          factory: factory,
+          transformer: transformer
+        )
+
+        @value_type = value_type
+        @value_transformer = nil
+        @entries = {}
+      end
+
+      def entries
+        @entries.dup.freeze
+      end
+
+      def entries=(entries)
+        case entries
+        when Hash
+          @entries = {}
+
+          entries.each do |name, entry|
+            if name != entry.name
+              raise ArgumentError, "Entry key '#{name}' does not match entry name for '#{entry.name}'"
+            end
+
+            define_entry(entry)
+          end
+        when Enumerable
+          @entries = {}
+          entries.each { |entry| define_entry(entry) }
+        else
+          raise ArgumentError, "Entries must be an Enumerable or a Hash"
+        end
+      end
+
+      def entry(name, value_type: nil, value_transformer: nil)
+        entry = Entry.new(
+          name: name.to_sym,
+          value_type: value_type || @value_type,
+          value_transformer: value_transformer || @value_transformer
+        )
+
+        define_entry(entry)
+      end
+
+      def setup(owner:)
+        super
+
+        property = self
+
+        if @entries.empty?
+          raise StandardError, "Please specify a value type for property '#{@name}'" if @value_type.nil?
+
+          define_entry(Entry.new(name: owner.dialekt_inflector.singularize(@name), value_type: @value_type))
+        end
+
+        @value_type ||= owner.class.type_checker.union_type(types: @entries.values.map(&:value_type))
+
+        owner.define_method(@name) do |value = EMPTY, &block|
+          value = property.access_value(shape: property.set_shape, target: self, value: value, &block)
+          value.dup.freeze
+        end
+
+        owner.define_method(:"#{@name}=") do |value|
+          property.set_value(shape: property.set_shape, target: self, value: value)
+        end
+
+        @entries.each_value do |entry|
+          owner.define_method(entry.name) do |value, &block|
+            property.add_entry(entry: entry, target: self, value: value, &block)
+          end
+        end
+      end
+
+      def set_shape
+        @set_shape ||= BasicProperty::Shape.new(
+          name: @name,
+          type: @type,
+          factory: @factory,
+          transformer: @transformer
+        )
+      end
+
+      def add_entry(entry:, target:, value:, &block)
+        set = get_value(shape: set_shape, target: target)
+
+        if entry.value_transformer
+          begin
+            value = entry.value_transformer.call(object: target, value: value)
+          rescue StandardError
+            raise ArgumentError, "Cannot transform value '#{value}' for property '#{@name}' (#{entry.name})"
+          end
+        end
+
+        unless target.class.dialekt_type_checker.valid?(type: entry.value_type, value: value)
+          raise TypeError, "Illegal value type '#{value.class}' for property '#{@name}' (#{entry.name})"
+        end
+
+        set.add(value)
+
+        Docile.dsl_eval(value, &block) if !value.nil? && block
+
+        value
+      end
+
+      def value_type(type = EMPTY)
+        type == EMPTY ? @value_type : (@value_type = type)
+      end
+
+      def value_transformer(transformer = EMPTY)
+        transformer == EMPTY ? @value_transformer : (@value_transformer = transformer&.call_adapter)
+      end
+
+      def value_factory(factory = EMPTY)
+        factory == EMPTY ? @value_factory : (@value_factory = factory&.call_adapter)
+      end
+
+      def to_s
+        result = StringIO.new
+
+        result << @name << " (" << self.class.base_name << ") {"
+        result << "type: " << @type
+        result << ", value_type: " << @value_type
+        result << ", factory: " << @factory.source_info if @factory
+        result << ", transformer: " << @transformer.source_info if @transformer
+        result << ", entries: [" << @entries.values.map(&:name).join(", ") << "]"
+        result << "}"
+
+        result.string
+      end
+
+      protected
+
+      def define_entry(entry)
+        if entry.name == @name
+          raise ArgumentError, "Entry '#{entry.name}' cannot have the same name as its set property"
+        end
+
+        raise ArgumentError, "Entry '#{entry.name}' already exists for property '#{@name}'" if @entries.key?(entry.name)
+
+        @entries[entry.name] = entry
+      end
+    end
+  end
+end

data/lib/dialekt/ruby_type_checker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Dialekt
+  # Ruby type checker
+  class RubyTypeChecker < BasicTypeChecker
+    include Singleton
+    
+    def union_type(types:)
+      union_type = Set.new(types.flatten.uniq)
+
+      raise ArgumentError, "Types must not be empty" if union_type.empty?
+
+      union_type.size == 1 ? union_type.first : union_type
+    end
+
+    def valid?(type:, value:)
+      case type
+      when Array, Set
+        type.any? { |t| valid?(type: t, value: value) }
+      when Class
+        value.is_a?(type)
+      else
+        raise TypeError, "Illegal type '#{type}'"
+      end
+    end
+  end
+end

data/lib/dialekt/util/call_adapter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Dialekt
+  module Util
+    # Call adapter for Proc that filters out excess named parameters
+    class CallAdapter
+      def initialize(callable:)
+        @callable = callable
+        @signature = callable.call_signature
+
+        if @signature.required_parameter_count.positive?
+          raise ArgumentError, "Callable '#{callable}' must not have any required positional parameters"
+        end
+      end
+
+      def method_missing(method, *arguments, &block)
+        if method == :call
+          options = arguments.last&.keys || []
+          define_call_method(options: options)
+          send(method, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      ruby2_keywords :method_missing
+
+      def respond_to_missing?(method, include_all = true)
+        method == :call ? true : super
+      end
+
+      def define_call_method(options:)
+        accepted_options = options.intersection(@signature.options.keys)
+
+        if accepted_options.size == options.size
+          define_singleton_method(:call, @callable)
+        elsif accepted_options.empty?
+          define_singleton_method(:call) do |**_call_options|
+            @callable.call
+          end
+        else
+          define_singleton_method(:call) do |**call_options|
+            @callable.call(**call_options.slice(*accepted_options))
+          end
+        end
+      end
+
+      def call_adapter
+        self
+      end
+
+      def source_info
+        "#{File.basename(@callable.source_location.first)}:#{@callable.source_location.last}"
+      end
+    end
+  end
+end

data/lib/dialekt/util/call_signature.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Dialekt
+  module Util
+    # Call signature information for Proc objects
+    class CallSignature
+      # Parameter information
+      class Parameter
+        attr_reader :name
+
+        def initialize(name:, optional:)
+          @name = name.to_sym
+          @optional = optional
+        end
+
+        def optional?
+          @optional
+        end
+
+        def ==(other)
+          @name == other.name && @optional == other.optional?
+        end
+      end
+
+      class << self
+        def create(signature:)
+          parameters = []
+          options = {}
+          extra_parameters = nil
+          extra_options = nil
+
+          signature.each do |type, name|
+            case type
+            when :req, :opt
+              parameters << Parameter.new(name: name, optional: type == :opt)
+            when :rest
+              extra_parameters = Parameter.new(name: name, optional: true)
+            when :keyreq, :key
+              options[name] = Parameter.new(name: name, optional: type == :key)
+            when :keyrest
+              extra_options = Parameter.new(name: name, optional: true)
+            else
+              raise ArgumentError, "Illegal type #{type} in signature #{PP.singleline_pp(signature, StringIO.new).string}"
+            end
+          end
+
+          new(parameters: parameters, extra_parameters: extra_parameters, options: options, extra_options: extra_options)
+        end
+      end
+
+      attr_reader :parameters, :options, :extra_parameters, :extra_options
+
+      def initialize(parameters:, extra_parameters:, options:, extra_options:)
+        @parameters = parameters.dup.freeze
+        @extra_parameters = extra_parameters
+        @options = options.dup.freeze
+        @extra_options = extra_options
+      end
+
+      def required_parameter_count
+        @required_parameter_count ||= @parameters.count { |p| !p.optional? }
+      end
+
+      def optional_parameter_count
+        @optional_parameter_count ||= @parameters.count(&:optional?)
+      end
+    end
+  end
+end

data/lib/dialekt/util/core_extensions.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Dialekt
+  module Util
+    # Core Ruby extensions
+    module CoreExtensions
+      TYPE_CHECKER_CONST = :DIALEKT_TYPE_CHECKER
+      INFLECTOR_CONST = :DIALEKT_INFLECTOR
+  
+      module ModuleMixins
+        def dialekt_base_name
+          @__dialekt_base_name ||= begin # rubocop:disable Naming/MemoizedInstanceVariableName
+            name.gsub(%r{\A.+::}, "")
+          end
+        end
+
+        def dialekt_enclosing_module
+          if %r{\A(?<parent_name>[^:#]+(?:::[^:#]+)*)::[^:]+\z} =~ name && Kernel.const_defined?(parent_name)
+            Kernel.const_get(parent_name)
+          end
+        end
+
+        def dialekt_lookup_type_checker
+          if const_defined?(TYPE_CHECKER_CONST, true)
+            const_get(TYPE_CHECKER_CONST)
+          else
+            enclosing_module = self.dialekt_enclosing_module
+
+            type_checker = if enclosing_module.nil?
+              RubyTypeChecker.instance
+            else
+              enclosing_module.dialekt_type_checker
+            end
+
+            const_set(TYPE_CHECKER_CONST, type_checker)
+          end
+        end
+
+        def dialekt_type_checker(checker = EMPTY)
+          if checker == EMPTY
+            dialekt_lookup_type_checker
+          else
+            if const_defined?(TYPE_CHECKER_CONST)
+              raise ArgumentError, "#{self.class} #{self} already has a type checker defined"
+            end
+
+            const_set(TYPE_CHECKER_CONST, checker)
+          end
+        end
+
+        def dialekt_lookup_inflector
+          if const_defined?(INFLECTOR_CONST, true)
+            const_get(INFLECTOR_CONST)
+          else
+            enclosing_module = self.dialekt_enclosing_module
+
+            inflector = if enclosing_module.nil?
+              Dry::Inflector.new
+            else
+              enclosing_module.dialekt_inflector
+            end
+
+            const_set(INFLECTOR_CONST, inflector)
+          end
+        end
+
+        def dialekt_inflector(inflector = EMPTY)
+          if inflector == EMPTY
+            dialekt_lookup_inflector
+          else
+            if const_defined?(INFLECTOR_CONST)
+              raise ArgumentError, "#{self.class} #{self} already has an inflector defined"
+            end
+
+            const_set(INFLECTOR_CONST, inflector)
+          end
+        end
+      end
+
+      Module.include(ModuleMixins)
+
+      module CallableExtensions
+        def call_signature
+          CallSignature.create(signature: parameters)
+        end
+      end
+
+      Proc.include(CallableExtensions)
+      Method.include(CallableExtensions)
+      UnboundMethod.include(CallableExtensions)
+
+      module ProcExtensions
+        def call_adapter
+          CallAdapter.new(callable: self)
+        end
+      end
+
+      Proc.include(ProcExtensions)
+    end
+  end
+end