active-triples 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a31ce4cccede2e3befa05a4b20dc4894547b219a
-  data.tar.gz: 8c47c1b2ad7a9514298dbae6f290c09313590c6d
+  metadata.gz: 6fe9b5e7c31b1ebd51f2c529d354c27ff5a50461
+  data.tar.gz: 96039e8d7e41040748705955d064101fce40f236
 SHA512:
-  metadata.gz: dea13110704ca324e2cce448cd413450e21c0a6837ea269f7be8aa783b5540f85d9a11df04a2a891c1986ed40eb551347b06119547518c7e43c093cc715504c8
-  data.tar.gz: 82fbe1c1025d727d396eb8e3c612b56b209d40bac4bec074cef008afa91c052a58e7b344a38a47b29943d725f273776c83b04070a403abcf53adbdf3a6682372
+  metadata.gz: 6c2474afde1a6b48790bed08a67caf0e413f8339cfa5993f0ef6bcb277cf642c21bc5d0f2e1ce830f735766d704ca35cd6bacc3076a1645d52f96f28ba44cd7a
+  data.tar.gz: abbe7fd8978112727f975413aa4cb5bb9a20cfc443c4e2f128d4469010391f20bc79e3466575e68153413b1db7763c7be1aa7f633ed6c75796e3213ac460af37

data/lib/active_triples.rb

@@ -1,16 +1,22 @@
 require 'rdf'
 require 'active_triples/version'
+require 'active_support'
 
 module ActiveTriples
-  autoload :Resource,         'active_triples/resource'
-  autoload :List,             'active_triples/list'
-  autoload :Term,             'active_triples/term'  
-  autoload :Indexing,         'active_triples/indexing'
-  autoload :Configurable,     'active_triples/configurable'
-  autoload :Properties,       'active_triples/properties'
-  autoload :Repositories,     'active_triples/repositories'
-  autoload :NodeConfig,       'active_triples/node_config'  
-  autoload :NestedAttributes, 'active_triples/nested_attributes'
+  extend ActiveSupport::Autoload
+  eager_autoload do
+    autoload :Resource
+    autoload :List
+    autoload :Term
+    autoload :Indexing
+    autoload :Configurable
+    autoload :Properties
+    autoload :PropertyBuilder
+    autoload :Reflection
+    autoload :Repositories
+    autoload :NodeConfig
+    autoload :NestedAttributes
+  end
 
   def self.class_from_string(class_name, container_class=Kernel)
     container_class = container_class.name if container_class.is_a? Module

data/lib/active_triples/list.rb

@@ -8,7 +8,8 @@ module ActiveTriples
   class List < RDF::List
     include ActiveTriples::NestedAttributes
     extend Configurable
-    extend Properties
+    include Properties
+    include Reflection
 
     delegate :rdf_subject, :mark_for_destruction, :marked_for_destruction?, :set_value, :get_values, :parent, :type, :dump, :attributes=, to: :resource
     alias_method :to_ary, :to_a
@@ -30,10 +31,6 @@ module ActiveTriples
       @graph = ListResource.new(subject) << graph unless graph.kind_of? Resource
       graph << parent if parent
       graph.list = self
-      graph.singleton_class.properties = self.class.properties
-      graph.singleton_class.properties.keys.each do |property|
-        graph.singleton_class.send(:register_property, property)
-      end
       graph.reload
     end
 
@@ -107,11 +104,15 @@ module ActiveTriples
         @list ||= list
       end
 
+      def reflections
+        @list.class
+      end
+
       def attributes=(values)
         raise ArgumentError, "values must be a Hash, you provided #{values.class}" unless values.kind_of? Hash
         values.with_indifferent_access.each do |key, value|
-          if self.singleton_class.properties.keys.map{ |k| "#{k}_attributes"}.include?(key)
-            klass = properties[key[0..-12]]['class_name']
+          if reflections.properties.keys.map { |k| "#{k}_attributes" }.include?(key)
+            klass = reflections.reflect_on_property(key[0..-12])['class_name']
             klass = ActiveTriples.class_from_string(klass, final_parent.class) if klass.is_a? String
             value.is_a?(Hash) ? attributes_hash_to_list(values[key], klass) : attributes_to_list(value, klass)
             values.delete key
@@ -159,9 +160,9 @@ module ActiveTriples
         when Array       then RDF::List.new(nil, graph, value)
         else value
       end
-      
+
       if subject == RDF.nil
-        @subject = RDF::Node.new 
+        @subject = RDF::Node.new
         @graph = ListResource.new(subject)
         @graph.type = RDF.List
       end

data/lib/active_triples/nested_attributes.rb

@@ -50,7 +50,7 @@ module ActiveTriples
 
       attributes_collection.each do |attributes|
         attributes = attributes.with_indifferent_access
-        
+
         if attributes['id'] && existing_record = association.detect { |record| record.rdf_subject.to_s == attributes['id'].to_s }
           if !call_reject_if(association_name, attributes)
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
@@ -83,7 +83,7 @@ module ActiveTriples
     def has_destroy_flag?(hash)
       ["1", "true"].include?(hash['_destroy'].to_s)
     end
-    
+
     module ClassMethods
       def accepts_nested_attributes_for *attr_names
         options = { :allow_destroy => false, :update_only => false }

data/lib/active_triples/node_config.rb

@@ -6,8 +6,9 @@ module ActiveTriples
       self.term = term
       self.predicate = predicate
       self.class_name = args.delete(:class_name)
-      self.multivalue = args.delete(:multivalue) { true } 
+      self.multivalue = args.delete(:multivalue) { true }
       raise ArgumentError, "Invalid arguments for Rdf Node configuration: #{args} on #{predicate}" unless args.empty?
+      yield(self) if block_given?
     end
 
     def [](value)

data/lib/active_triples/properties.rb

@@ -11,73 +11,59 @@ module ActiveTriples
   #    property :title, predicate: RDF::DC.title, class_name: ResourceClass
   #
   module Properties
-    attr_accessor :config
+    extend ActiveSupport::Concern
 
-    ##
-    # Registers properties for Resource-like classes
-    # @param [Symbol]  name of the property (and its accessor methods)
-    # @param [Hash]  opts for this property, must include a :predicate
-    # @yield [index] index sets solr behaviors for the property
-    def property(name, opts={}, &block)
-      self.config[name] = NodeConfig.new(name, opts[:predicate], opts.except(:predicate)).tap do |config|
-        config.with_index(&block) if block_given?
-      end
-      behaviors = config[name].behaviors.flatten if config[name].behaviors and not config[name].behaviors.empty?
-      register_property(name)
+    included do
+      initialize_generated_modules
     end
 
-    ##
-    # Returns the properties registered to the class and their 
-    # configurations.
-    #
-    # @return [ActiveSupport::HashWithIndifferentAccess{String => ActiveTriples::NodeConfig}]
-    def config
-      @config ||= if superclass.respond_to? :config
-        superclass.config.dup
-      else
-        {}.with_indifferent_access
+    module ClassMethods
+      def inherited(child_class) #:nodoc:
+        child_class.initialize_generated_modules
+        super
       end
-    end
-
-    alias_method :properties, :config
-    alias_method :properties=, :config=
 
-    ##
-    # Given a property name or a predicate, return the configuration
-    # for the matching property.
-    #
-    # @param term [#to_sym, RDF::Resource] a property name to predicate
-    #
-    # @return [ActiveTriples::NodeConfig]
-    def config_for_term_or_uri(term)
-      return config[term.to_sym] unless term.kind_of? RDF::Resource
-      config.each { |k, v| return v if v.predicate == term.to_uri }
-    end
+      def initialize_generated_modules # :nodoc:
+        generated_property_methods
+      end
 
-    ##
-    # List the property names registered to the class.
-    #
-    # @return [Array<Symbol>] list of the symbolized names of registered
-    #   properties
-    def fields
-      properties.keys.map(&:to_sym)
-    end
+      def generated_property_methods
+        @generated_property_methods ||= begin
+          mod = const_set(:GeneratedPropertyMethods, Module.new)
+          include mod
+          mod
+        end
+      end
 
-    private
+      ##
+      # Registers properties for Resource-like classes
+      # @param [Symbol]  name of the property (and its accessor methods)
+      # @param [Hash]  opts for this property, must include a :predicate
+      # @yield [index] index sets solr behaviors for the property
+      def property(name, opts={}, &block)
+        reflection = PropertyBuilder.build(self, name, opts, &block)
+        Reflection.add_reflection self, name, reflection
+      end
 
-    ##
-    # Private method for creating accessors for a given property.
-    #
-    # @param [#to_s] name Name of the accessor to be created, 
-    #   get/set_value is called on the resource using this.
-    def register_property(name)
-      parent = Proc.new{self}
-      # parent = Proc.new{resource} if self < ActiveFedora::Datastream
-      define_method "#{name}=" do |*args|
-        instance_eval(&parent).set_value(name.to_sym, *args)
+      ##
+      # Given a property name or a predicate, return the configuration
+      # for the matching property.
+      #
+      # @param term [#to_sym, RDF::Resource] a property name to predicate
+      #
+      # @return [ActiveTriples::NodeConfig]
+      def config_for_term_or_uri(term)
+        return config[term.to_sym] unless term.kind_of? RDF::Resource
+        config.each_value { |v| return v if v.predicate == term.to_uri }
       end
-      define_method name do
-        instance_eval(&parent).get_values(name.to_sym)
+
+      ##
+      # List the property names registered to the class.
+      #
+      # @return [Array<Symbol>] list of the symbolized names of registered
+      #   properties
+      def fields
+        properties.keys.map(&:to_sym)
       end
     end
   end

data/lib/active_triples/property_builder.rb

@@ -0,0 +1,53 @@
+module ActiveTriples
+  class PropertyBuilder
+
+    attr_reader :name, :options
+
+    def initialize(name, options, &block)
+      @name = name
+      @options = options
+    end
+
+    def self.create_builder(name, options, &block)
+      raise ArgumentError, "property names must be a Symbol" unless name.kind_of?(Symbol)
+
+      new(name, options, &block)
+    end
+
+    def self.build(model, name, options, &block)
+      builder = create_builder name, options, &block
+      reflection = builder.build(&block)
+      define_accessors model, reflection
+      reflection
+    end
+
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_property_methods
+      name = reflection.term
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          get_values(:#{name})
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          set_value(:#{name}, value)
+        end
+      CODE
+    end
+
+    def build(&block)
+      NodeConfig.new(name, options[:predicate], options.except(:predicate)) do |config|
+        config.with_index(&block) if block_given?
+      end
+    end
+  end
+end

data/lib/active_triples/reflection.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/class'
+
+module ActiveTriples
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_active_triples_config
+      self._active_triples_config = {}
+    end
+
+    def self.add_reflection(model, name, reflection)
+      model._active_triples_config = model._active_triples_config.merge(name.to_s => reflection)
+    end
+
+    module ClassMethods
+      def reflect_on_property(term)
+        _active_triples_config[term.to_s]
+      end
+
+      def properties
+        _active_triples_config
+      end
+
+      def properties=(val)
+        self._active_triples_config = val
+      end
+    end
+  end
+end

data/lib/active_triples/resource.rb

@@ -22,7 +22,7 @@ module ActiveTriples
   class Resource < RDF::Graph
     @@type_registry
     extend Configurable
-    extend Properties
+    include Properties
     extend Deprecation
     extend  ActiveModel::Naming
     extend  ActiveModel::Translation
@@ -31,6 +31,7 @@ module ActiveTriples
     include ActiveModel::Serialization
     include ActiveModel::Serializers::JSON
     include NestedAttributes
+    include Reflection
     attr_accessor :parent
 
     class << self
@@ -116,14 +117,18 @@ module ActiveTriples
       hash
     end
 
+    def reflections
+      self.class
+    end
+
     def attributes=(values)
       raise ArgumentError, "values must be a Hash, you provided #{values.class}" unless values.kind_of? Hash
       values = values.with_indifferent_access
       set_subject!(values.delete(:id)) if values.has_key?(:id) and node?
       values.each do |key, value|
-        if properties.keys.include?(key)
+        if reflections.reflect_on_property(key)
           set_value(rdf_subject, key, value)
-        elsif self.singleton_class.nested_attributes_options.keys.map{ |k| "#{k}_attributes"}.include?(key)
+        elsif nested_attributes_options.keys.map { |k| "#{k}_attributes" }.include?(key)
           send("#{key}=".to_sym, value)
         else
           raise ArgumentError, "No association found for name `#{key}'. Has it been defined yet?"
@@ -143,7 +148,7 @@ module ActiveTriples
     # @return [String]
     def dump(*args)
       if args.first == :jsonld and respond_to?(:jsonld_context)
-        args << {} unless args.last.is_a?(Hash) 
+        args << {} unless args.last.is_a?(Hash)
         args.last[:context] ||= jsonld_context
       end
       super
@@ -206,16 +211,16 @@ module ActiveTriples
     end
 
     ##
-    # Load data from the #rdf_subject URI. Retrieved data will be 
+    # Load data from the #rdf_subject URI. Retrieved data will be
     # parsed into the Resource's graph from available RDF::Readers
-    # and available from property accessors if if predicates are 
+    # and available from property accessors if if predicates are
     # registered.
-    # 
+    #
     #    osu = ActiveTriples::Resource.new('http://dbpedia.org/resource/Oregon_State_University')
     #    osu.fetch
     #    osu.rdf_label.first
     #    # => "Oregon State University"
-    # 
+    #
     # @return [ActiveTriples::Resource] self
     def fetch
       load(rdf_subject)
@@ -405,23 +410,23 @@ module ActiveTriples
      end
 
     private
-    
+
       ##
       # Returns the properties registered and their configurations.
       #
       # @return [ActiveSupport::HashWithIndifferentAccess{String => ActiveTriples::NodeConfig}]
       def properties
-        self.singleton_class.properties
+        _active_triples_config
       end
 
       ##
       # List of RDF predicates registered as properties on the object.
       #
       # @return [Array<RDF::URI>]
-      def registered_predicates 
+      def registered_predicates
         properties.values.map { |config| config.predicate }
       end
-      
+
       ##
       # List of RDF predicates used in the Resource's triples, but not
       # mapped to any property or accessor methods.
@@ -434,12 +439,12 @@ module ActiveTriples
       end
 
       ##
-      # Given a predicate which has been registered to a property, 
+      # Given a predicate which has been registered to a property,
       # returns the name of the matching property.
       #
       # @param predicate [RDF::URI]
       #
-      # @return [String, nil] the name of the property mapped to the 
+      # @return [String, nil] the name of the property mapped to the
       #   predicate provided
       def property_for_predicate(predicate)
         properties.each do |property, values|
@@ -463,7 +468,7 @@ module ActiveTriples
       # @return [RDF::Repository, ActiveTriples::Resource] the target
       #   repository
       def repository
-        @repository ||= 
+        @repository ||=
           if self.class.repository == :parent
             final_parent
           else
@@ -476,16 +481,16 @@ module ActiveTriples
       # an RDF term. If a String is given, first tries to interpret it
       # as a valid URI, then tries to append it to base_uri. Finally,
       # raises an error if no valid term can be built.
-      # 
+      #
       # The argument must be an RDF::Node, an object that responds to
       # #to_uri, a String that represents a valid URI, or a String that
       # appends to the Resource's base_uri to create a valid URI.
       #
-      # @TODO: URI.scheme_list is naive and incomplete. Find a better 
+      # @TODO: URI.scheme_list is naive and incomplete. Find a better
       #   way to check for an existing scheme.
       #
       # @param uri_or_str [RDF::Resource, String]
-      # 
+      #
       # @return [RDF::Resource] A term
       # @raise [RuntimeError] no valid RDF term could be built
       def get_uri(uri_or_str)

data/lib/active_triples/term.rb

@@ -4,11 +4,13 @@ module ActiveTriples
   class Term
 
     attr_accessor :parent, :value_arguments, :node_cache
+    attr_reader :reflections
 
     delegate *(Array.public_instance_methods - [:send, :__send__, :__id__, :class, :object_id] + [:as_json]), :to => :result
 
-    def initialize(parent, value_arguments)
-      self.parent = parent
+    def initialize(parent_resource, value_arguments)
+      self.parent = parent_resource
+      @reflections = parent_resource.reflections
       self.value_arguments = value_arguments
     end
 
@@ -18,8 +20,10 @@ module ActiveTriples
 
     def result
       result = parent.query(:subject => rdf_subject, :predicate => predicate)
-      .map{|x| convert_object(x.object)}
-      .reject(&:nil?)
+      .each_with_object([]) do |x, collector|
+        converted_object = convert_object(x.object)
+        collector << converted_object unless converted_object.nil?
+      end
       return result if !property_config || property_config[:multivalue]
       result.first
     end
@@ -42,9 +46,9 @@ module ActiveTriples
     end
 
     def build(attributes={})
-      new_subject = attributes.key?('id') ? attributes.delete('id') : RDF::Node.new
+      new_subject = attributes.fetch('id') { RDF::Node.new }
       make_node(new_subject).tap do |node|
-        node.attributes = attributes
+        node.attributes = attributes.except('id')
         if parent.kind_of? List::ListResource
           parent.list << node
         elsif node.kind_of? RDF::List
@@ -73,8 +77,8 @@ module ActiveTriples
     alias_method :push, :<<
 
     def property_config
-      return type_property if (property == RDF.type || property.to_s == "type") && !parent.send(:properties)[property]
-      parent.send(:properties)[property]
+      return type_property if (property == RDF.type || property.to_s == "type") && (!reflections.kind_of?(Resource) || !reflections.reflect_on_property(property))
+      reflections.reflect_on_property(property)
     end
 
     def type_property
@@ -113,7 +117,7 @@ module ActiveTriples
           return
         end
         val = val.to_uri if val.respond_to? :to_uri
-        raise 'value must be an RDF URI, Node, Literal, or a valid datatype. See RDF::Literal' unless
+        raise "value must be an RDF URI, Node, Literal, or a valid datatype. See RDF::Literal.\n\tYou provided #{val.inspect}" unless
           val.kind_of? RDF::Value or val.kind_of? RDF::Literal
         parent.insert [rdf_subject, predicate, val]
       end
@@ -144,7 +148,7 @@ module ActiveTriples
       def convert_object(value)
         case value
         when RDF::Literal
-          value.object 
+          value.object
         when RDF::Resource
           make_node(value)
         else

data/lib/active_triples/version.rb

@@ -1,3 +1,3 @@
 module ActiveTriples
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/spec/active_triples/configurable_spec.rb

@@ -29,7 +29,8 @@ describe ActiveTriples::Configurable do
 
   describe '#rdf_type' do
     it "should set the type the old way" do
-      DummyConfigurable.should_receive(:configure).with(type: RDF::RDFS.Class).and_call_original
+      expect(DummyConfigurable).to receive(:configure).with(type: RDF::RDFS.Class).and_call_original
+      expect(Deprecation).to receive(:warn)
       DummyConfigurable.rdf_type(RDF::RDFS.Class)
       expect(DummyConfigurable.type).to eq RDF::RDFS.Class
     end

data/spec/active_triples/list_spec.rb

@@ -5,7 +5,7 @@ require 'linkeddata'
 describe ActiveTriples::List do
 
   subject { ActiveTriples::List.new }
-  
+
   context 'when empty' do
     it 'has subject of RDF.nil' do
       expect(subject.subject).to eq RDF.nil
@@ -43,7 +43,7 @@ describe ActiveTriples::List do
     it 'has correct number of elements' do
       expect(subject.length).to eq 3
     end
-    
+
     context 'after clear' do
       before do
         subject.clear
@@ -247,7 +247,7 @@ END
           expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
           expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
           expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["1900s"]
-          expect(RDF::List.new(list.rdf_subject, subject.graph)).to be_valid
+          expect(RDF::List.new(list.rdf_subject, subject)).to be_valid
         end
 
         it "should be a valid list" do
@@ -255,9 +255,9 @@ END
           # TODO this is a workaround for https://github.com/projecthydra/active_fedora/issues/444
           # remove the following line when #444 is closed.
           list.resource.persist!
-          expect(RDF::List.new(list.rdf_subject, subject.graph)).to be_valid
+          expect(RDF::List.new(list.rdf_subject, subject)).to be_valid
         end
-      end  
+      end
     end
   end
 end

data/spec/active_triples/nested_attributes_spec.rb

@@ -85,7 +85,7 @@ describe "nesting attribute behavior" do
             personalName_attributes: [
               {
                 id: 'http://library.ucsd.edu/ark:20775/jefferson',
-                elementList_attributes: [{                         
+                elementList_attributes: [{
                   fullNameElement: "Jefferson, Thomas",
                   dateNameElement: "1743-1826"
                 }]
@@ -123,12 +123,12 @@ describe "nesting attribute behavior" do
           expect(subject.personalName.first.elementList.first.fullNameElement).to eq ["Jefferson, Thomas"]
           expect(subject.personalName.first.elementList.first.dateNameElement).to eq ["1743-1826"]
         end
-        
+
         it 'should build nodes with ids' do
           expect(subject.topic[0].elementList.first[0].rdf_subject).to eq 'http://library.ucsd.edu/ark:/20775/bb3333333x'
           expect(subject.personalName.first.rdf_subject).to eq  'http://library.ucsd.edu/ark:20775/jefferson'
         end
-        
+
         it 'should fail when writing to a non-predicate' do
           attributes = { topic_attributes: { '0' => { elementList_attributes: [{ topicElement_attributes: [{ fake_predicate:"Cosmology" }] }]}}}
           expect{ subject.attributes = attributes }.to raise_error ArgumentError

data/spec/active_triples/properties_spec.rb

@@ -2,7 +2,8 @@ require "spec_helper"
 describe ActiveTriples::Properties do
   before do
     class DummyProperties
-      extend ActiveTriples::Properties
+      include ActiveTriples::Reflection
+      include ActiveTriples::Properties
     end
   end
 
@@ -13,29 +14,29 @@ describe ActiveTriples::Properties do
   describe '#property' do
     it 'should set a property' do
       DummyProperties.property :title, :predicate => RDF::DC.title
-      expect(DummyProperties.properties).to include :title
+      expect(DummyProperties.reflect_on_property(:title)).to be_kind_of ActiveTriples::NodeConfig
     end
 
     it 'should set index behaviors' do
       DummyProperties.property :title, :predicate => RDF::DC.title do |index|
         index.as :facetable, :searchable
       end
-      expect(DummyProperties.properties[:title][:behaviors]).to eq [:facetable, :searchable]
+      expect(DummyProperties.reflect_on_property(:title)[:behaviors]).to eq [:facetable, :searchable]
     end
 
     it 'should set class name' do
       DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => RDF::Literal
-      expect(DummyProperties.properties[:title][:class_name]).to eq RDF::Literal
+      expect(DummyProperties.reflect_on_property(:title)[:class_name]).to eq RDF::Literal
     end
 
     it "should constantize string class names" do
       DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => "RDF::Literal"
-      expect(DummyProperties.properties[:title][:class_name]).to eq RDF::Literal
+      expect(DummyProperties.reflect_on_property(:title)[:class_name]).to eq RDF::Literal
     end
 
     it "should keep strings which it can't constantize as strings" do
       DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => "FakeClassName"
-      expect(DummyProperties.properties[:title][:class_name]).to eq "FakeClassName"
+      expect(DummyProperties.reflect_on_property(:title)[:class_name]).to eq "FakeClassName"
     end
   end
 
@@ -52,7 +53,8 @@ describe ActiveTriples::Properties do
     end
 
     it 'should carry properties from superclass' do
-      expect(DummySubClass.properties.keys).to eq ["title", "source"]
+      expect(DummySubClass.reflect_on_property(:title)).to be_kind_of ActiveTriples::NodeConfig
+      expect(DummySubClass.reflect_on_property(:source)).to be_kind_of ActiveTriples::NodeConfig
     end
   end
 end

data/spec/active_triples/resource_spec.rb

@@ -202,7 +202,7 @@ describe ActiveTriples::Resource do
       end
     end
   end
-  
+
   describe 'class_name' do
     it 'should raise an error when not a class or string' do
       DummyResource.property :relation, :predicate => RDF::DC.relation, :class_name => RDF::URI('http://example.org')
@@ -210,14 +210,33 @@ describe ActiveTriples::Resource do
       d.relation = RDF::DC.type
       expect { d.relation.first }.to raise_error "class_name for relation is a RDF::URI; must be a class"
     end
-    
+
     it 'should return nil when none is given' do
-      expect(DummyResource.properties['title'][:class_name]).to be_nil
+      expect(DummyResource.reflect_on_property('title')[:class_name]).to be_nil
     end
+
   end
-  
+
+  context 'property configuration' do
+    it 'preserves previous #properties[] API but prefers #reflect_on_property' do
+      expect(DummyResource.reflect_on_property('title')).to eq(DummyResource.properties.fetch('title'))
+    end
+
+    it 'uses hash access on #properties to retrieve the configuration' do
+      expect(DummyResource.properties['title']).to be_a(ActiveTriples::NodeConfig)
+    end
+
+    it 'stores the properties configuration as a hash' do
+      expect(DummyResource.properties).to be_a(Hash)
+    end
+
+    it "uses reflection to retrieve a property's configuration" do
+      expect(DummyResource.reflect_on_property('title')).to be_a(ActiveTriples::NodeConfig)
+    end
+  end
+
   describe 'attributes' do
-    before do 
+    before do
       subject.license = license
       subject.title = 'moomi'
     end

data/spec/active_triples/term_spec.rb

@@ -4,7 +4,10 @@ require 'rdf/isomorphic'
 describe ActiveTriples::Term do
 
   describe "#rdf_subject" do
-    subject { described_class.new( double("parent"), double("value args") ) }
+    let(:parent_resource) { double("parent resource", reflections: {}) }
+
+    subject { described_class.new(parent_resource, double("value args") ) }
+
     context "when term has 0 value arguments" do
       before { subject.value_arguments = double(length: 0) }
       it "should raise an error" do
@@ -35,7 +38,7 @@ describe ActiveTriples::Term do
   end
 
   describe "#valid_datatype?" do
-    subject { described_class.new( double("parent"), "value" ) }
+    subject { described_class.new(double("parent", reflections: []), "value" ) }
     before { allow(subject.parent).to receive(:rdf_subject) { "parent subject" } }
     context "the value is not a Resource" do
       it "should be true if value is a String" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-triples
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Tom Johnson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -189,6 +189,8 @@ files:
 - lib/active_triples/nested_attributes.rb
 - lib/active_triples/node_config.rb
 - lib/active_triples/properties.rb
+- lib/active_triples/property_builder.rb
+- lib/active_triples/reflection.rb
 - lib/active_triples/repositories.rb
 - lib/active_triples/resource.rb
 - lib/active_triples/term.rb