attribute_extras 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eac09be8233da669f266305340d2f7c796cd8ab9
-  data.tar.gz: 26f61ba42a8ecde62c87e393e9ebbe97c59fcf9e
+  metadata.gz: dbe2cf428824264839a52d09fe981d4212785d06
+  data.tar.gz: f34788ebc3efdef5db35eea0c7951e3698732d8a
 SHA512:
-  metadata.gz: 0a2e98ec1f27972c2edaf5966582c94c423e06a2194dcf719a26938eb0e85ca5272b69ae19d96e1065f8059f7295d9de10cecdfe84198fe28ce1d98d9efeb438
-  data.tar.gz: d49ae18115091d70f0f8fe6cb129e2b7cd45a9224673e06d9e9465bd02f8fb8413c59082230aab809014785948bcf7b9bff1bd21dea019a70e9feabdade20d21
+  metadata.gz: 81b22a9c17b95bbcde17c18ef0e38a329630e38cad3a054459e9b24cda64fe4ebcb11f13b75126fc40b572f2f32c2700375dc63ab819ebfba2b639f92f5eefdf
+  data.tar.gz: 023a5250dccab5535a615529e8dfdb3bff2940286ece963ce721272e6898c08adb6f3e445885d4c50d0b32cfe8c6fa4e7ec1ba6af7a19c532b93ef0bc553423d

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2015 Kevin Deisz
+Copyright 2015 DrugDev, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,6 +1,6 @@
 ## AttributeExtras
 
-Use this gem for automatic behavior on attributes. It provides three class macros that can be used for managing attributes.
+Use this gem for automatic behavior on attributes. It by default provides three class macros that can be used for managing attributes. You can also build your own macros that will automatically become available to you within your ActiveRecord models. By default each macro gets the options `:validator` and `:writer` and both are set to true. If you do not want the macros to validate or overwrite the attribute writers, you can pass false to those options.
 
 ### nullify_attributes
 
@@ -30,17 +30,15 @@ p.name # => 'value'
 
 ### truncate_attributes
 
-Causes string attribute assignment to be truncated down to the maximum allowed value for that column. If `whiny` is set to true, instead adds a length validator on that attribute to cause it to error if saved.
+Causes string attribute assignment to be truncated down to the maximum allowed value for that column.
 
 ```ruby
 class Person < ActiveRecord::Base
-  truncate_attributes :first_name
-  truncate_attributes :last_name, whiny: true
+  truncate_attributes :name
 end
 
-p = Person.new(first_name: 'a' * 500, last_name: 'a' * 500)
-p.first_name # => 'a' * limit
-p.save! # => ActiveRecord::RecordInvalid: Validation failed
+p = Person.new(name: 'a' * 500)
+p.name # => 'a' * limit
 ```
 
 ### Inheritance
@@ -69,6 +67,29 @@ Developer.nullified_attributes.map(&:attribute) # => [:email]
 Developer.inherited_nullified_attributes.map(&:attribute) # => [:email, :name]
 ```
 
+## Internals
+
+If you want to register your own macros, you can do so with `AttributeExtras.register_extra`. Internally `attribute_extras` does this for the three macros listed above.
+
+### `:nullify` Example
+
+```ruby
+self.register_extra :nullify, ->(value, options){ value.presence },
+  past: :nullified,
+  validator: { format: { allow_nil: true, without: /\A\s*\z/ } }
+```
+
+### `:truncate` Example
+
+```ruby
+self.register_extra :truncate, ->(value, options){ value.is_a?(String) ? value[0...options[:limit]] : value },
+  past: :truncated,
+  validator: ->(options){ { length: { maximum: options[:limit] } } },
+  options: ->(attribute){ { limit: self.columns_hash[attribute.to_s].limit } }
+```
+
+In this case the options is needed to build a hash of metadata about the attribute in question so that the validator option can change. The options hash is also passed in to the `truncate_attribute_extra` method so that you have access to that metadata.
+
 ## Additional information
 
 ### Contributing

data/lib/attribute_extras/base_extensions.rb

@@ -1,44 +1,8 @@
 module AttributeExtras
   module BaseExtensions
 
-    # overrides the writer to set to nil if that value is blank
-    def nullify_attributes(*attributes)
-      if self.table_exists? and (non_attributes = attributes.map(&:to_s) - self.column_names).any?
-        raise ArgumentError, "Invalid attributes passed to nullify_attributes: #{non_attributes.join(', ')}"
-      end
-
-      include ::AttributeExtras::NullifyAttributes
-
-      attributes.each do |attribute|
-        define_method("#{attribute}=") do |value|
-          write_attribute(attribute, value.presence)
-        end
-        nullified_attributes << Modifier.new(attribute)
-      end
-    end
-
-    # overrides the writer to strip the value
-    def strip_attributes(*attributes)
-      string_columns = self.columns.select { |column| column.type == :string }.map(&:name)
-      if self.table_exists? and (non_attributes = attributes.map(&:to_s) - string_columns).any?
-        raise ArgumentError, <<-MSG.squish
-          Invalid attributes passed to strip_attributes: #{non_attributes.join(', ')};
-          attributes must be string columns
-        MSG
-      end
-
-      include ::AttributeExtras::StripAttributes
-
-      attributes.each do |attribute|
-        define_method("#{attribute}=") do |value|
-          write_attribute(attribute, value.is_a?(String) ? value.strip : value)
-        end
-        stripped_attributes << Modifier.new(attribute)
-      end
-    end
-
     # overrides the writer to truncate if that value is blank
-    def truncate_attributes(*attributes, whiny: false)
+    def truncate_attributes(*attributes, validator: false, writer: true)
       string_columns = self.columns.select { |column| column.type == :string && !column.limit.nil? }.map(&:name)
       if self.table_exists? and (non_attributes = attributes.map(&:to_s) - string_columns).any?
         raise ArgumentError, <<-MSG.squish
@@ -53,15 +17,17 @@ module AttributeExtras
       attributes.each do |attribute|
         limit = self.columns_hash[attribute.to_s].limit
 
-        if whiny
+        if validator
           validates attribute, length: { maximum: limit }
-          @truncated_attributes << Modifier.new(attribute, limit: limit)
-        else
+        end
+
+        if writer
           define_method("#{attribute}=") do |value|
-            write_attribute(attribute, value.is_a?(String) ? value[0...limit] : value)
+            write_attribute(attribute, ::AttributeExtras::TruncateAttributes::FUNCTION[value, limit: limit])
           end
-          @truncated_attributes << Modifier.new(attribute)
         end
+
+        truncated_attributes << Modifier.new(attribute, limit: limit)
       end
     end
 

data/lib/attribute_extras/extra_builder.rb

@@ -0,0 +1,78 @@
+module AttributeExtras
+  class ExtraBuilder
+
+    # store the given options
+    def initialize(verb, past, function, validator, options)
+      @verb = verb
+      @past = past
+      @function = function
+      @validator = validator
+      @options = options
+    end
+
+    # build the extra
+    def build
+      concern = Module.new
+      concern.module_eval(concern_definition)
+      concern::ClassMethods.module_eval(&utilities_definition)
+      concern
+    end
+
+    private
+
+      # the module definition for the concern
+      def concern_definition
+        <<-RUBY
+          extend ActiveSupport::Concern
+
+          module ClassMethods
+            def inherited_#{@past}_attributes
+              @inherited_#{@past}_attributes ||= begin
+                modifiers = []
+                self.ancestors.each do |ancestor|
+                  break if ancestor == ActiveRecord::Base
+                  if ancestor.respond_to?(:#{@past}_attributes)
+                    modifiers += ancestor.#{@past}_attributes
+                  end
+                end
+                modifiers
+              end
+            end
+
+            def #{@past}_attributes
+              @#{@past}_attributes ||= []
+            end
+          end
+
+          def #{@verb}_attributes
+            set_#{@past}_attributes
+            self.changed? ? self.save : true
+          end
+
+          def #{@verb}_attributes!
+            set_#{@past}_attributes
+            self.changed? ? self.save : true
+          end
+
+          private
+
+            def set_#{@past}_attributes
+              self.class.inherited_#{@past}_attributes.each do |modifier|
+                attribute = modifier.attribute
+                self.send(:\"\#{attribute}=\", self.class.#{@verb}_attribute_extra(self.send(attribute), modifier.options))
+              end
+            end
+        RUBY
+      end
+
+      # the module definition for the utilities
+      def utilities_definition
+        verb, function, validator, options = @verb, @function, @validator, @options
+        proc do
+          define_method(:"#{verb}_attribute_extra", function)
+          define_method(:"#{verb}_validator_for", validator)
+          define_method(:"#{verb}_options_for", options)
+        end
+      end
+  end
+end

data/lib/attribute_extras/hook_builder.rb

@@ -0,0 +1,49 @@
+module AttributeExtras
+  class HookBuilder
+
+    # store the given options
+    def initialize(verb, past)
+      @verb = verb
+      @past = past
+    end
+
+    # build the hook
+    def build
+      hook = Module.new
+      hook.module_eval(module_definition)
+      hook
+    end
+
+    private
+
+      # the module definition for the extra
+      def module_definition
+        <<-RUBY
+          def #{@verb}_attributes(*attributes, validator: true, writer: true)
+            if self.table_exists? && (non_attributes = attributes.map(&:to_s) - self.column_names).any?
+              raise ArgumentError, "Invalid attributes passed to #{@verb}_attributes: \#{non_attributes.join(', ')}"
+            end
+
+            include ::AttributeExtras::#{@verb.capitalize}Attributes
+
+            attributes.each do |attribute|
+              options = self.#{@verb}_options_for(attribute)
+              modifier = Modifier.new(attribute, options)
+
+              if validator
+                validates attribute, self.#{@verb}_validator_for(modifier.options)
+              end
+
+              if writer
+                define_method("\#{attribute}=") do |value|
+                  write_attribute(attribute, self.class.#{@verb}_attribute_extra(value, modifier.options))
+                end
+              end
+
+              #{@past}_attributes << modifier
+            end
+          end
+        RUBY
+      end
+  end
+end

data/lib/attribute_extras/version.rb

@@ -1,3 +1,3 @@
 module AttributeExtras
-  VERSION = "0.0.1"
+  VERSION = '0.1.0'
 end

data/lib/attribute_extras.rb

@@ -1,8 +1,39 @@
 require 'attribute_extras/base_extensions'
+require 'attribute_extras/extra_builder'
+require 'attribute_extras/hook_builder'
+require 'attribute_extras/modifier'
 
 module AttributeExtras
-  autoload :Modifier, 'attribute_extras/modifier'
-  autoload :NullifyAttributes, 'attribute_extras/nullify_attributes'
-  autoload :StripAttributes, 'attribute_extras/strip_attributes'
-  autoload :TruncateAttributes, 'attribute_extras/truncate_attributes'
+
+  # the registered extras
+  mattr_accessor :extras
+  self.extras = []
+
+  # register the extra and build the functions
+  def self.register_extra(verb, function, past:, validator:, options: nil)
+    past ||= verb
+    compiled_validator = validator.is_a?(Proc) ? validator : ->(options){ validator }
+    options ||= ->(attribute){ {} }
+
+    extra = ExtraBuilder.new(verb, past, function, compiled_validator, options).build
+    hook = HookBuilder.new(verb, past).build
+
+    self.const_set(:"#{verb.capitalize}Attributes", extra)
+    self.extras << extra
+    ActiveRecord::Base.extend(hook)
+  end
+
+  self.register_extra :nullify, ->(value, options){ value.presence },
+    past: :nullified,
+    validator: { format: { allow_nil: true, without: /\A\s*\z/ } }
+
+  self.register_extra :strip, ->(value, options){ value.is_a?(String) ? value.strip : value },
+    past: :stripped,
+    validator: { format: { without: /\A\s+|\s+\z/ } }
+
+  self.register_extra :truncate, ->(value, options){ value.is_a?(String) ? value[0...options[:limit]] : value },
+    past: :truncated,
+    validator: ->(options){ { length: { maximum: options[:limit] } } },
+    options: ->(attribute){ { limit: self.columns_hash[attribute.to_s].limit } }
+
 end

data/test/base_extensions_test.rb

@@ -12,7 +12,6 @@ class BaseExtensionsTest < ActiveSupport::TestCase
   def test_nullify_attributes_success
     klass = address_class(:nullify_attributes, :first_line, :second_line)
     assert_equal klass.nullified_attributes.map(&:attribute), [:first_line, :second_line]
-    assert_includes klass.instance_method(:first_line=).source_location.first, 'attribute_extras/base_extensions'
   end
 
   def test_strip_attributes_failure
@@ -25,7 +24,6 @@ class BaseExtensionsTest < ActiveSupport::TestCase
   def test_strip_attributes_success
     klass = address_class(:strip_attributes, :first_line, :second_line)
     assert_equal klass.stripped_attributes.map(&:attribute), [:first_line, :second_line]
-    assert_includes klass.instance_method(:first_line=).source_location.first, 'attribute_extras/base_extensions'
   end
 
   def test_truncate_attributes_failure
@@ -38,16 +36,6 @@ class BaseExtensionsTest < ActiveSupport::TestCase
   def test_truncate_attributes_success
     klass = address_class(:truncate_attributes, :first_line, :second_line)
     assert_equal klass.truncated_attributes.map(&:attribute), [:first_line, :second_line]
-    assert_includes klass.instance_method(:first_line=).source_location.first, 'attribute_extras/base_extensions'
-  end
-
-  def test_truncate_attributes_success_whiny
-    klass = address_class(:truncate_attributes, :first_line, :second_line, whiny: true)
-    assert_equal klass.truncated_attributes.map(&:attribute), [:first_line, :second_line]
-
-    validator = klass.validators_on(:first_line).first
-    assert_kind_of ActiveModel::Validations::LengthValidator, validator
-    assert_equal validator.options[:maximum], COLUMN_LIMIT
   end
 
   private

data/test/nullify_attributes_test.rb

@@ -1,24 +1,14 @@
 require 'test_helper'
 
 class NullifyAttributesTest < ActiveSupport::TestCase
-  def test_nullified_name=
-    person = Person.new
-    person.nullified_name = '   '
-    assert_nil person.nullified_name
-
-    person.nullified_name = nil
-    assert_nil person.nullified_name
-
-    person.nullified_name = 'test_value'
-    assert_equal 'test_value', person.nullified_name
-  end
-
   def test_nullify_attributes
     person = Person.new
     person.set_blank_attributes
 
     assert person.nullify_attributes
-    assert_nil person.nullified_name
+    person_attributes.each do |attribute|
+      assert_nil person.send(attribute)
+    end
   end
 
   def test_nullify_attributes!
@@ -26,7 +16,9 @@ class NullifyAttributesTest < ActiveSupport::TestCase
     person.set_blank_attributes
 
     assert person.nullify_attributes!
-    assert_nil person.nullified_name
+    person_attributes.each do |attribute|
+      assert_nil person.send(attribute)
+    end
   end
 
   def test_nullified_attributes_inheritance
@@ -34,24 +26,32 @@ class NullifyAttributesTest < ActiveSupport::TestCase
     architect.set_blank_attributes
 
     assert architect.nullify_attributes
-    assert_nil architect.nullified_name
-    assert_nil architect.other_nullified_name
+    architect_attributes.each do |attribute|
+      assert_nil architect.send(attribute)
+    end
   end
 
   def test_nullified_attributes
-    assert_equal Person.nullified_attributes.map(&:attribute),
-      [:nullified_name]
-    assert_equal Developer.nullified_attributes.map(&:attribute), []
-    assert_equal Architect.nullified_attributes.map(&:attribute),
-      [:other_nullified_name]
+    assert_equal person_attributes, Person.nullified_attributes.map(&:attribute)
+    assert_empty Developer.nullified_attributes.map(&:attribute)
+    assert_equal [:architect_nullified], Architect.nullified_attributes.map(&:attribute)
   end
 
   def test_inherited_nullified_attributes
-    assert_equal Person.inherited_nullified_attributes.map(&:attribute),
-      [:nullified_name]
-    assert_equal Developer.inherited_nullified_attributes.map(&:attribute),
-      [:nullified_name]
-    assert_equal Architect.inherited_nullified_attributes.map(&:attribute),
-      [:other_nullified_name, :nullified_name]
+    assert_equal person_attributes, Person.inherited_nullified_attributes.map(&:attribute)
+    assert_equal person_attributes, Developer.inherited_nullified_attributes.map(&:attribute)
+    assert_equal architect_attributes, Architect.inherited_nullified_attributes.map(&:attribute)
   end
+
+  private
+
+    # a list of the attributes that are nullified on the architect class
+    def architect_attributes
+      @architect_attributes ||= ([:architect_nullified] + person_attributes)
+    end
+
+    # a list of the attributes that are nullified on the person class
+    def person_attributes
+      @person_attributes ||= [:person_nullified_one, :person_nullified_two, :person_nullified_three, :person_nullified_four]
+    end
 end

data/test/strip_attributes_test.rb

@@ -1,24 +1,14 @@
 require 'test_helper'
 
 class StripAttributesTest < ActiveSupport::TestCase
-  def test_stripped_name=
-    person = Person.new
-    person.stripped_name = '  test value  '
-    assert_equal 'test value', person.stripped_name
-
-    person.stripped_name = nil
-    assert_nil person.stripped_name
-
-    person.stripped_name = 'test value'
-    assert_equal 'test value', person.stripped_name
-  end
-
   def test_strip_attributes
     person = Person.new
     person.set_padded_attributes
 
     assert person.strip_attributes
-    assert_equal 'test value', person.stripped_name
+    person_attributes.each do |attribute|
+      assert_equal Person.stripped_value, person.send(attribute)
+    end
   end
 
   def test_strip_attributes!
@@ -26,7 +16,9 @@ class StripAttributesTest < ActiveSupport::TestCase
     person.set_padded_attributes
 
     assert person.strip_attributes!
-    assert_equal 'test value', person.stripped_name
+    person_attributes.each do |attribute|
+      assert_equal Person.stripped_value, person.send(attribute)
+    end
   end
 
   def test_stripped_attributes_inheritance
@@ -34,24 +26,32 @@ class StripAttributesTest < ActiveSupport::TestCase
     architect.set_padded_attributes
 
     assert architect.strip_attributes
-    assert_equal 'test value', architect.stripped_name
-    assert_equal 'test value', architect.other_stripped_name
+    architect_attributes.each do |attribute|
+      assert_equal Architect.stripped_value, architect.send(attribute)
+    end
   end
 
   def test_stripped_attributes
-    assert_equal Person.stripped_attributes.map(&:attribute),
-      [:stripped_name]
-    assert_equal Developer.stripped_attributes.map(&:attribute), []
-    assert_equal Architect.stripped_attributes.map(&:attribute),
-      [:other_stripped_name]
+    assert_equal person_attributes, Person.stripped_attributes.map(&:attribute)
+    assert_empty Developer.stripped_attributes.map(&:attribute)
+    assert_equal [:architect_stripped], Architect.stripped_attributes.map(&:attribute)
   end
 
   def test_inherited_stripped_attributes
-    assert_equal Person.inherited_stripped_attributes.map(&:attribute),
-      [:stripped_name]
-    assert_equal Developer.inherited_stripped_attributes.map(&:attribute),
-      [:stripped_name]
-    assert_equal Architect.inherited_stripped_attributes.map(&:attribute),
-      [:other_stripped_name, :stripped_name]
+    assert_equal person_attributes, Person.inherited_stripped_attributes.map(&:attribute)
+    assert_equal person_attributes, Developer.inherited_stripped_attributes.map(&:attribute)
+    assert_equal architect_attributes, Architect.inherited_stripped_attributes.map(&:attribute)
   end
+
+  private
+
+    # a list of the attributes that are stripped on the architect class
+    def architect_attributes
+      @architect_attributes ||= ([:architect_stripped] + person_attributes)
+    end
+
+    # a list of the attributes that are stripped on the person class
+    def person_attributes
+      @person_attributes ||= [:person_stripped_one, :person_stripped_two, :person_stripped_three, :person_stripped_four]
+    end
 end

data/test/test_classes.rb

@@ -1,16 +1,15 @@
 COLUMN_LIMIT = 255
+NUMBERS = %w[one two three four]
 
 ActiveRecord::Schema.define do
   create_table :people, force: true do |t|
-    t.string :nullified_name
-    t.string :other_nullified_name
-
-    t.string :stripped_name
-    t.string :other_stripped_name
-
-    t.string :truncated_name, limit: COLUMN_LIMIT
-    t.string :truncated_whiny_name, limit: COLUMN_LIMIT
-    t.string :other_truncated_name, limit: COLUMN_LIMIT
+    %w[nullified stripped truncated].each do |prefix|
+      options = (prefix == 'truncated') ? { limit: COLUMN_LIMIT } : {}
+      NUMBERS.each do |number|
+        t.string "person_#{prefix}_#{number}", options
+      end
+      t.string "architect_#{prefix}", options
+    end
   end
 
   create_table :addresses, force: true do |t|
@@ -20,25 +19,32 @@ ActiveRecord::Schema.define do
 end
 
 class Person < ActiveRecord::Base
-  nullify_attributes :nullified_name
-  strip_attributes :stripped_name
-  truncate_attributes :truncated_name
-  truncate_attributes :truncated_whiny_name, whiny: true
+
+  { nullified: :nullify_attributes, stripped: :strip_attributes, truncated: :truncate_attributes }.each do |prefix, macro|
+    NUMBERS.each_with_index do |number, index|
+      send(macro, "person_#{prefix}_#{number}".to_sym, validator: (index / 2).even?, writer: (index % 2))
+    end
+  end
 
   def set_blank_attributes
-    write_attribute(:nullified_name, '   ')
-    save
+    NUMBERS.each do |number|
+      write_attribute("person_nullified_#{number}", '   ')
+    end
+    save(validate: false)
   end
 
   def set_long_attributes
-    write_attribute(:truncated_name, self.class.long_value)
-    write_attribute(:truncated_whiny_name, self.class.long_value)
+    NUMBERS.each do |number|
+      write_attribute("person_truncated_#{number}", self.class.long_value)
+    end
     save(validate: false)
   end
 
   def set_padded_attributes
-    write_attribute(:stripped_name, '  test value  ')
-    save
+    NUMBERS.each do |number|
+      write_attribute("person_stripped_#{number}", '  test value  ')
+    end
+    save(validate: false)
   end
 
   class << self
@@ -46,6 +52,10 @@ class Person < ActiveRecord::Base
       @short_value ||= ('a' * COLUMN_LIMIT)
     end
 
+    def stripped_value
+      @stripped_value ||= 'test value'
+    end
+
     def long_value
       @long_value ||= ('a' * 500)
     end
@@ -55,26 +65,22 @@ end
 class Developer < Person; end
 
 class Architect < Developer
-  nullify_attributes :other_nullified_name
-  strip_attributes :other_stripped_name
-  truncate_attributes :other_truncated_name
+  nullify_attributes :architect_nullified
+  strip_attributes :architect_stripped
+  truncate_attributes :architect_truncated
 
   def set_blank_attributes
-    write_attribute(:nullified_name, '   ')
-    write_attribute(:other_nullified_name, '   ')
-    save
+    write_attribute(:architect_nullified, '   ')
+    super
   end
 
   def set_long_attributes
-    write_attribute(:truncated_name, self.class.long_value)
-    write_attribute(:truncated_whiny_name, self.class.long_value)
-    write_attribute(:other_truncated_name, self.class.long_value)
-    save
+    write_attribute(:architect_truncated, self.class.long_value)
+    super
   end
 
   def set_padded_attributes
-    write_attribute(:stripped_name, '  test value  ')
-    write_attribute(:other_stripped_name, '  test value  ')
-    save
+    write_attribute(:architect_stripped, '  test value  ')
+    super
   end
 end

data/test/truncate_attributes_test.rb

@@ -1,34 +1,14 @@
 require 'test_helper'
 
 class TruncateAttributesTest < ActiveSupport::TestCase
-  def test_truncated_name=
-    person = Person.new
-    person.truncated_name = Person.long_value
-    assert_equal Person.short_value, person.truncated_name
-
-    person.truncated_name = nil
-    assert_equal nil, person.truncated_name
-
-    person.truncated_name = 'test_value'
-    assert_equal 'test_value', person.truncated_name
-  end
-
-  def test_truncated_whiny_name_validation
-    person = Person.new
-    person.truncated_whiny_name = Person.long_value
-
-    assert_not person.save
-    assert_equal ["is too long (maximum is #{COLUMN_LIMIT} characters)"],
-      person.errors[:truncated_whiny_name]
-  end
-
   def test_truncate_attributes
     person = Person.new
     person.set_long_attributes
 
     assert person.truncate_attributes
-    assert_equal Person.short_value, person.truncated_name
-    assert_equal Person.short_value, person.truncated_whiny_name
+    person_attributes.each do |attribute|
+      assert_equal Person.short_value, person.send(attribute)
+    end
   end
 
   def test_truncate_attributes!
@@ -36,8 +16,9 @@ class TruncateAttributesTest < ActiveSupport::TestCase
     person.set_long_attributes
 
     assert person.truncate_attributes!
-    assert_equal Person.short_value, person.truncated_name
-    assert_equal Person.short_value, person.truncated_whiny_name
+    person_attributes.each do |attribute|
+      assert_equal Person.short_value, person.send(attribute)
+    end
   end
 
   def test_truncated_attributes_inheritance
@@ -45,25 +26,32 @@ class TruncateAttributesTest < ActiveSupport::TestCase
     architect.set_long_attributes
 
     assert architect.truncate_attributes
-    assert_equal Person.short_value, architect.truncated_name
-    assert_equal Person.short_value, architect.truncated_whiny_name
-    assert_equal Person.short_value, architect.other_truncated_name
+    architect_attributes.each do |attribute|
+      assert_equal Architect.short_value, architect.send(attribute)
+    end
   end
 
   def test_truncated_attributes
-    assert_equal Person.truncated_attributes.map(&:attribute),
-      [:truncated_name, :truncated_whiny_name]
-    assert_equal Developer.truncated_attributes.map(&:attribute), []
-    assert_equal Architect.truncated_attributes.map(&:attribute),
-      [:other_truncated_name]
+    assert_equal person_attributes, Person.truncated_attributes.map(&:attribute)
+    assert_empty Developer.truncated_attributes.map(&:attribute)
+    assert_equal [:architect_truncated], Architect.truncated_attributes.map(&:attribute)
   end
 
   def test_inherited_truncated_attributes
-    assert_equal Person.inherited_truncated_attributes.map(&:attribute),
-      [:truncated_name, :truncated_whiny_name]
-    assert_equal Developer.inherited_truncated_attributes.map(&:attribute),
-      [:truncated_name, :truncated_whiny_name]
-    assert_equal Architect.inherited_truncated_attributes.map(&:attribute),
-      [:other_truncated_name, :truncated_name, :truncated_whiny_name]
+    assert_equal person_attributes, Person.inherited_truncated_attributes.map(&:attribute)
+    assert_equal person_attributes, Developer.inherited_truncated_attributes.map(&:attribute)
+    assert_equal architect_attributes, Architect.inherited_truncated_attributes.map(&:attribute)
   end
+
+  private
+
+    # a list of the attributes that are truncated on the architect class
+    def architect_attributes
+      @architect_attributes ||= ([:architect_truncated] + person_attributes)
+    end
+
+    # a list of the attributes that are truncated on the person class
+    def person_attributes
+      @person_attributes ||= [:person_truncated_one, :person_truncated_two, :person_truncated_three, :person_truncated_four]
+    end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attribute_extras
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-03 00:00:00.000000000 Z
+date: 2015-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,10 +38,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Overrides writers methods on ActiveRecord classes to allow for different
-  behavior such as nullifying, stripping, and truncating.
+description: Builds macros to automatically manipulate your models' attributes.
 email:
-- kevin.deisz@gmail.com
+- info@trialnetworks.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -51,10 +50,9 @@ files:
 - Rakefile
 - lib/attribute_extras.rb
 - lib/attribute_extras/base_extensions.rb
+- lib/attribute_extras/extra_builder.rb
+- lib/attribute_extras/hook_builder.rb
 - lib/attribute_extras/modifier.rb
-- lib/attribute_extras/nullify_attributes.rb
-- lib/attribute_extras/strip_attributes.rb
-- lib/attribute_extras/truncate_attributes.rb
 - lib/attribute_extras/version.rb
 - test/base_extensions_test.rb
 - test/modifier_test.rb
@@ -63,7 +61,7 @@ files:
 - test/test_classes.rb
 - test/test_helper.rb
 - test/truncate_attributes_test.rb
-homepage: https://github.com/kddeisz/attribute_extras
+homepage: https://github.com/drugdev/attribute_extras
 licenses:
 - MIT
 metadata: {}

data/lib/attribute_extras/nullify_attributes.rb

@@ -1,49 +0,0 @@
-module AttributeExtras
-  module NullifyAttributes
-
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # inherited and current nullified attributes
-      def inherited_nullified_attributes
-        @inherited_nullified_attributes ||= begin
-          modifiers = []
-          self.ancestors.each_with_object([]) do |ancestor|
-            break if ancestor == ActiveRecord::Base
-            if ancestor.respond_to?(:nullified_attributes)
-              modifiers += ancestor.nullified_attributes
-            end
-          end
-          modifiers
-        end
-      end
-
-      # the nullified attributes for this class
-      def nullified_attributes
-        @nullified_attributes ||= []
-      end
-    end
-
-    # calls set_nullified_attributes then save
-    def nullify_attributes
-      set_nullified_attributes
-      self.save if self.changed?
-    end
-
-    # calls set_nullified_attributes then save!
-    def nullify_attributes!
-      set_nullified_attributes
-      self.save! if self.changed?
-    end
-
-    private
-
-      # apply the nullification to each specified nullified attribute
-      def set_nullified_attributes
-        self.class.inherited_nullified_attributes.each do |modifier|
-          attribute = modifier.attribute
-          self.send("#{attribute}=", self.send(attribute))
-        end
-      end
-  end
-end

data/lib/attribute_extras/strip_attributes.rb

@@ -1,49 +0,0 @@
-module AttributeExtras
-  module StripAttributes
-
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # inherited and current stripped attributes
-      def inherited_stripped_attributes
-        @inherited_stripped_attributes ||= begin
-          modifiers = []
-          self.ancestors.each_with_object([]) do |ancestor|
-            break if ancestor == ActiveRecord::Base
-            if ancestor.respond_to?(:stripped_attributes)
-              modifiers += ancestor.stripped_attributes
-            end
-          end
-          modifiers
-        end
-      end
-
-      # the stripped attributes for this class
-      def stripped_attributes
-        @stripped_attributes ||= []
-      end
-    end
-
-    # calls set_stripped_attributes then save
-    def strip_attributes
-      set_stripped_attributes
-      self.save if self.changed?
-    end
-
-    # calls set_stripped_attributes then save!
-    def strip_attributes!
-      set_stripped_attributes
-      self.save! if self.changed?
-    end
-
-    private
-
-      # apply the strip to each specified stripped attribute
-      def set_stripped_attributes
-        self.class.inherited_stripped_attributes.each do |modifier|
-          attribute = modifier.attribute
-          self.send("#{attribute}=", self.send(attribute))
-        end
-      end
-  end
-end

data/lib/attribute_extras/truncate_attributes.rb

@@ -1,53 +0,0 @@
-module AttributeExtras
-  module TruncateAttributes
-
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # inherited and current truncated attributes
-      def inherited_truncated_attributes
-        @inherited_truncated_attributes ||= begin
-          modifiers = []
-          self.ancestors.each_with_object([]) do |ancestor|
-            break if ancestor == ActiveRecord::Base
-            if ancestor.respond_to?(:truncated_attributes)
-              modifiers += ancestor.truncated_attributes
-            end
-          end
-          modifiers
-        end
-      end
-
-      # the truncated attributes for this class
-      def truncated_attributes
-        @truncated_attributes ||= []
-      end
-    end
-
-    # calls set_truncated_attributes then save
-    def truncate_attributes
-      set_truncated_attributes
-      self.save if self.changed?
-    end
-
-    # calls set_truncated_attributes then save!
-    def truncate_attributes!
-      set_truncated_attributes
-      self.save! if self.changed?
-    end
-
-    private
-
-      # apply the truncation to each specified truncated attribute
-      def set_truncated_attributes
-        self.class.inherited_truncated_attributes.each do |modifier|
-          attribute = modifier.attribute
-          if modifier.options[:limit]
-            self.send("#{attribute}=", self.send(attribute)[0...modifier.options[:limit]])
-          else
-            self.send("#{attribute}=", self.send(attribute))
-          end
-        end
-      end
-  end
-end