appfuel 0.2.0

data/lib/appfuel/domain/domain_name_parser.rb

@@ -0,0 +1,44 @@
+module Appfuel
+  module Domain
+
+    module DomainNameParser
+
+      # This parse the domain name string or object with domain_name method
+      # and returns an array with feature, domain and name.
+      # @example
+      #   parse_domain_name('Foo.Bar.Baz')
+      #   ['Foo', 'Bar', 'Foo.Bar.Baz']
+      # @param name [String, Object] domain name
+      # @return [Array] parsed Array from domain name
+      def parse_domain_name(name)
+        if !name.is_a?(String) && !name.respond_to?(:domain_name)
+          fail 'domain name must be a string or implement method :domain_name'
+        end
+
+        name = name.domain_name if name.respond_to?(:domain_name)
+        feature, domain = name.split('.')
+        if domain.nil?
+          domain, feature  = feature, nil
+        end
+
+        [feature, domain, name]
+      end
+
+      # This parse the domain attributes string and returns an array with
+      # two elements.
+      # @example
+      #   parse_domain_attr('Foo.Bar.Baz')
+      #   ['Foo.Bar', 'Baz']
+      # @param name [String] domain name attributes
+      # @return [Array] parsed Array from domain attributes
+      def parse_domain_attr(name)
+        unless name.is_a?(String)
+          fail 'domain attribute name must be a string'
+        end
+
+        *first, last = name.split('.')
+        [first.join('.'), last]
+      end
+    end
+  end
+end

data/lib/appfuel/domain/dsl.rb

@@ -0,0 +1,247 @@
+module Appfuel
+  # Mixin used to add attributes to an object. Attributes are given an name
+  # and have a type declaration which is used to ensure it is correct. Types
+  # are handled by Dry::Types which are mixed into the Types module. When an
+  # object is instaniated dymamic getters and setters are created depending
+  # on if the a value_object flag has been toggled
+  #
+  # @example
+  #   attribute :foo, 'strict.string', default: 'bar', min_size: 3
+  #
+  module Domain
+    module Dsl
+      # Class macro dsl used to implement attributes
+      attr_accessor :equalizer
+      attr_reader :schema, :defaults
+      protected :equalizer=
+
+      def self.extended(base)
+        base.instance_variable_set(:@schema, {})
+        base.instance_variable_set(:@value_object, false)
+      end
+
+      def inherited(klass)
+        super
+        klass.instance_variable_set(:@value_object, false)
+        klass.instance_variable_set(:@schema, {})
+        klass.equalizer = Dry::Equalizer.new(*schema.keys)
+        klass.send(:include, klass.equalizer)
+
+        register_container_class(klass)
+        Types.register_domain(klass)
+      end
+
+      def default?
+        false
+      end
+
+      def valid?(value)
+        self === value
+      end
+
+      def value_object?
+        @value_object
+      end
+
+      def enable_value_object
+        @value_object = true
+      end
+
+      def disable_value_object
+        @value_object = false
+      end
+
+      def type(str)
+        Types[str]
+      end
+
+      def strict_enum(*args)
+        type('strict.string').enum(*args)
+      end
+
+      def enum(*args)
+        type('coercible.string').enum(*args)
+      end
+
+      def attribute_names
+        schema.keys
+      end
+
+      def attribute(name, type_str, **options)
+        unless type_str.is_a?(String)
+          return handle_manual_type(name, type_str, options)
+        end
+
+        name = name.to_sym
+        type = build_type(type_str, options)
+        schema[name] = type unless attribute_exists?(name, type)
+        nil
+      end
+
+      def build_type(type_str, **options)
+        base = type_str.split('.').last
+        type = Types[type_str]
+        type = apply_defaults(type, options)
+        type = apply_optional(type, options)
+
+        nil_is_allowed = allow_nil?(options)
+
+        type = case base
+               when 'hash'  then handle_hash(type, options)
+               when 'array' then handle_array(type, options)
+               else
+                 type
+               end
+
+        type = apply_constraints(type, options)
+
+        # You have to apply all the contraints before summing nil
+        type = sum_nil(type) if nil_is_allowed
+
+        type
+      end
+
+      def attribute_exists?(name, type)
+        schema[name.to_sym] === type
+      end
+
+      def attribute_conflict?(name, type)
+        name = name.to_sym
+        schema.key?(name) && schema[name] != type
+      end
+
+      def create(inputs = {})
+        self.new(inputs)
+      end
+
+      alias_method :call, :create
+      alias_method :[], :create
+
+      def try(input)
+        Dry::Types::Result::Success.new(self[input])
+      rescue => e
+        failure = Dry::Types::Result::Failure.new(input, e.message)
+        block_given? ? yield(failure) : failure
+      end
+
+      def domain_name
+        @domain_name ||= build_domain_name
+      end
+
+      def domain_basename
+        domain_name.split('.').last
+      end
+
+      def empty_hash(undefined_as_nil = false)
+        data  = {}
+        value = undefined_as_nil == true ? nil : Types::Undefined
+        schema.keys.each do |key|
+          data[key] = value
+        end
+        data
+      end
+
+      private
+
+      def parse_class_name
+        return ["anonmous_#{generate_code(6)}"] if name.nil?
+        name.underscore.split('/')
+      end
+
+      def build_domain_name
+        "#{container_feature_name}.#{container_key_basename}"
+      end
+
+      def generate_code(nbr)
+        charset = Array('A' .. 'Z') + Array('a' .. 'z')
+        Array.new(nbr) { charset.sample }.join
+      end
+
+      def handle_manual_type(name, type, options)
+        name = name.to_sym
+        type = apply_defaults(type, options)
+        if attribute_conflict?(name, type)
+          fail RuntimeError, "Attribute :#{name} has already been defined " +
+            "as another type"
+        end
+
+        schema[name] = type unless attribute_exists?(name, type)
+      end
+
+      def handle_hash(type, options)
+        return type unless options.key?(:hash)
+        constructor = options.fetch(:constructor) { :schema }
+        options.delete(:constructor)
+        valid = [
+          :schema,
+          :weak,
+          :permissive,
+          :strict,
+          :strict_with_defaults,
+          :symbolized
+        ]
+
+        unless valid.include?(constructor)
+          fail "the :constructor of the hash must be one of the " +
+            "following (#{valid.join(' ')})"
+        end
+
+        unless options[:hash].is_a?(Hash)
+          fail ":hash params must be a hash"
+        end
+
+        if options[:hash].empty?
+          fail ":hash params that are empty don't make sense you probably " +
+            "want to exclude the params and use the constructor alone"
+        end
+
+        hash = options.delete(:hash)
+        params = {}
+        hash.each do |key, value|
+          params[key] = value.is_a?(String) ? Types[value] : value
+        end
+        type.send(constructor, params)
+      end
+
+      def handle_array(type, options)
+        if options.key?(:member)
+          member = options.delete(:member)
+          member = member.is_a?(String) ? Types[member] : member
+          type = type.member(member)
+        end
+        type
+      end
+
+      def apply_defaults(type, options)
+        return type unless options.key?(:default)
+
+        type.default(options.delete(:default))
+      end
+
+      def apply_optional(type, options)
+        return type unless options.key?(:optional)
+
+        options.delete(:optional)
+        type.optional
+      end
+
+      def apply_constraints(type, options)
+        return type if options.empty?
+        type.constrained(options)
+      end
+
+      def allow_nil?(options)
+        result = false
+        if options.key?(:allow_nil)
+          options.delete(:allow_nil)
+          result = true
+        end
+        result
+      end
+
+      def sum_nil(type)
+        type | Types['strict.nil']
+      end
+    end
+  end
+end

data/lib/appfuel/domain/entity.rb

@@ -0,0 +1,242 @@
+module Appfuel
+  # Mixin used to add attributes to an object. Attributes are given an name
+  # and have a type declaration which is used to ensure it is correct. Types
+  # are handled by Dry::Types which are mixed into the Types module. When an
+  # object is instaniated dymamic getters and setters are created depending
+  # on if the a value_object flag has been toggled
+  #
+  # @example
+  #   attribute :foo, 'strict.string', default: 'bar', min_size: 3
+  #
+  module Domain
+    class Entity
+      extend Appfuel::Application::ContainerKey
+      extend Appfuel::Application::ContainerClassRegistration
+      extend Dsl
+
+      def initialize(inputs = {})
+        setup_attributes(inputs)
+        enable_undefined
+        @is_global = domain_name.count('.') == 0
+
+      rescue Dry::Types::ConstraintError => e
+        msg = "#{self.class.name} could not initialize: #{e.message}"
+        error = RuntimeError.new(msg)
+        error.set_backtrace(e.backtrace)
+        raise error
+      end
+
+      def global?
+        @is_global
+      end
+
+      def collection?
+        false
+      end
+
+      def hide_undefined?
+        @hide_undefined
+      end
+
+      def hide_undefined
+        @hide_undefined = true
+      end
+
+      def show_undefined
+        @hide_undefined = false
+      end
+
+      def enable_undefined
+        show_undefined
+        @undefined_as_nil = false
+        each_entity do |entity|
+          entity.enable_undefined
+        end
+      end
+
+      def undefined_as_nil
+        @undefined_as_nil = true
+        each_entity do |entity|
+          entity.undefined_as_nil
+        end
+      end
+
+      def undefined_as_nil?
+        @undefined_as_nil
+      end
+
+      def attr_typed!(name, value)
+        self.class.schema[name][value]
+      end
+
+      def data_typed!(type_name, value)
+        data_type(type_name)[value]
+      end
+
+      def data_type(type_name)
+        self.class.type(type_name)
+      end
+
+      def validate_type!(value, type_str, **options)
+        type = self.class.build_type(type_str, **options)
+        type[value]
+      end
+
+      def domain_name
+        self.class.domain_name
+      end
+
+      def domain_basename
+        self.class.domain_basename
+      end
+
+      def to_hash
+        data = {}
+        self.class.schema.each do |key, type|
+          fail "no getter defined for #{key}" unless respond_to?(key)
+          value = send(key)
+          case
+          when value.is_a?(Array)
+            list = []
+            value.each do |item|
+              list << (item.is_a?(Entity) ? item.to_hash : item)
+            end
+            value = list
+          when value.is_a?(Hash)
+            dict = {}
+            value.each do |value_key, item|
+              dict[value_key] = item.is_a?(Entity) ? item.to_hash : item
+            end
+            value = dict
+          when value.respond_to?(:to_hash)
+            value = value.to_hash
+          when value == Types::Undefined
+            if type.respond_to?(:domain_name)
+              value = type.empty_hash(undefined_as_nil? ? true : false)
+            end
+            next if hide_undefined?
+
+          end
+          data[key] = value
+        end
+        data.deep_symbolize_keys
+      end
+
+      def to_h
+        to_hash
+      end
+
+      def has?(key)
+        value = send(key)
+        !value.nil? && value != Types::Undefined
+      end
+
+      private
+
+      def each_attr_schema
+        self.class.schema.each do |key, type|
+          yield key, type
+        end
+      end
+
+      def each_entity
+        each_attr_schema do |key, type|
+          if type.respond_to?(:<) && type < Dsl && has?(key)
+            yield send(key)
+          end
+        end
+      end
+
+      def each_attr
+        each_attr_schema do |key, type|
+          yield key, send(key)
+        end
+      end
+
+      def value_object?
+        self.class.value_object?
+      end
+
+      def setup_attributes(inputs = {})
+        inputs = {} if inputs.nil?
+        inputs = inputs.to_h if inputs == self
+
+        unless inputs.is_a?(Hash)
+          fail "Can not create #{self} entity inputs must be a Hash"
+        end
+
+        inputs.deep_symbolize_keys!
+        self.class.schema.each do |key, type|
+          value = Types::Undefined
+          value = inputs[key] if inputs.key?(key)
+          if value_object?
+            setup_value_object(key, type, value)
+            next
+          end
+          setup_entity(key, type, value)
+        end
+      end
+
+      def setup_value_object(key, type, input)
+        define_getter(key)
+        initialize_value(key, type, input)
+        freeze_instance_var(key)
+      end
+
+      def setup_entity(key, type, input)
+        define_getter(key)
+        initialize_value(key, type, input)
+        define_setter(key, type)
+      end
+
+      def initialize_value(key, type, input)
+        if input == Types::Undefined && type.default?
+          input = type[nil]
+        end
+
+        # manual overrides have to manually type check themselves
+        setter = "#{key}="
+        return send(setter, input) if respond_to?(setter)
+
+        if input != Types::Undefined && input != nil
+          input = type[input]
+        end
+
+        instance_variable_set("@#{key}", input)
+      rescue => e
+        msg   = "#{domain_name} could not assign :#{key} #{e.message}"
+        error = RuntimeError.new(msg)
+        error.set_backtrace(e.backtrace)
+        raise error
+      end
+
+      def define_getter(key)
+        return if respond_to?(key)
+        define_singleton_method(key) do
+          value = instance_variable_get("@#{key}")
+          value = nil if value == Types::Undefined && undefined_as_nil?
+          value
+        end
+      end
+
+      def define_setter(key, type)
+        setter = "#{key}="
+        return if respond_to?(setter)
+
+        define_singleton_method(setter) do |input|
+          value = is_entity?(input, type) ? input : type[input]
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def freeze_instance_var(key)
+        instance_variable_get("@#{key}").freeze
+      end
+
+
+      def is_entity?(value, type)
+        value.respond_to?(:domain_name) && value.domain_name == type.domain_name
+      end
+    end
+  end
+end