trax_core 0.0.76 → 0.0.77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2f12c0eb949c697016820d627ef3467f9a679ee
-  data.tar.gz: cfc59dc2ef2d2ab1bf266b1b649dc15238d984cc
+  metadata.gz: aa0d0a5564b1b1fb8a26de8475b203848b4c1aea
+  data.tar.gz: d3b6b0c5ad07512b6e767ab7f1c5b8fc850286e6
 SHA512:
-  metadata.gz: 8610656021f6fb3456ccc175b4d31864616906ce6a16095739bc18636e1f0572357345e32c5a52f4b0e944b732bc490d34881f1007b1df896d5867ceaf1853a4
-  data.tar.gz: 6f98fccf161ab3c3f3e88bcc0db7f3dc6b1f423109ed0c8cab4147543eb3e979ce1d0fe4ebf9a287792a34ac20bc80a186fa1ee4f1777269b41fcf6da19975e6
+  metadata.gz: 88518e6d9a919091b3a3b2db65a2ebb68cf1ec1e7508a8bf7b731bb56e68a23596973b80967c504ce9d0d433832f90e25336f7d421efcceb10c9ff6e95dbbf60
+  data.tar.gz: 1f66e3eb60887b82a2bd44369dfd48a26f76fe5b62ec83aaaaba3e267eda57775b9eae76b24b19e473a6836873ee14f61e3b0fcafeff4ee6bb908eb0d31dc51d

data/lib/trax/core/definitions.rb

@@ -0,0 +1,49 @@
+module Trax
+  module Core
+    module Definitions
+      def self.extended(base)
+        base.module_attribute(:_definitions) {
+          ::Hashie::Mash.new
+        }
+      end
+
+      def enum(klass_name, **options, &block)
+        attribute_klass = if options.key?(:extend)
+          _klass_prototype = options[:extend].constantize.clone
+          ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", _klass_prototype, :parent_definition => self, &block)
+        else
+          ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", ::Trax::Core::Types::Enum, :parent_definition => self, &block)
+        end
+
+        attribute_klass
+      end
+
+      def struct(klass_name, **options, &block)
+        attribute_klass = if options.key?(:extend)
+          _klass_prototype = options[:extend].constantize.clone
+          ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", _klass_prototype, :parent_definition => self, &block)
+        else
+          ::Trax::Core::NamedClass.new("#{self.name}::#{klass_name}", ::Trax::Core::Types::Struct, :parent_definition => self, &block)
+        end
+
+        attribute_klass
+      end
+
+      def all
+        @all ||= begin
+          constants.map{|const_name| const_get(const_name) }.each_with_object(self._definitions) do |klass, result|
+            result[klass.name.symbolize] = klass
+          end
+        end
+      end
+
+      def values
+        all.values
+      end
+
+      def [](_name)
+        const_get(_name.to_s.camelize)
+      end
+    end
+  end
+end

data/lib/trax/core/fields.rb

@@ -0,0 +1,72 @@
+module Trax
+  module Core
+    module Fields
+      def self.extended(base)
+        base.module_attribute(:_blank_fields_hash) {
+          ::Hashie::Mash.new
+        }
+      end
+
+      def all
+        @all ||= begin
+          constants.map{|const_name| const_get(const_name) }.each_with_object(self._blank_fields_hash) do |klass, result|
+            result[klass.name.symbolize] = klass
+          end
+        end
+      end
+
+      def by_type(*type_names)
+        all.select{|k,v| type_names.include?(v.type) }
+           .try(:with_indifferent_access)
+      end
+
+      def each(&block)
+        all.values(&block)
+      end
+
+      def each_pair(*args, &block)
+        all.each_pair(*args, &block)
+      end
+
+      def booleans
+        @booleans ||= by_type(:boolean)
+      end
+
+      def enums
+        @enums ||= by_type(:enum)
+      end
+
+      def structs
+        @structs ||= by_type(:struct)
+      end
+
+      def strings
+        @strings ||= by_type(:string)
+      end
+
+      def to_schema
+        schema = all.inject(::Hashie::Mash.new) do |result, (k,v)|
+          case v.try(:type)
+          when :enum
+            result[k] = v.to_schema
+          when :struct
+            result[k] = v.to_schema
+          else
+            result[k] = v.try(:to_schema)
+          end
+
+          result
+        end
+        schema
+      end
+
+      def values
+        all.values
+      end
+
+      def [](_name)
+        const_get(_name.to_s.camelize)
+      end
+    end
+  end
+end

data/lib/trax/core/named_class.rb

@@ -1,10 +1,10 @@
 module Trax
   module Core
     class NamedClass
-      def self.new(_name, _parent_klass=nil, **options, &block)
-        klass = ::Object.set_fully_qualified_constant(_name, (_parent_klass ? ::Class.new(_parent_klass) : Class.new do
+      def self.new(_name, _parent_klass=Object, **options, &block)
+        klass = ::Object.set_fully_qualified_constant(_name, ::Class.new(_parent_klass) do
           define_singleton_method(:name) { _name }
-        end))
+        end)
 
         options.each_pair do |k,v|
           klass.class_attribute k

data/lib/trax/core/types/enum.rb

@@ -0,0 +1,224 @@
+# require 'trax/core/inheritance_hooks'
+# require 'active_model/attribute_methods'
+### Examples
+# ProductCategory < Enum
+#   CLOTHING = 1
+#   SHOES = 2
+#   ACCESSORIES = 3
+# end
+# ProductCategory.keys => [:clothing, :shoes, :accessories]
+
+# StoreYearlyRevenue < Enum
+#   :'0_100000' = 1
+#   :'100000_999999' = 2
+#   :'1000000_99999999' = 3
+# end
+
+### Accepts either an integer or the name when setting a value
+# ProductCategory.new(1) => #{name: :clothing, :value => 1}
+module Trax
+  module Core
+    module Types
+      class Enum < SimpleDelegator
+        class_attribute :allow_nil, :raise_on_invalid
+
+        ### Class Methods ###
+        def self.define_enum_value(const_name, val=nil)
+          name = "#{const_name}".underscore.to_sym
+          const_name = name.to_s.camelize
+          val = (self._values_hash.length + 1) if val.nil?
+
+          raise ::Trax::Core::Errors::DuplicateEnumValue.new(:klass => self.class.name, :value => const_name) if self === name
+          raise ::Trax::Core::Errors::DuplicateEnumValue.new(:klass => self.class.name, :value => val) if self === val
+
+          value_klass = self.const_set(const_name, ::Class.new(::Trax::Core::Types::EnumValue){
+            self.tag = name
+            self.value = val
+          })
+
+          self._values_hash[val] = value_klass
+          self._names_hash[name] = value_klass
+        end
+
+        def self.[](val)
+          if ::Is.numeric?(val)
+            self._values_hash[val]
+          elsif ::Is.symbolic?(val)
+            val = val.to_sym if val.is_a?(::String)
+            self._names_hash[val]
+          elsif val.superclass.name == "Trax::Core::Types::EnumValue"
+            val = val.to_sym
+            self._names_hash[val]
+          end
+        end
+
+        def self.as_json(options={})
+          choice.to_s
+        end
+
+        def self.choices
+          @choices ||= self._values_hash.values
+        end
+
+        def self.formatted_choices
+          @formatted_choices ||= choices.each_with_object({}) do |choice, hash|
+            hash[choice.to_i] = choice.to_s
+          end
+        end
+
+        def self.select_values(*args)
+          args.flat_compact_uniq!
+          args.map{|arg| self[arg].to_i }
+        end
+
+        def self.define(*args)
+          define_enum_value(*args)
+        end
+
+        #define multiple values if its iterable
+        def self.define_values(*args)
+          args.each_with_index do |arg, i|
+            define_enum_value(arg, (i + 1))
+          end
+        end
+
+        def self.each(&block)
+          keys.each(&block)
+        end
+
+        def self.each_pair(&block)
+          self._names_hash.each_pair(&block)
+        end
+
+        def self.keys
+          _names_hash.keys
+        end
+
+        def self.key?(name)
+          _names_hash.key?(name)
+        end
+
+        def self.names
+          _names_hash.values
+        end
+
+        def self.no_raise_mode?
+          !raise_on_invalid
+        end
+
+        def self.valid_name?(val)
+          _names_as_strings.include?(val)
+        end
+
+        def self.valid_value?(val)
+          values.include?(val)
+        end
+
+        #because calling valid_value? in the define_enum_value method is unclear
+        def self.value?(val)
+          valid_value?(val)
+        end
+
+        def self.values
+          _names_hash.values.map(&:to_i)
+        end
+
+        def self.===(val)
+          _names_hash.values.any?{|v| v === val }
+        end
+
+        def self.type
+          :enum
+        end
+
+        def self.to_schema
+          ::Trax::Core::Definition.new(
+            :name => self.name.demodulize.underscore,
+            :source => self.name,
+            :type => :enum,
+            :choices => choices.map(&:to_schema),
+            :values => keys
+          )
+        end
+
+        class << self
+          alias :enum_value :define_enum_value
+          alias :define :define_enum_value
+          attr_accessor :_values_hash
+          attr_accessor :_names_hash
+          attr_accessor :_names_as_strings
+        end
+
+        ### Hooks ###
+        def self.inherited(subklass)
+          subklass.instance_variable_set(:@_values_hash, ::Hash.new)
+          subklass.instance_variable_set(:@_names_hash, ::Hash.new)
+          subklass.allow_nil = false
+          subklass.raise_on_invalid = false
+        end
+
+        ### Instance Methods ###
+        attr_reader :choice
+
+        def initialize(val)
+          self.choice = val unless val.nil? && self.class.allow_nil
+        end
+
+        def current_index
+          self.class.names.index(choice)
+        end
+
+        def choice=(val)
+          @choice = valid_choice?(val) ? self.class[val] : nil
+
+          raise ::Trax::Core::Errors::InvalidEnumValue.new(
+            :field => self.class.name,
+            :value => val
+          ) if self.class.raise_on_invalid && !@choice
+
+          @choice
+        end
+
+        def __getobj__
+          @choice || nil
+        end
+
+        def next_value
+          return choice if self.class.names.length == current_index
+          self.class.names[(current_index + 1)]
+        end
+
+        def next_value?
+          !(current_index == (self.class.names.length - 1))
+        end
+
+        #set choice if next value exists, return selected choi
+        def select_next_value
+          self.choice = next_value.to_sym if next_value?
+          self
+        end
+
+        def select_previous_value
+          self.choice = previous_value.to_sym if previous_value?
+          self
+        end
+
+        def previous_value
+          self.class.names[(current_index - 1)]
+        end
+
+        def previous_value?
+          !!current_index
+        end
+
+        def to_s
+          choice.to_s
+        end
+
+        def valid_choice?(val)
+          self.class === val
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/types/enum_value.rb

@@ -0,0 +1,62 @@
+require 'trax/core/abstract_methods'
+module Trax
+  module Core
+    module Types
+      class EnumValue
+        include ::Trax::Core::AbstractMethods
+
+        abstract_class_attribute :tag, :value
+
+        def self.as_json(options={})
+          tag.to_s
+        end
+
+        def self.enum
+          parent
+        end
+
+        def self.to_s
+          tag.to_s
+        end
+
+        def self.to_sym
+          tag
+        end
+
+        def self.to_i
+          value
+        end
+
+        def self.is_enum_value?(val)
+          val == parent
+        end
+
+        def self.to_schema
+          ::Trax::Core::Definition.new(
+            :source => self.name,
+            :name => to_s,
+            :type => :enum_value,
+            :integer_value => to_i
+          )
+        end
+
+        def self.inspect
+          ":#{tag}"
+        end
+
+        def self.include?(val)
+          self.=== val
+        end
+
+        #maybe this is a bad idea, not entirely sure
+        def self.==(val)
+          self.=== val
+        end
+
+        def self.===(val)
+          [tag, to_s, to_i].include?(val)
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/types/struct.rb

@@ -0,0 +1,127 @@
+require 'hashie/extensions/coercion'
+require 'hashie/extensions/indifferent_access'
+require 'hashie/extensions/dash/indifferent_access'
+
+module Trax
+  module Core
+    module Types
+      class Struct < ::Hashie::Dash
+        include ::Hashie::Extensions::Dash::IndifferentAccess
+        include ::Hashie::Extensions::Coercion
+        include ::Hashie::Extensions::IgnoreUndeclared
+        include ::Hashie::Extensions::Dash::PropertyTranslation
+
+        # note that we must explicitly set default or blank values for all properties.
+        # It defeats the whole purpose of being a 'struct'
+        # if we fail to do so, and it makes our data far more error prone
+        DEFAULT_VALUES_FOR_PROPERTY_TYPES = {
+          :boolean_property => nil,
+          :string_property  => "",
+          :struct_property  => {},
+          :enum_property    => nil,
+          :integer_property => nil
+        }.with_indifferent_access.freeze
+
+        def self.fields_module
+          @fields_module ||= begin
+            module_name = "#{self.name}::Fields"
+            ::Trax::Core::NamedModule.new(module_name, ::Trax::Core::Fields)
+          end
+        end
+
+        def self.fields
+          fields_module
+        end
+
+        def self.boolean_property(name, *args, **options, &block)
+          name = name.is_a?(Symbol) ? name.to_s : name
+          klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+          options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+          property(name.to_sym, *args, **options)
+          coerce_key(name.to_sym, ->(value) { !!value })
+        end
+
+        def self.integer_property(name, *args, **options, &block)
+          name = name.is_a?(Symbol) ? name.to_s : name
+          options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+          property(name.to_sym, *args, **options)
+          coerce_key(name.to_sym, Integer)
+        end
+
+        def self.string_property(name, *args, **options, &block)
+          name = name.is_a?(Symbol) ? name.to_s : name
+          options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+          property(name.to_sym, *args, **options)
+          coerce_key(name.to_sym, String)
+        end
+
+        def self.struct_property(name, *args, **options, &block)
+          name = name.is_a?(Symbol) ? name.to_s : name
+          klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+
+          attribute_klass = if options.key?(:extend)
+            _klass_prototype = options[:extend].constantize.clone
+            _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => self, &block)
+            _klass
+          else
+            ::Trax::Core::NamedClass.new(klass_name, ::Trax::Core::Types::Struct, :parent_definition => self, &block)
+          end
+
+          options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+          property(name.to_sym, *args, **options)
+          coerce_key(name.to_sym, attribute_klass)
+        end
+
+        def self.enum_property(name, *args, **options, &block)
+          name = name.is_a?(Symbol) ? name.to_s : name
+          klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+
+          attribute_klass = if options.key?(:extend)
+            _klass_prototype = options[:extend].constantize.clone
+            _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => self, &block)
+            _klass
+          else
+            ::Trax::Core::NamedClass.new(klass_name, ::Trax::Core::Types::Enum, :parent_definition => self, &block)
+          end
+
+          options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+          property(name.to_sym, *args, **options)
+          coerce_key(name.to_sym, attribute_klass)
+        end
+
+        def self.to_schema
+          ::Trax::Core::Definition.new(
+            :source => self.name,
+            :name => self.name.demodulize.underscore,
+            :type => :struct,
+            :fields => self.fields_module.to_schema
+          )
+        end
+
+        def self.type; :struct end;
+
+        def to_serializable_hash
+          _serializable_hash = to_hash
+
+          self.class.fields_module.enums.keys.each do |attribute_name|
+            _serializable_hash[attribute_name] = _serializable_hash[attribute_name].try(:to_i)
+          end if self.class.fields_module.enums.keys.any?
+
+          _serializable_hash
+        end
+
+        class << self
+          alias :boolean :boolean_property
+          alias :enum :enum_property
+          alias :integer :integer_property
+          alias :struct :struct_property
+          alias :string :string_property
+        end
+
+        def value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/types.rb

@@ -0,0 +1,11 @@
+module Trax
+  module Core
+    module Types
+      extend ::ActiveSupport::Autoload
+
+      autoload :Enum
+      autoload :EnumValue
+      autoload :Struct
+    end
+  end
+end

data/lib/trax/core.rb

@@ -21,9 +21,11 @@ module Trax
     autoload :Configuration
     autoload :Concern
     autoload :Definition
+    autoload :Definitions
     autoload :EagerLoadNamespace
     autoload :EagerAutoloadNamespace
     autoload :Errors
+    autoload :Fields
     autoload :FS
     autoload :HasMixins
     autoload :InheritanceHooks
@@ -31,5 +33,6 @@ module Trax
     autoload :Mixable
     autoload :NamedClass
     autoload :NamedModule
+    autoload :Types
   end
 end

data/lib/trax_core/version.rb

@@ -1,3 +1,3 @@
 module TraxCore
-  VERSION = "0.0.76"
+  VERSION = "0.0.77"
 end

data/spec/support/defs.rb

@@ -0,0 +1,26 @@
+module Defs
+  extend ::Trax::Core::Definitions
+
+  enum :Category do
+    define :default,     1
+    define :clothing,    2
+    define :shoes,       3
+    define :accessories, 4
+  end
+
+  struct :ProductAttributes do
+    string :name, :default => ""
+    integer :price, :default => ""
+    boolean :is_active, :default => false
+  end
+
+  struct :ShoesAttributes, :extend => "Defs::ProductAttributes" do
+    enum :size do
+      define :mens_8,  1
+      define :mens_9,  2
+      define :mens_10, 3
+      define :mens_11, 4
+      define :mens_12, 5
+    end
+  end
+end

data/spec/trax/core/definitions_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ::Trax::Core::Definitions do
+  subject { ::Defs }
+
+  context "enum" do
+    let(:test_subject) { subject::Category.new(1) }
+
+    it { expect(test_subject).to be_a(::Trax::Core::Types::Enum) }
+    it { expect(test_subject.name).to eq "Defs::Category::Default" }
+  end
+
+  context "struct" do
+    it { expect(subject::ProductAttributes.new).to be_a(::Trax::Core::Types::Struct) }
+  end
+
+  context "inheritance" do
+    it { expect(subject::ProductAttributes.new).to_not have_key(:size) }
+    it { expect(subject::ShoesAttributes.new).to have_key(:size) }
+    it { expect(subject::ShoesAttributes.new).to have_key(:price) }
+    it { expect(subject::ShoesAttributes.new(:size => :mens_8).size.to_i).to eq 1 }
+  end
+end

data/spec/trax/core/types/enum_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ::Trax::Core::Types::Enum do
+  before(:all) do
+    module MyFakeEnumNamespace
+      extend ::Trax::Core::Definitions
+
+      enum :Locale do
+        define :en, 1
+        define :da, 2
+        define :ca, 3
+      end
+    end
+  end
+
+  subject { "::MyFakeEnumNamespace::Locale".constantize.new(:en) }
+
+  it { expect(subject.to_i).to eq 1 }
+
+  context "integer value" do
+    subject { "::MyFakeEnumNamespace::Locale".constantize.new(1) }
+
+    it { expect(subject).to eq :en }
+  end
+
+  context "non existent value" do
+    subject { "::MyFakeEnumNamespace::Locale".constantize.new(:blah) }
+
+    it { expect(subject).to eq nil }
+  end
+end

data/spec/trax/core/types/struct_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ::Trax::Core::Types::Struct do
+  before(:all) do
+    module MyFakeStructNamespace
+      extend ::Trax::Core::Definitions
+
+      struct :Locale do
+        string :en, :default => ""
+        string :da, :default => ""
+        string :ca, :default => "eh"
+      end
+    end
+  end
+
+  subject { "::MyFakeStructNamespace::Locale".constantize.new(:en => "something") }
+
+  it { expect(subject).to have_key("en") }
+  it { expect(subject.en).to eq "something" }
+  it { expect(subject.da).to eq "" }
+  it { expect(subject.ca).to eq "eh" }
+
+  context "unknown value" do
+    subject { "::MyFakeStructNamespace::Locale".constantize.new(:blah => "something") }
+    it { expect(subject).to_not respond_to(:blah) }
+    it { expect(subject.en).to eq "" }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trax_core
 version: !ruby/object:Gem::Version
-  version: 0.0.76
+  version: 0.0.77
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-09 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -184,6 +184,7 @@ files:
 - lib/trax/core/concern.rb
 - lib/trax/core/configuration.rb
 - lib/trax/core/definition.rb
+- lib/trax/core/definitions.rb
 - lib/trax/core/eager_autoload_namespace.rb
 - lib/trax/core/eager_load_namespace.rb
 - lib/trax/core/errors.rb
@@ -197,6 +198,7 @@ files:
 - lib/trax/core/ext/string.rb
 - lib/trax/core/ext/symbol.rb
 - lib/trax/core/ext/uri.rb
+- lib/trax/core/fields.rb
 - lib/trax/core/fs.rb
 - lib/trax/core/has_mixins.rb
 - lib/trax/core/inheritance_hooks.rb
@@ -207,10 +209,15 @@ files:
 - lib/trax/core/named_module.rb
 - lib/trax/core/primitives/enum.rb
 - lib/trax/core/primitives/enum_value.rb
+- lib/trax/core/types.rb
+- lib/trax/core/types/enum.rb
+- lib/trax/core/types/enum_value.rb
+- lib/trax/core/types/struct.rb
 - lib/trax_core.rb
 - lib/trax_core/version.rb
 - spec/spec_helper.rb
 - spec/support/category_enum.rb
+- spec/support/defs.rb
 - spec/support/ecom.rb
 - spec/support/ecom/widget.rb
 - spec/support/ecom/widget_category.rb
@@ -226,6 +233,7 @@ files:
 - spec/support/storefront/product.rb
 - spec/trax/array_spec.rb
 - spec/trax/core/concern_spec.rb
+- spec/trax/core/definitions_spec.rb
 - spec/trax/core/eager_autoload_namespace_spec.rb
 - spec/trax/core/errors_spec.rb
 - spec/trax/core/ext/array_spec.rb
@@ -237,6 +245,8 @@ files:
 - spec/trax/core/inheritance_spec.rb
 - spec/trax/core/named_class_spec.rb
 - spec/trax/core/named_module_spec.rb
+- spec/trax/core/types/enum_spec.rb
+- spec/trax/core/types/struct_spec.rb
 - spec/trax/core_spec.rb
 - spec/trax/enum_spec.rb
 - spec/trax/hash_spec.rb
@@ -268,6 +278,7 @@ summary: Core Trax Dependencies
 test_files:
 - spec/spec_helper.rb
 - spec/support/category_enum.rb
+- spec/support/defs.rb
 - spec/support/ecom.rb
 - spec/support/ecom/widget.rb
 - spec/support/ecom/widget_category.rb
@@ -283,6 +294,7 @@ test_files:
 - spec/support/storefront/product.rb
 - spec/trax/array_spec.rb
 - spec/trax/core/concern_spec.rb
+- spec/trax/core/definitions_spec.rb
 - spec/trax/core/eager_autoload_namespace_spec.rb
 - spec/trax/core/errors_spec.rb
 - spec/trax/core/ext/array_spec.rb
@@ -294,6 +306,8 @@ test_files:
 - spec/trax/core/inheritance_spec.rb
 - spec/trax/core/named_class_spec.rb
 - spec/trax/core/named_module_spec.rb
+- spec/trax/core/types/enum_spec.rb
+- spec/trax/core/types/struct_spec.rb
 - spec/trax/core_spec.rb
 - spec/trax/enum_spec.rb
 - spec/trax/hash_spec.rb