trax_model 0.0.98 → 0.0.99

data/lib/trax/model/mti/namespace.rb

@@ -1,21 +0,0 @@
-module Trax
-  module Model
-    module MTI
-      module Namespace
-        extend ::Trax::Core::EagerAutoloadNamespace
-
-        class << self
-          attr_reader :base_mti_model
-        end
-
-        def self.base_model(model)
-          @base_mti_model = model
-        end
-
-        def self.all
-          @all ||= base_mti_model.subclasses
-        end
-      end
-    end
-  end
-end

data/lib/trax/model/restorable.rb

@@ -1,61 +0,0 @@
-module Trax
-  module Model
-    module Restorable
-      extend ::Trax::Model::Mixin
-
-      define_configuration_options! do
-        option :field, :default => :is_deleted
-        option :timestamp_field, :default => :deleted_at
-        option :hide_deleted, :default => true
-        option :alias_destroy, :default => true
-      end
-
-      included do
-        define_configuration_options!(:restorable) do
-          option :field, :default => ::Trax::Model::Restorable.config.field
-          option :timestamp_field, :default => ::Trax::Model::Restorable.config.timestamp_field
-          option :hide_deleted, :default => ::Trax::Model::Restorable.config.hide_deleted
-          option :alias_destroy, :default => ::Trax::Model::Restorable.config.alias_destroy
-        end
-      end
-
-      module ClassMethods
-        def setup_restorable!
-          self.class_eval do
-            if(self.restorable_config.hide_deleted)
-              default_scope { by_not_deleted }
-            end
-
-            if(self.restorable_config.alias_destroy)
-              alias_method :destroy!, :destroy
-            end
-
-            ### Clear default deleted scope ###
-            scope :by_is_deleted, lambda { |*|
-              unscope(:where => self.restorable_config.field).where(self.restorable_config.field => true)
-            }
-            scope :by_not_deleted, lambda { |*|
-              where(self.restorable_config.field => false)
-            }
-
-            default_value_for(self.restorable_config.field) { false }
-          end
-        end
-      end
-
-      def destroy
-        self.update_attributes(self.class.restorable_config.field => true, self.class.restorable_config.timestamp_field => ::DateTime.now)
-      end
-
-      def restore
-        self.update_attributes(self.class.restorable_config.field => false, self.class.restorable_config.timestamp_field => ::DateTime.now)
-      end
-
-      def self.apply_mixin(target, options)
-        target.restorable_config.merge!(options)
-
-        target.setup_restorable!
-      end
-    end
-  end
-end

data/lib/trax/model/scopes.rb

@@ -1,16 +0,0 @@
-module Trax
-  module Model
-    module Scopes
-      extend ::ActiveSupport::Concern
-
-      module ClassMethods
-        def field_scope(attr_name)
-          scope attr_name, lambda{ |*_scope_values|
-            _scope_values.flat_compact_uniq!
-            where(attr_name => _scope_values)
-          }
-        end
-      end
-    end
-  end
-end

data/lib/trax/model/sti/attributes.rb

@@ -1,94 +0,0 @@
-module Trax
-  module Model
-    module STI
-      module Attributes
-        extend ::ActiveSupport::Concern
-
-        #not configurable atm as you can see below
-
-        included do
-          class_attribute :_attribute_set_column,
-                          :_attribute_set_class_name,
-                          :_attribute_set_relation_name,
-                          :_sti_attributes
-
-          self._sti_attributes = []
-
-          self._attribute_set_relation_name = :attribute_set
-          self._attribute_set_column = :attribute_set_id
-          self._attribute_set_class_name = "#{name}AttributeSet"
-
-          self.belongs_to(self._attribute_set_relation_name, :class_name => self._attribute_set_class_name, :validate => true)
-          self.validates(self._attribute_set_relation_name, :presence => true)
-
-          self.before_create(:attribute_set)
-        end
-
-        def attributes
-          super.merge!(sti_attributes)
-        end
-
-        def attribute_set
-          build_attribute_set if super.nil?
-
-          super
-        end
-
-        def sti_attributes
-          sti_attribute_hash = self.class._sti_attributes.inject({}) do |result, attribute|
-            result["#{attribute}"] = __send__(attribute)
-            result
-          end
-
-          sti_attribute_hash
-        end
-
-        def super!(*args)
-          method_caller = caller_locations(1,1)[0].label
-          attribute_set.send(method_caller, *args)
-        end
-
-        module ClassMethods
-          def sti_attribute(*args)
-            options = args.extract_options!
-
-            args.each do |attribute_name|
-              return unless self._attribute_set_class_name.constantize.table_exists?
-              raise ::Trax::Model::Errors::STIAttributeNotFound unless self._attribute_set_class_name.constantize.column_names.include?("#{attribute_name}")
-
-              self._sti_attributes << attribute_name
-
-              self.delegate(attribute_name, :to => :attribute_set)
-              self.delegate("#{attribute_name}=", :to => :attribute_set) unless options.key?(:writer) && options[:writer] == false
-            end
-          end
-
-          def validates_uniqueness_of!(*args)
-            options = args.extract_options!
-
-            args.each do |arg|
-              validation_method_name = :"validate_#{arg.to_s}"
-
-              self.send(:define_method, :"validate_#{arg.to_s}") do |*_args|
-                where_scope_hash = {}
-                field_value = self.__send__(arg)
-                where_scope_hash[arg] = field_value
-
-                where_scope = self._attribute_set_class_name.constantize.where(where_scope_hash).all
-
-                options[:scope].each do |field|
-                  scoped_field_value = self.__send__(field)
-                  where_scope.merge(self.class.where({field => scoped_field_value}))
-                end if options.has_key?(:scope)
-
-                errors.add(arg, "has already been taken") if where_scope.limit(1).any?
-              end
-
-              self.validate(validation_method_name)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/trax/model/string_extensions.rb

@@ -1,11 +0,0 @@
-module Trax
-  module Model
-    module StringExtensions
-      extend ::ActiveSupport::Concern
-
-      def uuid
-        ::Trax::Model::UUID === self ? ::Trax::Model::UUID.new(self) : nil
-      end
-    end
-  end
-end

data/lib/trax/model/struct_extensions.rb

@@ -1,185 +0,0 @@
-module Trax
-  module Model
-    module StructExtensions
-      extend ::ActiveSupport::Concern
-      include ::ActiveModel::Validations
-
-      included do
-        attr_reader :record
-      end
-
-      def inspect
-        self.to_hash.inspect
-      end
-
-      def to_json
-        self.to_hash.to_json
-      end
-
-      def value
-        self
-      end
-
-      module ClassMethods
-        #bit of a hack for the sake of strong params for now
-        def permitted_keys
-          @permitted_keys ||= properties.map(&:to_sym)
-        end
-
-        def define_model_scopes_for(*attribute_names)
-          attribute_names.each do |attribute_name|
-            define_model_scope_for(attribute_name)
-          end
-        end
-
-        def define_model_scope_for(attribute_name, **options)
-          attribute_klass = fields[attribute_name]
-
-          case fields[attribute_name].type
-          when :boolean
-            define_where_scopes_for_boolean_property(attribute_name, attribute_klass, **options)
-          when :enum
-            define_scopes_for_enum(attribute_name, attribute_klass, **options)
-          when :array
-            define_scopes_for_array(attribute_name, attribute_klass, **options)
-          when :integer
-            define_scopes_for_numeric(attribute_name, attribute_klass, **options)
-          when :time
-            define_scopes_for_time(attribute_name, attribute_klass, **options)
-          else
-            define_where_scopes_for_property(attribute_name, attribute_klass, **options)
-          end
-        end
-
-        def define_scopes_for_array(attribute_name, property_klass, as:nil)
-          return unless has_active_record_ancestry?(property_klass)
-
-          model_class = model_class_for_property(property_klass)
-          field_name = property_klass.parent_definition.name.demodulize.underscore
-          attribute_name = property_klass.name.demodulize.underscore
-          scope_name = as || :"by_#{field_name}_#{attribute_name}"
-          
-          model_class.scope(scope_name, lambda{ |*_scope_values|
-            _scope_values.flat_compact_uniq!
-            model_class.where("#{field_name} -> '#{attribute_name}' ?| array[:values]", :values => _scope_values)
-          })
-        end
-
-        def define_scopes_for_numeric(attribute_name, property_klass, as:nil)
-          return unless has_active_record_ancestry?(property_klass)
-
-          model_class = model_class_for_property(property_klass)
-          field_name = property_klass.parent_definition.name.demodulize.underscore
-          attribute_name = property_klass.name.demodulize.underscore
-          cast_type = property_klass.type
-
-          { :gt => '>', :gte => '>=', :lt => '<', :lte => '<=', :eq => '='}.each_pair do |k, operator|
-            scope_name = as ? :"#{as}_#{k}" : :"by_#{field_name}_#{attribute_name}_#{k}"
-
-            model_class.scope(scope_name, lambda{ |*_scope_values|
-              _scope_values.flat_compact_uniq!
-              model_class.where("(#{field_name} ->> '#{attribute_name}')::#{cast_type} #{operator} ?", _scope_values)
-            })
-          end
-        end
-
-        def define_scopes_for_time(attribute_name, property_klass, as:nil)
-          return unless has_active_record_ancestry?(property_klass)
-
-          model_class = model_class_for_property(property_klass)
-          field_name = property_klass.parent_definition.name.demodulize.underscore
-          attribute_name = property_klass.name.demodulize.underscore
-          cast_type = 'timestamp'
-
-          { :gt => '>', :lt => '<'}.each_pair do |k, operator|
-            scope_prefix = as ? as : :"by_#{field_name}_#{attribute_name}"
-            scope_name = "#{scope_prefix}_#{k}"
-            scope_alias = "#{scope_prefix}_#{{:gt => 'after', :lt => 'before' }[k]}"
-
-            model_class.scope(scope_name, lambda{ |*_scope_values|
-              _scope_values.flat_compact_uniq!
-              model_class.where("(#{field_name} ->> '#{attribute_name}')::#{cast_type} #{operator} ?", _scope_values)
-            })
-            model_class.singleton_class.__send__("alias_method", scope_alias.to_sym, scope_name)
-          end
-        end
-
-        #this only supports properties 1 level deep, but works beautifully
-        #I.E. for this structure
-        # define_attributes do
-        #   struct :custom_fields do
-        #     enum :color, :default => :blue do
-        #       define :blue,     1
-        #       define :red,      2
-        #       define :green,    3
-        #     end
-        #   end
-        # end
-        # ::Product.by_custom_fields_color(:blue, :red)
-        # will return #{Product color=blue}, #{Product color=red}
-        def define_scopes_for_enum(attribute_name, enum_klass, as:nil)
-          return unless has_active_record_ancestry?(enum_klass)
-
-          model_class = model_class_for_property(enum_klass)
-          field_name = enum_klass.parent_definition.name.demodulize.underscore
-          attribute_name = enum_klass.name.demodulize.underscore
-          scope_name = as || :"by_#{field_name}_#{attribute_name}"
-          model_class.scope(scope_name, lambda{ |*_scope_values|
-            _integer_values = enum_klass.select_values(*_scope_values.flat_compact_uniq!)
-            _integer_values.map!(&:to_s)
-            model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _integer_values)
-          })
-        end
-
-        def define_where_scopes_for_boolean_property(attribute_name, property_klass, as:nil)
-          return unless has_active_record_ancestry?(property_klass)
-
-          model_class = model_class_for_property(property_klass)
-          field_name = property_klass.parent_definition.name.demodulize.underscore
-          attribute_name = property_klass.name.demodulize.underscore
-          scope_name = as || :"by_#{field_name}_#{attribute_name}"
-          model_class.scope(scope_name, lambda{ |*_scope_values|
-            _scope_values.map!(&:to_s).flat_compact_uniq!
-            model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _scope_values)
-          })
-        end
-
-        def define_where_scopes_for_property(attribute_name, property_klass, as:nil)
-          return unless has_active_record_ancestry?(property_klass)
-
-          model_class = model_class_for_property(property_klass)
-          field_name = property_klass.parent_definition.name.demodulize.underscore
-          attribute_name = property_klass.name.demodulize.underscore
-          scope_name = as || :"by_#{field_name}_#{attribute_name}"
-
-          model_class.scope(scope_name, lambda{ |*_scope_values|
-            _scope_values.map!(&:to_s).flat_compact_uniq!
-            model_class.where("#{field_name} ->> '#{attribute_name}' IN(?)", _scope_values)
-          })
-        end
-
-        def has_active_record_ancestry?(property_klass)
-          return false unless property_klass.respond_to?(:parent_definition)
-
-          result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
-            true
-          else
-            has_active_record_ancestry?(property_klass.parent_definition)
-          end
-
-          result
-        end
-
-        def model_class_for_property(property_klass)
-          result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
-            property_klass.parent_definition
-          else
-            model_class_for_property(property_klass.parent_definition)
-          end
-
-          result
-        end
-      end
-    end
-  end
-end

data/lib/trax/model/unique_id.rb

@@ -1,83 +0,0 @@
-module Trax
-  module Model
-    module UniqueId
-      extend ::Trax::Model::Mixin
-
-      define_configuration_options! do
-        option :uuid_column, :default => :id
-        option :uuid_map, :default => {}
-      end
-
-      after_included do |options|
-        define_configuration_options!(:unique_id) do
-          option :uuid_prefix,
-                 :validates => {
-                   :exclusion => {
-                     :in => ::Trax::Model::Registry.uuid_map.values
-                   },
-                   :inclusion => {
-                     :in => ::Trax::Model::UUIDPrefix.all,
-                     :message => "%{value} not a valid uuid prefix!\nRun Trax::Model::UUIDPrefix.all for valid prefix list"
-                   },
-                   :allow_nil => true
-                 }
-
-          option :uuid_column, :default => ::Trax::Model::UniqueId.config.uuid_column
-
-          klass do
-            def uuid_prefix=(prefix)
-              if(::Trax::Model::UniqueId.config.uuid_map.values.include?(prefix) && ::Trax::Model::UniqueId.config.uuid_map[self.source.name] != prefix)
-                raise ::Trax::Model::Errors::DuplicatePrefixRegistered.new(:prefix => prefix, :model => self.source.name)
-              end
-
-              ::Trax::Model::UniqueId.config.uuid_map[self.source.name] = prefix
-              super(::Trax::Model::UUIDPrefix.new(prefix))
-            end
-          end
-
-        end
-
-        #grab prefix from uuid registry if uuids are defined in an initializer
-        if ::Trax::Model.mixin_registry.key?(:unique_id) && ::Trax::Model::UUID.klass_prefix_map.key?(self.name)
-          self.unique_id_config.uuid_prefix = ::Trax::Model::UUID.klass_prefix_map[self.name]
-        end
-
-        self.unique_id_config.merge!(options)
-
-        if(self.unique_id_config.uuid_prefix)
-          default_value_for(:"#{self.unique_id_config.uuid_column}") {
-            ::Trax::Model::UUID.generate(self.unique_id_config.uuid_prefix)
-          }
-        end
-      end
-
-      def uuid
-        uuid_column = self.class.unique_id_config.uuid_column
-        uuid_value = (uuid_column == "uuid") ? super : __send__(uuid_column)
-
-        ::Trax::Model::UUID.new(uuid_value)
-      end
-
-      #i.e. Blog::Post
-      def uuid_type
-        uuid.record_type
-      end
-
-      #i.e. 'Blog::Post'
-      def uuid_type_name
-        uuid.record_type.name
-      end
-
-      #i.e, Blog::Post will = post
-      def uuid_type_slug
-        uuid.record_type.name.demodulize.underscore
-      end
-
-      module ClassMethods
-        def uuid_prefix
-          self.unique_id_config.uuid_prefix
-        end
-      end
-    end
-  end
-end