trax_core 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0ab417a5f629ffa26dd2ed8aa06606ad0ef8da8
-  data.tar.gz: 0e40b82964838f3a67ce14188f88fa50a3f53b6b
+  metadata.gz: 0fea6e82d277b0d2b84405221ea0c6604efbc2d1
+  data.tar.gz: 19e536032336156466c42a90df643e080f2a584e
 SHA512:
-  metadata.gz: 0fb3074b04d8a8d4aef67b29c74d0d26fdaf448aeef86e4840a41fd123f6882fce2d93257022440aab3f60678617166ce20e913cef86ebd92595c6fb5af7ced6
-  data.tar.gz: cb0cc1e316457f2d1a8b62eca08c36de77011b8c752ab7fe364107f40a7b093b245f56de65c8acc90e6400877a5cd690406b80d1a6be2ae9230d972f0ec74e04
+  metadata.gz: 02861133c520bfb36217068f12ba983d865bf5d87d478d34e9486753a8e50073250f12ee3f4ddb72384593ceffdb5f629da35ec81220b3e84440154550d79a84
+  data.tar.gz: ef5faec34cb92cf6c37078f979911955f02c6c13a45320a1201479b8a061e532a3c7a90b161c5dba4af3b8d61d290da27b9b6c27092dabe989c68ccd1d0871fc

data/lib/trax/core/abstract_methods.rb

@@ -0,0 +1,68 @@
+module Trax
+  module Core
+    module AbstractMethods
+      extend ::ActiveSupport::Concern
+
+      included do
+        private
+        class_attribute :_abstract_methods, :_abstract_class_methods, :_abstract_class_attributes
+        self._abstract_methods = []
+        self._abstract_class_methods = []
+        self._abstract_class_attributes = []
+      end
+
+      module ClassMethods
+        def abstract_method(*method_names)
+          _abstract_methods.push(*method_names)
+        end
+        alias :abstract_methods :abstract_method
+
+        def abstract_class_method(*method_names)
+          _abstract_class_methods.push(*method_names)
+        end
+        alias :abstract_class_methods :abstract_class_method
+
+        def abstract_class_attribute(*method_names)
+          _abstract_class_attributes.push(*method_names)
+          class_attribute(*method_names)
+        end
+        alias :abstract_class_attributes :abstract_class_attribute
+
+        def inherited(subklass)
+          klass = super(subklass)
+
+          trace = ::TracePoint.new(:end) do |tracepoint|
+            if tracepoint.self == subklass #modules also trace end we only care about the class end
+              trace.disable
+
+              if _abstract_methods.any?
+                missing_instance_methods = ( Array(_abstract_methods) - subklass.instance_methods(false) )
+
+                raise NotImplementedError, "#{subklass} must implement the following instance method(s) \n" \
+                                           << "#{missing_instance_methods}" if missing_instance_methods.any?
+              end
+
+              if _abstract_class_methods.any?
+                missing_class_methods = ( Array(_abstract_class_methods) - subklass.singleton_methods(false) )
+
+                raise NotImplementedError, "#{subklass} must implement the following class method(s) \n" \
+                                            << "#{missing_class_methods}" if missing_class_methods.any?
+              end
+
+              if _abstract_class_attributes.any?
+                missing_class_attributes = _abstract_class_attributes.select{|_property| subklass.__send__(_property).blank? }
+
+                raise NotImplementedError, "#{subklass} must set the following class attributes(s) \n" \
+                                            << "#{missing_class_attributes}" if missing_class_attributes.any?
+              end
+            end
+          end
+
+          trace.enable
+
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/concern.rb

@@ -0,0 +1,47 @@
+module Trax
+  module Core
+    module Concern
+      def included(base = nil, &block)
+        super(base, &block)
+
+        trace = ::TracePoint.new(:end) do |tracepoint|
+          if tracepoint.self == base
+            trace.disable
+
+            if self.instance_variable_defined?(:@_after_included_block)
+              base.instance_eval(&self.instance_variable_get(:@_after_included_block))
+            end
+          end
+        end
+
+        trace.enable
+      end
+
+      def self.extended(base)
+        base.extend(::ActiveSupport::Concern)
+
+        super(base)
+
+        trace = ::TracePoint.new(:end) do |tracepoint|
+          if tracepoint.self == base
+            trace.disable
+
+            if base.instance_variable_defined?(:@_after_extended_block)
+              base.instance_variable_get(:@_after_extended_block).call
+            end
+          end
+        end
+
+        trace.enable
+      end
+
+      def after_extended(&block)
+        self.instance_variable_set(:@_after_extended_block, block)
+      end
+
+      def after_included(&block)
+        self.instance_variable_set(:@_after_included_block, block)
+      end
+    end
+  end
+end

data/lib/trax/core/configuration.rb

@@ -7,10 +7,12 @@ module Trax
     class Configuration
       include ActiveModel::Validations
 
+      class_attribute :source
+
       def initialize
         set_default_values
 
-        yield self
+        yield self if block_given?
 
         raise_errors unless self.valid?
       end
@@ -22,6 +24,8 @@ module Trax
       end
 
       def self.inherited(subklass)
+        super(subklass)
+
         subklass.class_attribute :configurable_options
         subklass.configurable_options = {}
       end
@@ -31,9 +35,30 @@ module Trax
 
         validates_presence_of(attr_name) if(options.key?(:required))
 
+        if(options.key?(:validates))
+          validates(attr_name, options[:validates])
+        end
+
+        define_method("#{attr_name}=") do |val|
+          value = options.key?(:setter) ? options[:setter].call(val) : val
+          instance_variable_set("@#{attr_name}", value)
+
+          raise_errors unless self.valid?
+        end
+
+        if(options.key?(:getter))
+          define_method(attr_name) do |val|
+            options[:getter].call(val)
+          end
+        end
+
         self.configurable_options[attr_name] = options
       end
 
+      def merge!(options = {})
+        options.each_pair{ |k,v| __send__("#{k}=", v) }
+      end
+
       def raise_errors
         raise Trax::Core::Errors::ConfigurationError.new(
           :messages => self.errors.full_messages,

data/lib/trax/core/eager_autoload_namespace.rb

@@ -4,7 +4,7 @@ module Trax
       def self.extended(base)
         source_file_path = caller[0].partition(":")[0]
 
-        base.class_eval do
+        base.module_eval do
           extend ::ActiveSupport::Autoload
 
           @eager_autoload_filepath = source_file_path

data/lib/trax/core/eager_load_namespace.rb

@@ -0,0 +1,18 @@
+module Trax
+  module Core
+    module EagerLoadNamespace
+      def self.extended(base)
+        source_file_path = caller[0].partition(":")[0]
+
+        base.module_attribute(:eager_autoload_filepath) { source_file_path }
+        base.module_attribute(:module_path) { ::Pathname.new(::File.path(base.eager_autoload_filepath).gsub(".rb", "")) }
+
+        ::Trax::Core::FS::Directory.new(base.module_path).files.each do |file|
+          load file
+        end
+
+        super(base)
+      end
+    end
+  end
+end

data/lib/trax/core/errors.rb

@@ -92,6 +92,17 @@ module Trax
           "#{messages.join('\n')}"
         }
       end
+
+      class MixinNotRegistered < ::Trax::Core::Errors::Base
+        argument :mixin
+        argument :source
+        argument :mixin_namespace
+
+        message {
+          "#{source} tried to load mixin: #{mixin}, whichdoes not exist in " \
+          "registry. Registered mixins were #{mixin_namespace.mixin_registry.keys.join(', ')} \n"
+        }
+      end
     end
   end
 end

data/lib/trax/core/ext/enumerable.rb

@@ -0,0 +1,5 @@
+module Enumerable
+  def group_by_count
+    ::Hash.new(0).tap{|hash| each{|item| hash[item] += 1 } }
+  end
+end

data/lib/trax/core/ext/module.rb

@@ -1,4 +1,11 @@
 class Module
+  def module_attribute(*attribute_names, &block)
+    attribute_names.each do |_attribute_name|
+      singleton_class.__send__("attr_accessor", _attribute_name)
+      instance_variable_set("@#{_attribute_name}", block.call) if block_given?
+    end
+  end
+
   def recursively_define_namespaced_class(class_name, class_to_inherit_from = Object)
     paths = class_name.split("::")
     const_name = paths.shift

data/lib/trax/core/ext/object.rb

@@ -1,35 +1,55 @@
 require "active_support/core_ext/object/try"
-
+require 'pry'
 class Object
   # Defines a Configuration Class within a target module namespace, or nested class
   # i.e. configuration_for(::Ecommerce::Cart) will define
   # Ecommerce::Cart::Configuration class, inherited form Trax::Core::Configuration
   # And we can then define specific configuration options, for that class, on that class
-  def configuration_for(target, &blk)
-    target.class_eval do
-      class << self
-        attr_accessor :_configuration
-      end
+  def configuration_for(target, as = :configuration, run_configuration = false, &blk)
+    configuration_ivar_name = (as == :configuration) ? :configuration : :"#{as}_configuration"
+    configuration_ivar_name_shortcut = (as == :configuration) ? :config : :"#{as}_config"
+    target.const_set(configuration_ivar_name.to_s.classify, ::Class.new(::Trax::Core::Configuration))
+    configuration_klass = target.const_get(configuration_ivar_name.to_s.classify)
+    configuration_klass.source = target
 
-      const_set("Configuration", ::Class.new(::Trax::Core::Configuration))
-      const_get("Configuration").instance_eval(&blk)
+    configurer_method_name = (as == :configuration) ? :configure : :"configure_#{as}"
+    target.singleton_class.__send__(:attr_accessor, configuration_ivar_name)
+    target.singleton_class.instance_variable_set("@#{configuration_ivar_name}", configuration_klass.instance_eval(&blk))
+    target.singleton_class.__send__(:alias_method, configuration_ivar_name_shortcut, configuration_ivar_name)
 
-      def self.configure(&block)
-        @_configuration = const_get("Configuration").new(&block)
-      end
-
-      def self.config
-        _configuration
+    target.define_singleton_method(configurer_method_name) do |&block|
+      if block
+        return instance_variable_set("@#{configuration_ivar_name}", configuration_klass.new(&block)) if !instance_variable_get("@#{configuration_ivar_name}")
+        return instance_variable_get("@#{configuration_ivar_name}").instance_eval(&block)
+      else
+        return instance_variable_set("@#{configuration_ivar_name}", configuration_klass.new) if !instance_variable_get("@#{configuration_ivar_name}")
+        return instance_variable_get("@#{configuration_ivar_name}")
       end
     end
+
+    target.__send__(configurer_method_name) if run_configuration
   end
 
-  def define_configuration_options(&block)
-    configuration_for(self, &block)
+  def define_configuration_options(as=:configuration, run_configuration = false, &block)
+    configuration_for(self, as, run_configuration, &block)
+  end
+
+  def define_configuration_options!(as=:configuration, &block)
+    define_configuration_options(as, true, &block)
   end
 
   alias_method :define_configuration, :define_configuration_options
   alias_method :has_configuration, :define_configuration_options
+  alias_method :has_configurable_options, :define_configuration_options
+  alias_method :has_configurable_options!, :define_configuration_options!
+
+  def remove_instance_variables(*args)
+    args.map{ |ivar_name|
+      remove_instance_variable(:"@#{ivar_name}") if instance_variable_defined?(:"@#{ivar_name}")
+    }
+    self
+  end
+  alias_method :reset_instance_variables, :remove_instance_variables
 
   #following method stolen from abrandoned https://rubygems.org/gems/try_chain
   def try_chain(*symbols)

data/lib/trax/core/ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  def translate(*args)
+    I18n.translate(self.underscore, *args)
+  end
+
+  def translate_words
+    self.split(" ").map(&:translate).join(" ")
+  end
+end

data/lib/trax/core/fs.rb

@@ -0,0 +1,238 @@
+# clearly this should be its own gem
+# or at least parts of it
+# But this is an advanced set of file tools built around ruby stdlib file/dir clases
+# that lets you do stuff like collect all the files in the current directory
+# and its a WIP I ripped out of my project hastily so u done been warned
+
+# Examples:
+#
+# Get all files in the current dir
+# ::Trax::Core::FS::CurrentDirectory.new.files
+#
+# Get all ruby files in current dir
+# ::Trax::Core::FS::CurrentDirectory.new.files.by_extension(".rb")
+#
+# Get all ruby files in target directory
+# ::Trax::Core::FS::Directory.new('/users/jayre/whatever').files.by_extension(".rb")
+#
+# RECURSIVELY get files + children files + childrens children (yarr)
+# ::Trax::Core::FS::Directory.new('/users/jayre/whatever').files(true)
+#
+
+module Trax
+  module Core
+    module FS
+      module Scopes
+        def by_extension(*extensions)
+          matches = select{ |file|
+            extensions.include?(file.extension)
+          }
+        end
+      end
+
+      class Files < SimpleDelegator
+        include ::Enumerable
+        include ::Trax::Core::FS::Scopes
+
+        attr_accessor :files
+
+        def initialize(*args)
+          @files = (args || []).flatten.compact.uniq
+        end
+
+        def __getobj__
+          @files
+        end
+
+        def each(&block)
+          @files.each do |file|
+            block.call(file)
+          end
+        end
+      end
+
+      class Directory < SimpleDelegator
+        attr_accessor :files, :directories, :path
+
+        def self.[](path)
+          file_path = path.is_a?(Pathname) ? path : ::Pathname.new(path)
+          new(file_path)
+        end
+
+        def [](arg)
+          self.class.new(@path.join(arg).to_s)
+        end
+
+        def initialize(file_path)
+          @path = ::Pathname.new(file_path)
+          @dir = ::Dir[@path]
+        end
+
+        def all
+          @all ||= ::Dir[path.join("*")].map do |folder_or_file|
+            listing = ::Pathname.new(folder_or_file)
+            listing.directory? ? self.class.new(listing) : ::Trax::Core::FS::Listing.new(listing)
+          end
+        end
+
+        def directories(*args)
+          folders(*args)
+        end
+
+        def each
+          yield(entries)
+        end
+
+        def entries
+          @entries ||= ::Dir.entries(path).map do |file_path|
+            directory_file_path = ::Pathname.new(file_path) unless file_path.is_a?(Pathname)
+            directory_file_path.directory? ? ::Trax::Core::FS::Directory.new(directory_file_path) : ::Listing.new(directory_file_path)
+          end
+        end
+
+        def files(recurse = false)
+          @files ||= begin
+            if recurse
+              current_directory_files = Files.new(all.select{|file_path| file_path.is_a?(::Trax::Core::FS::Listing) })
+
+              directories.map do |dir|
+                next unless dir.files(true) && dir.files(true).any?
+                current_directory_files.files += dir.files(true)
+              end if directories.any?
+
+              current_directory_files || ::Trax::Core::FS::Files.new
+            else
+              Files.new(all.select{|file_path| file_path.is_a?(::Trax::Core::FS::Listing) })
+            end
+          end
+        end
+
+        def folders(recurse = false)
+          @folders ||= begin
+            if recurse
+              current_directory_directories = all.select{|file_path| file_path.is_a?(::Trax::Core::FS::Directory) }
+
+              current_directory_directories += folders(true).map do |dir|
+                dir.directories(true).any? ? dir.directories(true) : []
+              end if directories(true) && directories(true).any?
+
+              current_directory_directories
+            else
+              all.select{ |file_path| file_path.is_a?(::Trax::Core::FS::Directory) }
+            end
+          end
+        end
+
+        def glob(*args)
+          args.map do |arg|
+            self.dup[arg].flatten.compact.uniq.map{|_path| ::Trax::Core::FS::Listing.new(_path) }
+          end.flatten.compact.uniq
+        end
+
+        def __getobj__
+          @dir
+        end
+
+        def recursive_files
+          files(true)
+        end
+
+        def recursive_folders
+          folders(true)
+        end
+
+        def reload
+          remove_instance_variable(:@folders) if defined?(:@folders)
+          remove_instance_variable(:@files) if defined?(:@files)
+          self
+        end
+
+        def images
+          files.select{|file| file.image? }
+        end
+      end
+
+      class CurrentFileDirectory < SimpleDelegator
+        include ::Enumerable
+
+        def self.[](path)
+          file_path = path.is_a?(::Pathname) ? path : ::Pathname.new(path)
+          new(file_path)
+        end
+
+        attr_accessor :directory, :path
+
+        def initialize
+          source_file_path = caller[3].partition(":")[0]
+          @path = ::Pathname.new(::File.dirname(source_file_path))
+          @directory = ::Trax::Core::FS::Directory.new(@path)
+        end
+
+        def __getobj__
+          @directory
+        end
+
+        def each
+          yield @directory
+        end
+      end
+
+      class CurrentDirectory < CurrentFileDirectory
+
+      end
+
+      class CurrentWorkingDirectory < SimpleDelegator
+        include ::Enumerable
+
+        attr_accessor :directory, :path
+
+        def initialize
+          @path = ::Pathname.new(::Dir.pwd)
+          @directory = ::Trax::Core::FS::Directory.new(@path)
+        end
+
+        def __getobj__
+          @directory
+        end
+
+        def each
+          yield @directory
+        end
+      end
+
+      class Listing < Pathname
+        def bitmap?
+          return sample[0,2] == "MB"
+        end
+
+        def copy_to(destination)
+          ::FileUtils.cp(self, destination)
+        end
+
+        alias_method :extension, :extname
+        alias_method :ext, :extname
+
+        def gif?
+          return sample[0,4] == "GIF8"
+        end
+
+        def image?
+          bitmap? || gif? || jpeg?
+        end
+
+        def jpeg?
+          return sample[0,4] == "\xff\xd8\xff\xe0"
+        end
+
+        def sample
+          @sample ||= begin
+            f = ::File.open(self.to_s, 'rb')
+            result = f.read(9)
+            f.close
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/has_mixins.rb

@@ -0,0 +1,49 @@
+module Trax
+  module Core
+    module HasMixins
+      module ClassMethods
+        def register_mixin(mixin_klass, key = nil)
+          mixin_key = mixin_klass.respond_to?(:mixin_registry_key) ? mixin_klass.mixin_registry_key : (key || mixin_klass.name.demodulize.underscore.to_sym)
+
+          return if mixin_registry.key?(mixin_key)
+          mixin_registry[mixin_key] = mixin_klass
+        end
+      end
+
+      def self.extended(base)
+        base.module_attribute(:mixin_registry) { Hash.new }
+        base.extend(ClassMethods)
+
+        base.define_configuration_options! do
+          option :auto_include, :default => false
+          option :auto_include_mixins, :default => []
+        end
+
+        mixin_module = base.const_set("Mixin", ::Module.new)
+        mixin_module.module_attribute(:mixin_namespace) { base }
+        mixin_module.extend(::Trax::Core::Mixin)
+
+        mixin_module.module_eval do
+          def self.extended(base)
+            base.extend(Trax::Core::Mixin)
+            super(base)
+            mixin_namespace.register_mixin(base)
+          end
+        end
+
+        mixable_module = base.const_set("Mixable", ::Module.new)
+        mixable_module.module_attribute(:mixin_namespace) { base }
+        mixable_module.extend(::ActiveSupport::Concern)
+
+        mixable_module.included do
+          class_attribute :mixin_namespace
+          self.mixin_namespace = base
+        end
+
+        mixable_module.include(::Trax::Core::Mixable)
+
+        super(base)
+      end
+    end
+  end
+end

data/lib/trax/core/inheritance.rb

@@ -0,0 +1,22 @@
+module Trax
+  module Core
+    module Inheritance
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def inherited(subklass)
+          klass = super(subklass)
+          klass.class_attribute(:_after_inherited_block)
+
+          trace = ::TracePoint.new(:end) do |tracepoint|
+            if tracepoint.self == subklass
+              trace.disable
+            end
+          end
+
+          trace.enable
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/isolated_mixin.rb

@@ -0,0 +1,77 @@
+module Trax
+  module Core
+    module IsolatedMixin
+      def included(base = nil, &block)
+        unless base.respond_to?(:_concerns)
+          base.class_attribute :_concerns_config
+          base._concerns_confg = {}
+        end
+
+        base.extend(ClassMethods)
+
+        super(base, &block)
+
+        trace = ::TracePoint.new(:end) do |tracepoint|
+          if tracepoint.self == base
+            trace.disable
+
+            if self.instance_variable_defined?(:@_after_included_block)
+              base.instance_eval(&self.instance_variable_get(:@_after_included_block))
+            end
+
+            if self.instance_variable_defined?(:@_on_concern_included_block)
+              base.instance_exec(base._concerns_config[self.name.demodulize.underscore.to_sym], &self.instance_variable_get(:@_on_concern_included_block))
+            end
+          end
+        end
+
+        trace.enable
+      end
+
+      def self.extended(base)
+        base.extend(::ActiveSupport::Concern)
+        base.extend(::Trax::Core::IsolatedMixin::ClassMethods)
+
+        super(base)
+
+        trace = ::TracePoint.new(:end) do |tracepoint|
+          if tracepoint.self == base
+            trace.disable
+
+            if base.instance_variable_defined?(:@_after_extended_block)
+              base.instance_variable_get(:@_after_extended_block).call
+            end
+          end
+        end
+
+        trace.enable
+      end
+
+      module ClassMethods
+        def configure_concern(name, options = {})
+          _concerns_config[name] = options
+        end
+      end
+
+      def after_extended(&block)
+        self.instance_variable_set(:@_after_extended_block, block)
+      end
+
+      def after_included(&block)
+        self.instance_variable_set(:@_after_included_block, block)
+      end
+
+      def mixed_in(&block)
+        after_included(&block)
+      end
+
+      def mixed(&block)
+        after_included(&block)
+      end
+
+      def on_concern_included(&block)
+        self.instance_variable_set(:@_on_concern_included_block, block)
+      end
+    end
+  end
+end

data/lib/trax/core/mixable.rb

@@ -0,0 +1,57 @@
+module Trax
+  module Core
+    module Mixable
+      extend ::ActiveSupport::Concern
+
+      included do
+        class_attribute :registered_mixins
+
+        self.registered_mixins = {}
+      end
+
+      module ClassMethods
+        def mixin(key, options = {})
+          raise ::Trax::Core::Errors::MixinNotRegistered.new(
+            source: self.name,
+            mixin: key,
+            mixin_namespace: mixin_namespace
+          )  unless mixin_namespace.mixin_registry.key?(key)
+
+          mixin_module = mixin_namespace.mixin_registry[key]
+          self.registered_mixins[key] = mixin_module
+
+          self.class_eval do
+            include(mixin_module) unless self.ancestors.include?(mixin_module)
+
+            options = {} if options.is_a?(TrueClass)
+            options = { options => true } if options.is_a?(Symbol)
+
+            if mixin_module.instance_variable_defined?(:@_before_mixed_in_block)
+              _before_mixed_in_block = mixin_module.instance_variable_get(:@_before_mixed_in_block)
+
+              instance_exec(&_before_mixed_in_block)
+            end
+
+            if mixin_module.instance_variable_defined?(:@_on_mixed_in_block)
+              _on_mixed_in_block = mixin_module.instance_variable_get(:@_on_mixed_in_block)
+
+              instance_exec(options, &_on_mixed_in_block)
+            end
+          end
+        end
+
+        def mixins(*args)
+          options = args.extract_options!
+
+          if(!options.blank?)
+            options.each_pair do |key, val|
+              self.mixin(key, val)
+            end
+          else
+            args.map{ |key| mixin(key) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/mixin.rb

@@ -0,0 +1,42 @@
+module Trax
+  module Core
+    module Mixin
+      def on_mixed_in(&block)
+        self.instance_variable_set(:@_on_mixed_in_block, block)
+      end
+
+      def before_mixed_in(&block)
+        self.instance_variable_set(:@_before_mixed_in_block, block)
+      end
+
+      def self.extended(base)
+        base.extend(::ActiveSupport::Concern)
+
+        super(base)
+
+        trace = ::TracePoint.new(:end) do |tracepoint|
+          if tracepoint.self == base
+            trace.disable
+
+            if base.instance_variable_defined?(:@_after_extended_block)
+              puts "CALLING AFTER EXTENDED"
+              base.instance_variable_get(:@_after_extended_block).call
+            end
+          end
+        end
+
+        trace.enable
+
+        super(base)
+
+        mixin_namespace.register_mixin(base) unless self == ::Trax::Core::Mixin
+      end
+
+      module ClassMethods
+        def on_mixed_in(&block)
+          self.instance_variable_set(:@_on_mixed_in_block, block)
+        end
+      end
+    end
+  end
+end

data/lib/trax/core/mixin_registry.rb

@@ -0,0 +1,10 @@
+module Trax
+  module Core
+    class MixinRegistry
+      def self.extended(base)
+        base.extend(::ActiveSupport::PerThreadRegistry)
+        super(base)
+      end
+    end
+  end
+end

data/lib/trax/core.rb

@@ -1,14 +1,25 @@
 require 'active_support/all'
 require_relative './array'
+require_relative './core/ext/enumerable'
 require_relative './core/ext/module'
 require_relative './core/ext/object'
+require_relative './core/ext/string'
 
 module Trax
   module Core
     extend ::ActiveSupport::Autoload
 
+    autoload :AbstractMethods
     autoload :Configuration
+    autoload :Concern
+    autoload :EagerLoadNamespace
     autoload :EagerAutoloadNamespace
     autoload :Errors
+    autoload :FS
+    autoload :HasMixins
+    autoload :Inheritance
+    autoload :Mixin
+    autoload :Mixable
+    autoload :MixinRegistry
   end
 end

data/lib/trax_core/version.rb

@@ -1,3 +1,3 @@
 module TraxCore
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/support/ecom/widget.rb

@@ -1,5 +1,4 @@
 module Ecom
   class Widget
-
   end
 end

data/spec/support/fake_namespace/priceable.rb

@@ -0,0 +1,27 @@
+module FakeNamespace
+  module Priceable
+    extend ::FakeNamespace::Mixin
+
+    included do
+      class_attribute :default_starting_price
+    end
+
+    on_mixed_in do |options|
+      self.default_starting_price = options[:default_starting_price]
+    end
+
+    def some_instance_method
+      "some_instance_method_return"
+    end
+
+    def starting_price
+      @starting_price || self.class.default_starting_price
+    end
+
+    module ClassMethods
+      def some_class_method
+        "some_class_method_return"
+      end
+    end
+  end
+end

data/spec/support/fake_namespace.rb

@@ -0,0 +1,5 @@
+module FakeNamespace
+  extend ::Trax::Core::HasMixins
+  extend ::Trax::Core::EagerLoadNamespace
+
+end

data/spec/support/storefront/category.rb

@@ -0,0 +1,4 @@
+module Storefront
+  class Category
+  end
+end

data/spec/support/storefront/product.rb

@@ -0,0 +1,7 @@
+module Storefront
+  class Product
+    include ::FakeNamespace::Mixable
+
+    mixins :priceable => { :default_starting_price => 9.99 }
+  end
+end

data/spec/support/storefront.rb

@@ -0,0 +1,4 @@
+module Storefront
+  extend ::Trax::Core::EagerLoadNamespace
+
+end

data/spec/trax/core/ext/module_spec.rb

@@ -3,6 +3,16 @@ require 'spec_helper'
 describe ::Module do
   subject { Trax::Core }
 
+  describe ".module_attribute" do
+    before(:all) do
+      Trax.module_attribute(:some_fake_hash) do
+        {}
+      end
+    end
+
+    it { Trax.some_fake_hash.should be_a(Hash) }
+  end
+
   describe ".recursively_define_namespaced_class" do
     context "when class namespace does not exist at global module level" do
       before do

data/spec/trax/core/ext/object_spec.rb

@@ -23,4 +23,13 @@ describe ::Object do
       SomeFakeClass.new.try_chain(:class, :name, :underscore).should eq "some_fake_class"
     end
   end
+
+  describe ".remove_instance_variables" do
+    it "reset instance variables by symbol names" do
+      obj = SomeFakeClass.new
+      obj.instance_variable_set(:@someivar, "anything")
+      obj.reset_instance_variables(:someivar)
+      obj.instance_variable_get(:@someivar).should be nil
+    end
+  end
 end

data/spec/trax/core/has_mixins_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ::Trax::Core::HasMixins do
+  subject { FakeNamespace }
+
+  it { expect(subject.const_defined?("Mixin")).to eq true }
+  it { expect(subject.mixin_registry).to be_a(Hash) }
+  it { expect(subject::Mixin.mixin_namespace).to eq FakeNamespace }
+
+  context "Priceable Mixin" do
+    it {
+      expect(::Storefront::Product.new.starting_price).to eq 9.99
+    }
+
+    it "includes class methods" do
+      expect(::Storefront::Product.some_class_method).to eq "some_class_method_return"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trax_core
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-21 00:00:00.000000000 Z
+date: 2015-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -265,11 +265,23 @@ files:
 - lib/trax.rb
 - lib/trax/array.rb
 - lib/trax/core.rb
+- lib/trax/core/abstract_methods.rb
+- lib/trax/core/concern.rb
 - lib/trax/core/configuration.rb
 - lib/trax/core/eager_autoload_namespace.rb
+- lib/trax/core/eager_load_namespace.rb
 - lib/trax/core/errors.rb
+- lib/trax/core/ext/enumerable.rb
 - lib/trax/core/ext/module.rb
 - lib/trax/core/ext/object.rb
+- lib/trax/core/ext/string.rb
+- lib/trax/core/fs.rb
+- lib/trax/core/has_mixins.rb
+- lib/trax/core/inheritance.rb
+- lib/trax/core/isolated_mixin.rb
+- lib/trax/core/mixable.rb
+- lib/trax/core/mixin.rb
+- lib/trax/core/mixin_registry.rb
 - lib/trax_core.rb
 - lib/trax_core/version.rb
 - spec/spec_helper.rb
@@ -277,11 +289,17 @@ files:
 - spec/support/ecom/widget.rb
 - spec/support/ecom/widget_category.rb
 - spec/support/errors.rb
+- spec/support/fake_namespace.rb
+- spec/support/fake_namespace/priceable.rb
+- spec/support/storefront.rb
+- spec/support/storefront/category.rb
+- spec/support/storefront/product.rb
 - spec/trax/array_spec.rb
 - spec/trax/core/eager_autoload_namespace_spec.rb
 - spec/trax/core/errors_spec.rb
 - spec/trax/core/ext/module_spec.rb
 - spec/trax/core/ext/object_spec.rb
+- spec/trax/core/has_mixins_spec.rb
 - spec/trax/core_spec.rb
 - trax_core.gemspec
 homepage: http://github.com/jasonayre/trax_core
@@ -304,7 +322,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Core Trax Dependencies
@@ -314,9 +332,15 @@ test_files:
 - spec/support/ecom/widget.rb
 - spec/support/ecom/widget_category.rb
 - spec/support/errors.rb
+- spec/support/fake_namespace.rb
+- spec/support/fake_namespace/priceable.rb
+- spec/support/storefront.rb
+- spec/support/storefront/category.rb
+- spec/support/storefront/product.rb
 - spec/trax/array_spec.rb
 - spec/trax/core/eager_autoload_namespace_spec.rb
 - spec/trax/core/errors_spec.rb
 - spec/trax/core/ext/module_spec.rb
 - spec/trax/core/ext/object_spec.rb
+- spec/trax/core/has_mixins_spec.rb
 - spec/trax/core_spec.rb