active_fedora-registered_attributes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8dac8cbef5f9c4b50b43a392200ac5ad508c946a
+  data.tar.gz: 24c9889b73ad5b4cd584323c7a654d72877ab4ca
+SHA512:
+  metadata.gz: 5c056a733cd092784c5b730fe233c1988c3cb65e2cc116a7ab36e1cfff5c595fd2337492e78cf6b07c5eeba5ecb064fc6a1d602508283abbb9f75ae4857b18fd
+  data.tar.gz: 2bf802fc4d7178567339b552a84a51e12f8befe12cfdff0163371b5012d55c729ee19360f700fb3e0daa2184af66f0b278185e5698f92d5254da56617709c805

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+
+script: "rspec"
+
+notifications:
+  irc: "irc.freenode.org#ndlib"
+
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_fedora-registered_attributes.gemspec
+gemspec
+
+group :test do
+  gem 'simplecov', require: false
+  gem "guard"
+  gem "guard-rspec"
+end

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('spec/support/*')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,17 @@
+##########################################################################
+# active_fedora-registered_attributes
+#
+# Copyright © 2013 University of Notre Dame
+# Additional copyright may be held by others, as reflected in the commit history.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,63 @@
+# ActiveFedora::RegisteredAttributes
+
+[![Build Status](https://travis-ci.org/jeremyf/active_fedora-registered_attributes.png?branch=master)](https://travis-ci.org/jeremyf/active_fedora-registered_attributes)
+
+An ActiveFedora extension for consolidating the attribute definitions for an object.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_fedora-registered_attributes'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_fedora-registered_attributes
+
+## Usage
+
+    class Foo < ActiveRecord::Base
+      include ActiveFedora::RegisteredAttributes
+
+      has_metadata name: "descMetadata", type: FooMetadataDatastream
+
+      attribute :title,
+        datastream: :descMetadata, multiple: false,
+        label: "Title of your Senior Thesis",
+        validates: { presence: { message: 'Your must have a title.' } }
+
+      attribute :creator,
+        datastream: :descMetadata, multiple: true,
+        label: "Author",
+        hint: "Enter your preferred name",
+        writer: :parse_person_names,
+        reader: :parse_person_names,
+        validates: { presence: { message: "You must have an author."} }
+    end
+
+## Internationalization
+
+If you utilize internationalization, such as below, then regardless of what
+your model indicates as the label, it will use the internationalization.
+
+    en:
+      activemodel:
+        attributes:
+          foo:
+            internationalized_field: Welcome
+
+## TODO
+
+* Add internationalization support for hints and validation messages.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/active_fedora-registered_attributes.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_fedora/registered_attributes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_fedora-registered_attributes"
+  spec.version       = ActiveFedora::RegisteredAttributes::VERSION
+  spec.authors       = ["Jeremy Friesen"]
+  spec.email         = ["jeremy.n.friesen@gmail.com"]
+  spec.description   = %q{An ActiveFedora extension for registring attributes}
+  spec.summary       = %q{An ActiveFedora extension for registring attributes}
+  spec.homepage      = "http://github.com/jeremyf/active_fedora-registered_attributes"
+  spec.license       = "APACHE2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "active-fedora", ">= 6.4"
+  spec.add_dependency "active_attr", "~> 0.8.2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/active_fedora/registered_attributes.rb

@@ -0,0 +1,69 @@
+require "active_fedora/registered_attributes/version"
+require 'active_attr'
+require "active_fedora/registered_attributes/attribute"
+require "active_fedora/registered_attributes/attribute_registry"
+
+module ActiveFedora
+  module RegisteredAttributes
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :attribute_registry, instance_writer: false, instance_reader: false
+    end
+
+    delegate :attribute_defaults, to: :attribute_registry
+    delegate :input_options_for, to: :attribute_registry
+    delegate :label_for, to: :attribute_registry
+    delegate :editable_attributes, to: :attribute_registry
+    delegate :displayable_attributes, to: :attribute_registry
+
+    def attribute_registry
+      self.class.attribute_registry
+    end
+    private :attribute_registry
+
+    module ClassMethods
+      def attribute(attribute_name, options ={})
+        self.attribute_registry ||= AttributeRegistry.new(self)
+        self.attribute_registry.register(attribute_name, options) do |attribute|
+
+          attribute.with_validation_options do |name, opts|
+            validates(name, opts)
+          end
+
+          attribute.with_accession_options do |name, opts|
+            attr_accessor name
+          end
+
+          attribute.with_delegation_options do |name, opts|
+            delegate(name, opts)
+          end
+
+          attribute.wrap_writer_method(self)
+          attribute.wrap_reader_method(self)
+        end
+      end
+    end
+
+
+    # Applies the attribute defaults
+    #
+    # Applies all the default values to any attributes not yet set, avoiding
+    # any attribute setter logic, such as dirty tracking.
+    #
+    # @param [Hash{String => Object}, #each] defaults The defaults to apply
+    def apply_defaults(defaults=attribute_defaults)
+      defaults.each do |name, value|
+        unless value.nil?
+          send("#{name}=", value) unless send("#{name}").present?
+        end
+      end
+    end
+
+    # Applies attribute default values
+    def initialize(*)
+      super
+      apply_defaults
+    end
+
+  end
+end

data/lib/active_fedora/registered_attributes/attribute.rb

@@ -0,0 +1,124 @@
+module ActiveFedora
+  module RegisteredAttributes
+    class Attribute
+
+      attr_reader :context_class, :name, :datastream
+      private :context_class
+
+      def initialize(context_class, name, options = {})
+        @context_class = context_class
+        @options = options.symbolize_keys
+        @options.assert_valid_keys(:default, :displayable, :editable, :form, :datastream, :validates, :at, :as, :multiple, :writer, :reader, :label, :hint)
+        @datastream = @options.fetch(:datastream, false)
+        @name = name
+        @options[:multiple] = false unless @options.key?(:multiple)
+        @options[:form] ||= {}
+      end
+
+      def displayable?
+        @options.fetch(:displayable, true)
+      end
+
+      def editable?
+        @options.fetch(:editable, true)
+      end
+
+      def label
+        default = options[:label] || name.to_s.humanize
+        context_class.human_attribute_name(name, default: default)
+      end
+
+      def with_delegation_options
+        yield(name, options_for_delegation) if datastream
+      end
+
+      def with_validation_options
+        yield(name, options[:validates]) if options[:validates]
+      end
+
+      def with_accession_options
+        yield(name, {}) if !datastream
+      end
+
+      def options_for_input(overrides = {})
+        options[:form].tap {|hash|
+          hash[:hint] ||= options[:hint] if options[:hint]
+          hash[:label] ||= options[:label] if options[:label]
+          hash[:as] ||= options[:as] if options[:as]
+          if options[:multiple]
+            hash[:as] = 'multi_value'
+            hash[:input_html] ||= {}
+            hash[:input_html][:multiple] = 'multiple'
+          end
+        }.deep_merge(overrides)
+      end
+
+      def default(context)
+        this_default = options[:default]
+        case
+        when this_default.respond_to?(:call) then context.instance_exec(&this_default)
+        when this_default.duplicable? then this_default.dup
+        else this_default
+        end
+      end
+
+      def wrap_writer_method(context)
+        with_writer_method_wrap do |method_name, block|
+          context.instance_exec do
+            original_method = instance_method(method_name)
+            define_method(method_name) do |*args|
+              original_method.bind(self).call(instance_exec(*args, &block))
+            end
+          end
+        end
+      end
+
+      def wrap_reader_method(context)
+        with_reader_method_wrapper do |method_name, block|
+          context.instance_exec do
+            original_method = instance_method(method_name)
+            define_method(method_name) do |*args|
+              instance_exec(original_method.bind(self).call(*args), &block)
+            end
+          end
+        end
+      end
+
+      private
+
+        def options_for_delegation
+          {
+            to: datastream,
+            unique: !options[:multiple]
+          }.tap {|hash|
+            hash[:at] = options[:at] if options.key?(:at)
+          }
+        end
+
+        def with_writer_method_wrap
+          if writer = options[:writer]
+            method_name = "#{name}=".to_sym
+            proc = writer.respond_to?(:call) ?
+              writer :
+              lambda { |value| send(writer, value) }
+            yield(method_name, proc)
+          end
+        end
+
+        def with_reader_method_wrapper
+          if reader = options[:reader]
+            method_name = "#{name}".to_sym
+            proc = reader.respond_to?(:call) ?
+              reader :
+              lambda { |value| send(reader, value) }
+            yield(method_name, proc)
+          end
+        end
+
+        def options
+          @options
+        end
+
+    end
+  end
+end

data/lib/active_fedora/registered_attributes/attribute_registry.rb

@@ -0,0 +1,57 @@
+require 'delegate'
+require 'active_support/hash_with_indifferent_access'
+require 'active_fedora/registered_attributes/attribute'
+
+
+module ActiveFedora
+  module RegisteredAttributes
+    class AttributeRegistry < DelegateClass(HashWithIndifferentAccess)
+      attr_accessor :context_class
+      def initialize(context_class)
+        @context_class = context_class
+        super(HashWithIndifferentAccess.new)
+      end
+
+      def register(attribute_name, options)
+        attribute = Attribute.new(context_class, attribute_name, options)
+        self[attribute.name] = attribute
+        yield(attribute) if block_given?
+        attribute
+      end
+
+      def editable_attributes
+        @editable_attributes ||= each_with_object([]) {|(name, attribute), m|
+          m << attribute if attribute.editable?
+          m
+        }
+      end
+
+      def displayable_attributes
+        @displayable_attributes ||= each_with_object([]) {|(name, attribute),m|
+          m << attribute if attribute.displayable?
+          m
+        }
+      end
+
+      # Calculates the attribute defaults from the attribute definitions
+      #
+      # @return [Hash{String => Object}] the attribute defaults
+      def attribute_defaults
+        collect { |name, attribute| [name, attribute.default(context_class)] }
+      end
+
+      def input_options_for(attribute_name, override_options = {})
+        fetch(attribute_name).options_for_input(override_options)
+      rescue KeyError
+        override_options
+      end
+
+      def label_for(name)
+        fetch(name).label
+      rescue KeyError
+        name.to_s.titleize
+      end
+    end
+
+  end
+end

data/lib/active_fedora/registered_attributes/version.rb

@@ -0,0 +1,5 @@
+module ActiveFedora
+  module RegisteredAttributes
+    VERSION = "0.0.1"
+  end
+end

data/spec/active_fedora/registered_attributes/attribute_registry_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require "active_fedora/registered_attributes/attribute_registry"
+
+describe ActiveFedora::RegisteredAttributes::AttributeRegistry do
+  let(:context) { Book }
+  let(:name) { "My Name" }
+  let(:options) { {} }
+  subject { ActiveFedora::RegisteredAttributes::AttributeRegistry.new(context) }
+
+  describe '#register' do
+    it 'yields an attribute' do
+      @name = nil
+      subject.register(name, options) do |attribute|
+        @name = attribute.name
+      end
+      expect(@name).to eq(name)
+    end
+    it 'stores the attribute' do
+      subject.register(name, options)
+      expect(subject.fetch(name)).to be_kind_of(ActiveFedora::RegisteredAttributes::Attribute)
+    end
+  end
+  describe 'editable and displayable attributes' do
+    let(:editable_options) { { editable: true, displayable: false } }
+    let(:displayable_options) { { editable: false, displayable: true } }
+    let(:default_options) { {} }
+
+    before(:each) do
+      @editable_attribute = subject.register('editable', editable_options)
+      @displayable_attribute = subject.register('displayable', displayable_options)
+      @default_attribute = subject.register('default', default_options)
+    end
+    it 'has #editable_attributes derived from registered inputs' do
+      expect(subject.editable_attributes).to eq([@editable_attribute, @default_attribute])
+    end
+    it 'has #displayable_attributes derived from registered inputs' do
+      expect(subject.displayable_attributes).to eq([@displayable_attribute, @default_attribute])
+    end
+  end
+  describe '#attribute_defaults' do
+    let(:context) { double }
+    let(:default_options) { { default: '1234' } }
+    let(:default_field_name) { 'something' }
+    it "assigns default on registry's context context" do
+      subject.register(default_field_name, default_options)
+      expect(subject.attribute_defaults).to eq([[default_field_name, default_options.fetch(:default)]])
+    end
+  end
+  describe '#input_options_for' do
+    let(:editable_options) { { editable: true, displayable: false, multiple: true } }
+
+    before(:each) do
+      @editable_attribute = subject.register('editable', editable_options)
+    end
+
+    it "returns input options for existing attribute" do
+      expect(subject.input_options_for('editable')).to eq({as: "multi_value",input_html: {multiple:"multiple"}})
+    end
+
+    it "returns default options for existing attribute" do
+      options = {hello: :world}
+      expect(subject.input_options_for('hello', options)).to eq(options)
+    end
+  end
+  describe '#label_for' do
+    let(:label_options) { { label: "Hello World" } }
+    let(:field_name) { 'thing' }
+
+    before(:each) do
+      subject.register(field_name, label_options)
+    end
+
+    it "handles label for existing field" do
+      expect(subject.label_for(field_name)).to eq(label_options.fetch(:label))
+    end
+
+    it "handles missing field's label" do
+      expect(subject.label_for("hydra_field")).to eq("Hydra Field")
+    end
+  end
+end

data/spec/active_fedora/registered_attributes/attribute_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require "active_fedora/registered_attributes/attribute"
+
+describe ActiveFedora::RegisteredAttributes::Attribute do
+  let(:context) { Book }
+  let(:field_name) { :title }
+  let(:datastream) { 'properties' }
+  let(:validation_options) {{ presence: true }}
+  let(:options) {
+    {
+      datastream: datastream, hint: 'Your title',
+      form: { input_html: {style: 'title-picker'}},
+      multiple: true,
+      displayable: displayable,
+      editable: editable,
+      default: default_value,
+      validates: validation_options
+    }
+  }
+  let(:displayable) { true }
+  let(:editable) { true }
+  let(:default_value) { nil }
+  subject { ActiveFedora::RegisteredAttributes::Attribute.new(context, field_name, options) }
+
+  describe '#displayable?' do
+    its (:displayable?) { should == displayable }
+  end
+
+  describe '#editable?' do
+    its (:editable?) { should == editable }
+  end
+
+  describe '#label' do
+    describe 'with explicit model level label' do
+      it 'uses the explicit label' do
+        expect(subject.label).to eq(field_name.to_s.titleize)
+      end
+    end
+
+    describe 'with inferred field' do
+      let(:field_name) { 'internationalized_field' }
+      it 'uses the explicit label' do
+        expect(subject.label).to eq('Internationalized field')
+      end
+    end
+  end
+
+  describe '#with_delegation_options' do
+    describe 'with a datastream' do
+      it 'yields name and options' do
+        @yielded = false
+        subject.with_delegation_options {|name,opts|
+          @yielded = true
+          expect(name).to eq(field_name)
+          expect(opts).to eq(subject.send(:options_for_delegation))
+        }
+        expect(@yielded).to eq(true)
+      end
+    end
+    describe 'without datastream' do
+      let(:datastream) { nil }
+      it 'does not yield name and options for #delegation' do
+        @yielded = false
+        subject.with_delegation_options {|name,opts|
+          @yielded = true
+        }
+        expect(@yielded).to eq(false)
+      end
+    end
+  end
+
+  describe '#with_validation_options' do
+    describe 'with validation options' do
+      it 'yields name and options for #validations' do
+        @yielded = false
+        subject.with_validation_options do |name, opts|
+          expect(name).to eq(field_name)
+          expect(opts).to eq(validation_options)
+          @yielded = true
+        end
+        expect(@yielded).to eq(true)
+      end
+    end
+    describe 'without validation options' do
+      let(:validation_options) { nil }
+      it 'does not yield validation options' do
+        @yielded = false
+        subject.with_validation_options do |name, opts|
+          @yielded = true
+        end
+        expect(@yielded).to eq(false)
+      end
+    end
+  end
+
+  describe '#with_accession_options' do
+    describe 'with a datastream' do
+      it 'does not yield name nor options' do
+        @yielded = false
+        subject.with_accession_options {|name,opts|
+          @yielded = true
+        }
+        expect(@yielded).to eq(false)
+      end
+    end
+
+    describe 'without datastream' do
+      let(:datastream) { nil }
+      it 'yields name and options for #accession' do
+        @yielded = false
+        subject.with_accession_options {|name,opts|
+          @yielded = true
+          expect(name).to eq(field_name)
+          expect(opts).to eq({})
+        }
+        expect(@yielded).to eq(true)
+      end
+    end
+  end
+
+  describe '#options_for_input' do
+    it 'is roughly what simple_form expects' do
+      expect(subject.options_for_input(input_html: {size: 10})).to eq(
+        {
+          hint: 'Your title', as: 'multi_value', input_html:
+          {
+            style: 'title-picker', multiple: 'multiple', size: 10
+          }
+        }
+      )
+    end
+  end
+
+  describe '#default' do
+    let(:instance) { Book.new }
+    describe 'with string as default value' do
+      let(:default_value) { '1234' }
+      it 'defaults to the string' do
+        expect(subject.default(instance)).to eq(default_value)
+      end
+    end
+
+    describe 'with a lambda as the option' do
+      let(:default_value) { lambda { object_id } }
+      it "evaluates the lambda in the context of the default method's input" do
+        expect(subject.default(instance)).to eq(instance.object_id)
+      end
+    end
+  end
+
+  describe '#wrap_writer_method(context)' do
+    xit 'with a symbol referencing an instance method'
+    xit 'with a lambda'
+  end
+
+  describe '#wrap_reader_method(context)' do
+    xit 'with a symbol referencing an instance method'
+    xit 'with a lambda'
+  end
+end

data/spec/active_fedora/registered_attributes_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'active_fedora/registered_attributes'
+
+describe 'ActiveFedora::RegisteredAttributes' do
+  class MockDelegateAttribute < ActiveFedora::Base
+    include ActiveFedora::RegisteredAttributes
+
+    has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
+      m.field "title",  :string
+      m.field "description",  :string
+      m.field "creator", :string
+      m.field "file_names", :string
+      m.field "locations", :string
+      m.field "created_on", :date
+      m.field "modified_on", :date
+    end
+
+    attribute :title, {
+      datastream: 'properties',
+      label: 'Title of your Work',
+      hint: "How would you name this?",
+      validates: { presence: true }
+    }
+
+    attribute :description, {
+      datastream: 'properties',
+      default: ['One two'],
+      multiple: true
+    }
+
+    attribute :creator, {
+      datastream: 'properties',
+      multiple: false,
+      writer: lambda{|value| value.reverse }
+    }
+
+    attribute :file_names, {
+      datastream: 'properties',
+      multiple: true,
+      writer: lambda{|value| value.reverse }
+    }
+
+    def set_locations(value)
+      value.dup << '127.0.0.1'
+    end
+    protected :set_locations
+
+    attribute :locations, {
+      datastream: 'properties',
+      displayable: false,
+      multiple: true,
+      writer: :set_locations
+    }
+
+    attribute :created_on, {
+      datastream: 'properties',
+      multiple: false,
+      reader: lambda {|value|
+        "DATE: #{value}"
+      }
+    }
+
+    attribute :not_in_the_datastream, {
+      multiple: false,
+      editable: false,
+      displayable: false
+    }
+
+    attribute :modified_on, {
+      datastream: 'properties',
+      multiple: true,
+      editable: false,
+      reader: lambda {|value|
+        "DATE: #{value}"
+      }
+    }
+  end
+  subject { MockDelegateAttribute.new() }
+
+  describe '#editable_attributes' do
+    let(:expected_attribute_names) {
+      [ :title, :description, :creator, :file_names, :locations, :created_on ]
+    }
+    it 'is all of the attributes that are editable' do
+      actual_editable_attributes = subject.editable_attributes.collect {|a| a.name }
+      expect(actual_editable_attributes).to eq(expected_attribute_names)
+    end
+  end
+
+  describe '#displayable_attributes' do
+    let(:expected_attribute_names) {
+      [ :title, :description, :creator, :file_names, :created_on, :modified_on ]
+    }
+    it 'is all of the attributes that are displayable' do
+      actual_displayable_attributes = subject.displayable_attributes.collect {|a| a.name }
+      expect(actual_displayable_attributes).to eq(expected_attribute_names)
+    end
+  end
+
+  describe '.attribute' do
+    it 'handles attributes not delegated to a datastream' do
+      subject.not_in_the_datastream = 'World?'
+      expect(subject.not_in_the_datastream).to eq('World?')
+    end
+    it "has creates a setter/getter" do
+      subject.title = 'Hello'
+      expect(subject.properties.title).to eq([subject.title])
+    end
+
+    it "enforces validation when passed" do
+      subject.title = nil
+      subject.valid?
+      expect(subject.errors[:title].size).to eq(1)
+    end
+
+    it "allows for default" do
+      expect(subject.description).to eq(['One two'])
+    end
+
+    it "allows for a reader to intercept the returning of values" do
+      date = Date.today
+      subject.created_on = date
+      expect(subject.properties.created_on).to eq([date])
+      expect(subject.created_on).to eq("DATE: #{date}")
+    end
+
+    it "allows for a reader to intercept the returning of values" do
+      date = Date.today
+      subject.created_on = date
+      expect(subject.properties.created_on).to eq([date])
+      expect(subject.created_on).to eq("DATE: #{date}")
+    end
+
+    it "allows for a writer to intercept the setting of values" do
+      text = 'hello world'
+      subject.creator = 'hello world'
+      expect(subject.properties.creator).to eq([text.reverse])
+      expect(subject.creator).to eq(text.reverse)
+    end
+
+    it "allows for a writer to intercept the setting of values" do
+      values = ['foo.rb', 'bar.rb']
+      subject.file_names = values
+      expect(subject.properties.file_names).to eq(values.reverse)
+      expect(subject.file_names).to eq(values.reverse)
+    end
+
+    it "allows for a writer that is a symbol" do
+      values = ['South Bend', 'State College', 'Minneapolis']
+      expected_values = values.dup
+      expected_values << '127.0.0.1'
+      subject.locations = values
+      expect(subject.properties.locations).to eq(expected_values)
+      expect(subject.locations).to eq(expected_values)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec"
+end
+
+require 'active_fedora'
+
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each {|f| require f}
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/book.rb

@@ -0,0 +1,5 @@
+class Book < ActiveFedora::Base
+  has_metadata name: "properties", type: ActiveFedora::SimpleDatastream do |m|
+    m.field('title')
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: active_fedora-registered_attributes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeremy Friesen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active-fedora
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '6.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '6.4'
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An ActiveFedora extension for registring attributes
+email:
+- jeremy.n.friesen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_fedora-registered_attributes.gemspec
+- lib/active_fedora/registered_attributes.rb
+- lib/active_fedora/registered_attributes/attribute.rb
+- lib/active_fedora/registered_attributes/attribute_registry.rb
+- lib/active_fedora/registered_attributes/version.rb
+- spec/active_fedora/registered_attributes/attribute_registry_spec.rb
+- spec/active_fedora/registered_attributes/attribute_spec.rb
+- spec/active_fedora/registered_attributes_spec.rb
+- spec/spec_helper.rb
+- spec/support/book.rb
+homepage: http://github.com/jeremyf/active_fedora-registered_attributes
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: An ActiveFedora extension for registring attributes
+test_files:
+- spec/active_fedora/registered_attributes/attribute_registry_spec.rb
+- spec/active_fedora/registered_attributes/attribute_spec.rb
+- spec/active_fedora/registered_attributes_spec.rb
+- spec/spec_helper.rb
+- spec/support/book.rb