holotype 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cec00eba6093334124b9af2074359ab2d19ea7bf
-  data.tar.gz: ffc97f6ca90bf16613f6567b0aa1fd911cde8683
+  metadata.gz: c8de676ea732eeaafa954422a48c138e2e0fb6a8
+  data.tar.gz: d52556331331d5b80e9d79635895f1364e4115a4
 SHA512:
-  metadata.gz: 159ce5c4894bc7087802094a00cfdfadebf88c6c7d1a3eb939a572c37f84891b81d291567545cf5f71dfe04786a17ead18c0315d6a53a4bd3789eb9c26161174
-  data.tar.gz: b1c8b238d0c85592928dbe487d62b141163fd8abd57ade5d11a987ff79da7ae08faeb7bcfe87814e5f9cd26de12d8d42b3c13c79acd4806104a30681e1d6b478
+  metadata.gz: d615c9697c7d70431b710fe7882f03867f2949503ecb85fc6465b2e0051ce85b91b886ea3de9a30cc4f3382ca5e9302e97094ecb319f768a18da01d6687364fe
+  data.tar.gz: 17e20c875c8fd863a3536753228a258aed88b0556120a1af750c5b8b2066507fa182f8cb6a6830fbc174dac7f52e62a81b90ee74d1a64a1d9a997f2283a40807

data/lib/holotype/attribute/definition/default_conflict_error.rb

@@ -0,0 +1,14 @@
+class Holotype
+  class Attribute
+    class Definition
+      class DefaultConflictError < StandardError
+        def message; MESSAGE; end
+
+        private
+
+        MESSAGE = 'Attribute definitions cannot have both a default value ' \
+                  'and a default block'.freeze
+      end
+    end
+  end
+end

data/lib/holotype/attribute/definition/no_collection_class_error.rb

@@ -0,0 +1,18 @@
+class Holotype
+  class Attribute
+    class Definition
+      class NoCollectionClassError < StandardError
+        attr_reader :definition
+
+        def initialize definition
+          @definition = definition
+        end
+
+        def message
+          "No collection class for attribute definition: #{definition.name}"
+            .freeze
+        end
+      end
+    end
+  end
+end

data/lib/holotype/attribute/definition/no_value_class_error.rb

@@ -0,0 +1,17 @@
+class Holotype
+  class Attribute
+    class Definition
+      class NoValueClassError < StandardError
+        attr_reader :definition
+
+        def initialize definition
+          @definition = definition
+        end
+
+        def message
+          "No value class for attribute definition: #{definition.name}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/holotype/attribute/definition/required_conflict_error.rb

@@ -0,0 +1,14 @@
+class Holotype
+  class Attribute
+    class Definition
+      class RequiredConflictError < StandardError
+        def message; MESSAGE; end
+
+        private
+
+        MESSAGE = 'Attribute definitions cannot both be required and provide ' \
+                  'a default'.freeze
+      end
+    end
+  end
+end

data/lib/holotype/attribute/definition.rb

@@ -0,0 +1,123 @@
+%w[
+  default_conflict_error
+  no_collection_class_error
+  no_value_class_error
+  required_conflict_error
+].each { |file| require_relative "definition/#{file}" }
+
+require_relative 'definition/default_conflict_error.rb'
+
+class Holotype
+  class Attribute
+    class Definition
+      attr_reader :name
+
+      def initialize name, **options, &default_block
+        @collection = options.fetch :collection, false
+        @immutable  = options.fetch :immutable, false
+        @name       = name
+        @read_only  = options.fetch :read_only, false
+        @required   = options.fetch :required, false
+
+        if options.key? :collection_class
+          @collection           = true
+          @has_collection_class = true
+          @collection_class     = options[:collection_class]
+        else
+          if collection?
+            @has_collection_class = true
+            @collection_class     = Array
+          else
+            @has_collection_class = false
+          end
+        end
+
+        if options.key? :value_class
+          @has_value_class = true
+          @value_class     = options[:value_class]
+        else
+          @has_value_class = false
+        end
+
+        if default_block
+          raise DefaultConflictError.new  if options.key? :default
+          raise RequiredConflictError.new if @required
+
+          @default      = default_block
+          @default_type = :dynamic
+        elsif options.key? :default
+          raise RequiredConflictError.new if @required
+
+          @default      = options[:default]
+          @default_type = :constant
+        end
+      end
+
+      def default receiver
+        case @default_type
+        when :constant then @default
+        when :dynamic  then receiver.instance_exec(&@default).freeze
+        else nil
+        end
+      end
+
+      def normalize value
+        if collection?
+          normalize_collection value
+        else
+          normalize_single value
+        end
+      end
+
+      def required?
+        !!@required
+      end
+
+      def has_value_class?
+        @has_value_class
+      end
+
+      def value_class
+        raise NoValueClassError.new self unless has_value_class?
+        @value_class
+      end
+
+      def collection?
+        !!@collection
+      end
+
+      def has_collection_class?
+        @has_collection_class
+      end
+
+      def collection_class
+        return @collection_class if has_collection_class?
+        raise NoCollectionClassError.new self
+      end
+
+      def read_only?
+        !!@read_only
+      end
+
+      def immutable?
+        !!@immutable
+      end
+
+      private
+
+      def normalize_single value
+        ValueNormalizer
+          .new(self)
+          .normalize value
+      end
+
+      def normalize_collection values
+        CollectionNormalizer.new(self).normalize values
+      end
+
+      def symbolize_keys hash
+        Hash[hash.map { |key, value| [key.to_sym, value] }]
+      end
+    end
+  end
+end

data/lib/holotype/attribute/frozen_modification_error.rb

@@ -0,0 +1,15 @@
+class Holotype
+  class Attribute
+    class FrozenModificationError < StandardError
+      attr_reader :attribute_name
+
+      def initialize attribute_name
+        @attribute_name = attribute_name.freeze
+      end
+
+      def message
+        "Cannot modify value of `#{attribute_name}` in frozen object".freeze
+      end
+    end
+  end
+end

data/lib/holotype/attribute/immutable_value_error.rb

@@ -0,0 +1,15 @@
+class Holotype
+  class Attribute
+    class ImmutableValueError < StandardError
+      attr_reader :name
+
+      def initialize name
+        @name = name.freeze
+      end
+
+      def message
+        "Cannot modify value of `#{name}` in immutable class".freeze
+      end
+    end
+  end
+end

data/lib/holotype/attribute/read_only_error.rb

@@ -0,0 +1,15 @@
+class Holotype
+  class Attribute
+    class ReadOnlyError < StandardError
+      attr_reader :name
+
+      def initialize name
+        @name = name.freeze
+      end
+
+      def message
+        "Cannot modify read-only attribute `#{name}`".freeze
+      end
+    end
+  end
+end

data/lib/holotype/attribute.rb

@@ -0,0 +1,43 @@
+%w[
+  definition
+  frozen_modification_error
+  immutable_value_error
+  read_only_error
+].each { |file| require_relative "attribute/#{file}" }
+
+class Holotype
+  class Attribute
+    attr_reader :definition, :owner
+
+    def initialize owner, definition, **options
+      @definition = definition
+      @owner      = owner
+
+      set_value options[:value] if options.key? :value
+    end
+
+    def name
+      definition.name
+    end
+
+    def value
+      set_value definition.default owner unless @has_value
+      @value
+    end
+
+    def value= new_value
+      raise ImmutableValueError.new     name if definition.immutable?
+      raise FrozenModificationError.new name if owner.frozen?
+      raise ReadOnlyError.new           name if definition.read_only?
+
+      set_value new_value
+    end
+
+    private
+
+    def set_value new_value
+      @has_value = true
+      @value     = definition.normalize new_value
+    end
+  end
+end

data/lib/holotype/attributes_already_defined_error.rb

@@ -0,0 +1,9 @@
+class Holotype
+  class AttributesAlreadyDefinedError < StandardError
+    def message; MESSAGE; end
+
+    private
+
+    MESSAGE = 'Cannot make class immutable afer attributes are defined'.freeze
+  end
+end

data/lib/holotype/collection_normalizer/expected_array_like_collection_error.rb

@@ -0,0 +1,16 @@
+class Holotype
+  class CollectionNormalizer
+    class ExpectedArrayLikeCollectionError < StandardError
+      attr_reader :attribute
+
+      def initialize attribute
+        @attribute = attribute
+      end
+
+      def message
+        "Attribute `#{attribute}` expected Array-like collection, received " \
+        "Hash-like collection".freeze
+      end
+    end
+  end
+end

data/lib/holotype/collection_normalizer/expected_hash_like_collection_error.rb

@@ -0,0 +1,16 @@
+class Holotype
+  class CollectionNormalizer
+    class ExpectedHashLikeCollectionError < StandardError
+      attr_reader :attribute
+
+      def initialize attribute
+        @attribute = attribute
+      end
+
+      def message
+        "Attribute `#{attribute}` expected Hash-like collection, received " \
+        "Array-like collection".freeze
+      end
+    end
+  end
+end

data/lib/holotype/collection_normalizer.rb

@@ -0,0 +1,155 @@
+%w[
+  expected_array_like_collection_error
+  expected_hash_like_collection_error
+].each { |file| require_relative "collection_normalizer/#{file}" }
+
+class Holotype
+  class CollectionNormalizer
+    extend Memorandum
+
+    ARRAY_LIKE_METHODS = %i[
+      []
+      []=
+    ].freeze
+
+    HASH_LIKE_METHODS = %i[
+      []
+      []=
+      keys
+      values
+    ]
+
+    attr_reader :definition
+
+    def initialize definition
+      @definition = definition
+    end
+
+    def normalize collection
+      check_likeness_of collection
+
+      result = classify normalized collection
+
+      if definition.immutable?
+        result.freeze
+      else
+        result
+      end
+    end
+
+    private
+
+    memo def value_normalizer
+      ValueNormalizer.new definition
+    end
+
+    def check_likeness_of collection
+      if hash_like?
+        raise ExpectedHashLikeCollectionError.new definition.name \
+          unless collection.nil? || object_is_hash_like?(collection)
+      elsif array_like?
+        raise ExpectedArrayLikeCollectionError.new definition.name \
+          unless collection.nil? || object_is_array_like?(collection)
+      end
+    end
+
+    def hash_like?
+      return false unless definition.has_collection_class?
+
+      class_is_hash_like? definition.collection_class
+    end
+
+    def array_like?
+      return false unless definition.has_collection_class?
+      return false if hash_like?
+
+      class_is_array_like? definition.collection_class
+    end
+
+    def class_is_array_like? klass
+      return false if class_is_hash_like? klass
+
+      instance_methods = klass.instance_methods
+
+      ARRAY_LIKE_METHODS.all? do |method|
+        instance_methods.include? method
+      end
+    end
+
+    def class_is_hash_like? klass
+      instance_methods = klass.instance_methods
+
+      HASH_LIKE_METHODS.all? do |method|
+        instance_methods.include? method
+      end
+    end
+
+    def object_is_array_like? object
+      return false if object_is_hash_like? object
+
+      ARRAY_LIKE_METHODS.all? do |method|
+        object.respond_to? method
+      end
+    end
+
+    def object_is_hash_like? object
+      HASH_LIKE_METHODS.all? do |method|
+        object.respond_to? method
+      end
+    end
+
+    def hash_like collection
+      return collection unless definition.has_collection_class?
+
+      definition
+        .collection_class
+        .new
+        .tap do |result|
+          collection.each { |key, value| result[key] = value }
+        end
+    end
+
+    def array_like collection
+      return collection unless definition.has_collection_class?
+
+      definition
+        .collection_class
+        .new
+        .tap do |result|
+          collection.each { |value| result << value }
+        end
+    end
+
+    def classify collection
+      if object_is_hash_like? collection
+        hash_like collection
+      else
+        array_like collection
+      end
+    end
+
+    def normalized collection
+      if hash_like?
+        normalized_hash collection
+      else
+        normalized_array collection
+      end
+    end
+
+    def normalized_hash collection
+      collection ||= Hash[]
+
+      Hash[
+        collection.map do |key, value|
+          [key, value_normalizer.normalize(value)]
+        end
+      ]
+    end
+
+    def normalized_array collection
+      collection ||= []
+
+      collection.map { |value| value_normalizer.normalize value }
+    end
+  end
+end

data/lib/holotype/inheritance_disallowed_error.rb

@@ -0,0 +1,9 @@
+class Holotype
+  class InheritanceDisallowedError < StandardError
+    def message; MESSAGE; end
+
+    private
+
+    MESSAGE = 'Cannot inherit from immutable class'.freeze
+  end
+end

data/lib/holotype/missing_required_attributes_error.rb

@@ -0,0 +1,34 @@
+class Holotype
+  class MissingRequiredAttributesError < StandardError
+    attr_reader :attributes, :original_class
+
+    def initialize original_class, attributes
+      @attributes     = attributes
+      @original_class = original_class
+    end
+
+    def message
+      "Class `#{original_class.name}` requires the following attributes:" \
+      "#{format_list required_attributes}"                                \
+      "\n\n"                                                              \
+      "Missing attributes:"                                               \
+      "#{format_list attributes}".freeze
+    end
+
+    private
+
+    def required_attributes
+      original_class
+        .attributes
+        .values
+        .select(&:required?)
+        .map(&:name)
+    end
+
+    def format_list attributes
+      attributes
+        .map { |name| "\n  * #{name}" }
+        .join
+    end
+  end
+end

data/lib/holotype/value_normalizer.rb

@@ -0,0 +1,27 @@
+class Holotype
+  class ValueNormalizer
+    attr_reader :definition
+
+    def initialize definition
+      @definition = definition
+    end
+
+    def normalize value
+      result = if definition.has_value_class?
+                 if value.nil?
+                   nil
+                 else
+                   definition.value_class.new value
+                 end
+               else
+                 value
+               end
+
+      if definition.immutable?
+        result.freeze
+      else
+        result
+      end
+    end
+  end
+end

data/lib/holotype/version.rb

@@ -0,0 +1,3 @@
+class Holotype
+  VERSION = '0.15.1'.freeze
+end

data/lib/holotype.rb

@@ -0,0 +1,182 @@
+%w[
+  memorandum
+].each { |gem| require gem }
+
+%i[
+  attribute
+  attributes_already_defined_error
+  collection_normalizer
+  inheritance_disallowed_error
+  missing_required_attributes_error
+  value_normalizer
+  version
+].each { |name| require_relative "holotype/#{name}.rb" }
+
+class Holotype
+  # Singleton Definition
+
+  class << self
+    def attribute name, **options, &default
+      # symbolize name
+      name = name.to_sym
+
+      # prepare options
+      processed_options = if immutable?
+                            [
+                              __default_attribute_options,
+                              options,
+                              IMMUTABLE_OPTION,
+                            ].reduce :merge
+                          else
+                            [
+                              __default_attribute_options,
+                              options,
+                            ].reduce :merge
+                          end
+
+      # create attribute definition
+      attribute = Attribute::Definition.new name,
+                                            **processed_options,
+                                            &default
+
+      # store the attribute definition
+      attributes[name] = attribute
+
+      # create an attribute reader
+      define_method name do
+        self.attributes[name].value
+      end
+
+      # create an attribute writer
+      define_method "#{name}=" do |value|
+        self.attributes[name].value = value
+      end
+    end
+
+    def attributes
+      @attributes ||= Hash[]
+    end
+
+    def make_immutable
+      raise AttributesAlreadyDefinedError.new if attributes.count != 0
+
+      define_singleton_method :inherited do |_|
+        raise InheritanceDisallowedError.new
+      end
+
+      @immutable = true
+    end
+
+    def immutable?
+      !!@immutable
+    end
+
+    def default_attribute_options **options
+      @default_attribute_options = options.freeze
+    end
+
+    private
+
+    IMMUTABLE_OPTION = Hash[immutable: true].freeze
+
+    def __default_attribute_options
+      @default_attribute_options || Hash[]
+    end
+  end
+
+  # Instance Definition
+
+  attr_reader :attributes
+
+  def initialize **attributes
+    __holotype_check_for_missing_required attributes
+    __holotype_store attributes
+  end
+
+  def frozen?
+    true
+  end
+
+  def to_hash
+    Hash[
+      attributes
+        .map do |key, attribute|
+          definition = attribute.definition
+
+          value = __holotype_hashify attribute.value
+
+          [key, value]
+        end
+    ]
+  end
+
+  def == other
+    return false unless self.class == other.class
+
+    attributes.all? do |name, attribute|
+      attribute.value == other.attributes[name].value
+    end
+  end
+
+  def with **attributes
+    self.class.new to_hash.merge attributes
+  end
+
+  def inspect
+    data = to_hash
+             .map { |attribute, value| "#{attribute}: #{value.inspect}" }
+             .join(', ')
+
+    "#{self.class.name}(#{data})"
+  end
+
+  private
+
+  def __holotype_hashify value
+    if value.respond_to? :to_hash
+      value.to_hash
+    elsif value.kind_of? Enumerable
+      value.map { |value| __holotype_hashify value }
+    else
+      value
+    end
+  end
+
+  def __holotype_check_for_missing_required attributes
+    self
+      .class
+      .attributes
+      .flat_map do |name, attribute|
+        # skip non-required attributes
+        next [] unless attribute.required?
+
+        # skip attributes with provided values
+        next [] if attributes.key? name
+
+        [name]
+      end
+      .tap do |missing_attributes|
+        next if missing_attributes.empty?
+        raise MissingRequiredAttributesError.new self.class, missing_attributes
+      end
+  end
+
+  def __holotype_store attributes
+    @attributes = Hash[
+                    self
+                      .class
+                      .attributes
+                      .map do |name, definition|
+                        options = if attributes.key? name
+                                    Hash value: attributes[name]
+                                  else
+                                    Hash[]
+                                  end
+
+                        attribute = Attribute.new self, definition, **options
+
+                        [name, attribute]
+                      end
+                  ].freeze
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: holotype
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Robert Lude
@@ -58,20 +58,38 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.2
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.2
+        version: '2.1'
 description: 
 email: rob@ertlu.de
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/holotype.rb
+- lib/holotype/attribute.rb
+- lib/holotype/attribute/definition.rb
+- lib/holotype/attribute/definition/default_conflict_error.rb
+- lib/holotype/attribute/definition/no_collection_class_error.rb
+- lib/holotype/attribute/definition/no_value_class_error.rb
+- lib/holotype/attribute/definition/required_conflict_error.rb
+- lib/holotype/attribute/frozen_modification_error.rb
+- lib/holotype/attribute/immutable_value_error.rb
+- lib/holotype/attribute/read_only_error.rb
+- lib/holotype/attributes_already_defined_error.rb
+- lib/holotype/collection_normalizer.rb
+- lib/holotype/collection_normalizer/expected_array_like_collection_error.rb
+- lib/holotype/collection_normalizer/expected_hash_like_collection_error.rb
+- lib/holotype/inheritance_disallowed_error.rb
+- lib/holotype/missing_required_attributes_error.rb
+- lib/holotype/value_normalizer.rb
+- lib/holotype/version.rb
 homepage: https://www.github.com/robertlude/holotype
 licenses:
 - MIT
@@ -92,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Simple models