gearbox 0.1.0 → 0.1.10

data/lib/gearbox/mixins/active_model_implementation.rb

@@ -0,0 +1,27 @@
+module Gearbox
+  
+  # I wanted to have all of my ActiveModel mixins in one place.
+  # I want to see how this is being used explicitly.
+  module ActiveModelImplementation
+    
+    def self.included(base)
+      base.send :include, ActiveModel::Validations
+      base.send :include, ActiveModel::Conversion
+
+      # This isn't right...so I need to research these things a little bit. 
+      # What I'm thinking is a RESTful API isn't too much to ask from Gearbox, 
+      # So I want these to produce JSON and XML in a consistent way...
+      # I may be wrong, but I may be getting the RDF::JSON version here instead.
+      base.send :include, ActiveModel::Serializers::JSON
+      base.send :include, ActiveModel::Serializers::Xml
+      
+      base.send :extend, ActiveModel::Naming
+    end
+    
+    # TODO Temporary!!! Remove after finishing the Mutable changes.
+    def persisted?
+      false
+    end
+    
+  end
+end

data/lib/gearbox/mixins/resource.rb

@@ -8,10 +8,26 @@ module Gearbox
     # ============
     # = Behavior =
     # ============
-    include AdHocProperties
-    include SemanticAccessors
-    include RDF::Mutable
-    include RDF::Queryable
+    def self.included(base)
+      # Rethinking this one, they will be much more robust soon.
+      # This is more for knowledge base discovery or throw-away models
+      # So there's a new approach on the horizon of my imagination.
+      # base.send :include, AdHocProperties
+      base.send :include, SubjectMethods
+      base.send :include, SemanticAccessors
+      base.send :include, ActiveModelImplementation
+      base.send :include, RDF::Mutable
+      base.send :include, RDF::Queryable
+    end
+    
+    # Depends on RDF::Queryable, SemanticAccessors and SubjectMethods
+    def each(opts={}, &block)
+      attribute_definitions.map{|name, attribute| attribute.to_rdf(self, opts)}.each(&block)
+    end
+    
+    def inspect
+      "#{self.class.name} #{self.attributes.inspect}"
+    end
     
   end
 end

data/lib/gearbox/mixins/semantic_accessors.rb

@@ -1,118 +1,157 @@
 module Gearbox
   
-  ##
-  # The attributes to add to a model.
-  # TODO: Add example from file.
-  ##
+  # These are the attributes and associations that the user adds to a model.
   module SemanticAccessors
 
-    # Treat this as a bundle of class methods and instance methods.
-    # @private
     def self.included(base)
       base.extend ClassMethods
       base.send :include, InstanceMethods
     end
 
-    ##
-    # Class methods for the model.
-    ##
     module ClassMethods
       
-      # Add an attribute or a field to a model.  Takes a field name.  
-      # Defines both a getter and a setter on the object.
-      # Requires a predicate option.  Options are:
-      # * :predicate => RDF::URI
-      # * :reverse => Boolean store as value, predicate, subject
-      # * :index => Boolean maintain a full-text search index on this attribute
-      # @param [String, Symbol] getter_name, the field that is being created.
-      # @param [Hash] options
-      def attribute(getter_name, options={})
-        
-        raise ArgumentError, "A predicate must be defined" unless options[:predicate]
-        
-        send(attributes_source)[getter_name] = options
-
-        # Define a getter on the object
-        define_method(getter_name) do
-          self.class.yield_attr(getter_name, self)
-        end
-
-        # Define a setter on the object
-        define_method("#{getter_name}=") do |value|
-          self.class.store_attr(getter_name, self, value)
-          # attribute = send(self.class.attributes_source)[getter_name]
-        end
-
+      def attributes
+        @attributes ||= {}
       end
       
-      # Sets the attributes_source, where to store the attributes
-      attr_writer :attributes_source
-      
-      # Gets the attributes_source...
-      def attributes_source
-        @attributes_source ||= :attribute_collection
-      end
+      def attribute(name, opts={})
+        opts = opts.merge(:name => name)
 
-      def attribute_collection
-        @attribute_collection ||= AttributeCollection.new
-      end
-      
-      def yield_attr(getter_name, instance)
-        if statement = instance.rdf_collection[getter_name]
-          # TODO: Deserialize object
-          return statement.object.to_s
-        else
-          attribute_options = send(attributes_source)[getter_name]
-          attribute_options ? attribute_options.default : nil
+        define_method(name) do
+          attribute_definitions[name] ||= Attribute.new(opts)
+          attribute_definitions[name].to_value
+        end
+        
+        define_method("#{name}=") do |value|
+          attribute_definitions[name] ||= Attribute.new(opts)
+          attribute_definitions[name].set(value)
         end
-      end
-      
-      def store_attr(getter_name, instance, value)
-        attribute_options = send(attributes_source)[getter_name]
-        # TODO: serialize value
-        statement = RDF::Statement.new(instance.subject, attribute_options.predicate, value)
-        instance.rdf_collection[getter_name] = statement
-      end
 
+        attributes[name] = opts
+      end
     end
     
     module InstanceMethods
-      # We collect triples inside the models in order to query them, filter them
-      # and handle the bridge between domain models and the graph we're building.
-      def rdf_collection
-        @rdf_collection ||= RDFCollection.new
-      end
-      
-      def subject
-        "1"
+
+      def initialize(opts={})
+        super
+        assert_defaults
+        assert_options(opts)
       end
       
-      # An initialization strategy for all occasions.
-      def initialize(obj=nil)
-        case obj
-        when Hash
-          merge_hash_values(obj)
-        when RDFCollection
-          merge_rdf_collection(obj)
+      def attributes
+        self.class.attributes.inject({:id => id}) do |hash, (name, opts)|
+          hash[name] = send(name)
+          hash
         end
       end
       
       private
       
-        def merge_hash_values(hash)
-          # TODO: work with associations here...
-          hash.each do |getter_name, value|
-            setter_name = "#{getter_name}="
-            send(setter_name, value) if respond_to?(setter_name)
-            # What to do with the others?
-          end
+      def assert_defaults
+        self.class.attributes.each do |name, opts|
+          next unless opts.has_key?(:default)
+          setter = "#{name}="
+          send(setter, opts[:default])
         end
-        
-        def merge_rdf_collection(collection)
-          rdf_collection.merge!(collection)
+      end
+      
+      def assert_options(opts)
+        opts.each do |name, value|
+          setter = "#{name}="
+          send(setter, value) if respond_to?(setter)
         end
+      end
+
+      def attribute_definitions
+        @attribute_definitions ||= {}
+      end
       
-    end # InstanceMethods
-    
-  end # SemanticAccessors
-end # Gearbox
+    end
+  end
+end
+
+
+
+# class Z
+#   
+#   # ============
+#   # = Behavior =
+#   # ============
+#   include RDF::Queryable
+#   include ActiveModel::Validations
+#   include ActiveModel::Conversion
+#   extend ActiveModel::Naming
+#   
+#   def self.attribute(name, opts={})
+#     
+#     opts = opts.merge(:name => name)
+#     
+#     define_method(name) do
+#       attribute_definitions[name] ||= Attribute.new(opts)
+#       attribute_definitions[name].to_value
+#     end
+#     
+#     define_method("#{name}=") do |value|
+#       attribute_definitions[name] ||= Attribute.new(opts)
+#       attribute_definitions[name].set(value)
+#     end
+#     
+#     attributes[name] = opts
+#   end
+#   
+#   def self.attributes
+#     @attributes ||= {}
+#   end
+#   
+#   attribute :name, :predicate => RDF::FOAF.name
+#   attribute :email, :predicate => RDF::FOAF.mbox
+#   
+#   def initialize(opts={})
+#     assert_defaults
+#     assert_options(opts)
+#   end
+#   
+#   def id
+#     @id ||= object_id
+#   end
+#   attr_writer :id
+#   
+#   def subject
+#     "http://example.com/z/#{id}"
+#   end
+#   
+#   def attributes
+#     self.class.attributes.inject({:id => id}) do |hash, (name, opts)|
+#       hash[name] = send(name)
+#       hash
+#     end
+#   end
+#   
+#   def each(opts={}, &block)
+#     attribute_definitions.map{|name, attribute| attribute.to_rdf(self, opts)}.each(&block)
+#   end
+#   
+#   def inspect
+#     "Z: #{name}"
+#   end
+#   
+#   def persisted?
+#     false
+#   end
+#   
+#   private
+#   
+#   def assert_defaults
+#   end
+# 
+#   def assert_options(opts)
+#     opts.each do |accessor, value|
+#       send("#{accessor}=", value) if respond_to?("#{accessor}=")
+#     end
+#   end
+# 
+#   def attribute_definitions
+#     @attribute_definitions ||= {}
+#   end
+# end

data/lib/gearbox/mixins/subject_methods.rb

@@ -0,0 +1,88 @@
+module Gearbox
+  module SubjectMethods
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+      def base_uri(value=:_value_not_set)
+        @base_uri = value unless value == :_value_not_set
+        @base_uri
+      end
+      
+      def id_method(value=:_value_not_set)
+        @id_method = value unless value == :_value_not_set
+        @id_method ||= :object_id
+      end
+      
+      def subject_decorator(value=:_value_not_set)
+        @subject_decorator = value unless value == :_value_not_set
+        @subject_decorator
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      attr_accessor :base_uri
+      
+      def initialize(opts={})
+        super
+        set_attributes_from_configuration_or_opts(opts, :base_uri, :id_method, :id, :subject_decorator)
+      end
+      
+      def id
+        return @id if @id
+        send(id_method)
+      end
+      attr_writer :id
+    
+      # Gives us the ability to derive an id from other sources or patterns.
+      # Based on the identifier patterns: http://patterns.dataincubator.org/book/
+      attr_accessor :id_method
+      
+      # Allows patterns to be used to define the subject.
+      attr_accessor :subject_decorator
+      
+      # subject_decorator -> internal method -> subject
+      # subject_decorator -> lambda -> subject
+      # (base_uri + (id_method -> id)) -> subject
+      # There are several ways to create the subject.  First, the subject_decorator
+      # will use whatever instance values that are set to build a pattern.
+      # Second, the base_uri and id are combined to create the subject.  
+      # Note, the id can be set directly, or set with the id_method, so UUID, 
+      # or an external source, or a slug generating method can be used to generate
+      # an id.
+      def subject
+        if subject_decorator
+          derive_subject_from_decorator
+        else
+          derive_subject_from_base_uri_and_id
+        end
+      end
+      
+      private
+      
+      def derive_subject_from_decorator
+        subject_decorator.respond_to?(:call) ? subject_decorator.call(self)
+                                             : self.send(subject_decorator)
+      end
+      
+      def derive_subject_from_base_uri_and_id
+        File.join(base_uri.to_s, id.to_s)
+      end
+      
+      def set_attributes_from_configuration_or_opts(opts, *attributes)
+        attributes.each do |attribute|
+          variable_name = "@#{attribute}"
+          instance_variable_set(variable_name, self.class.send(attribute)) if self.class.respond_to?(attribute)
+          instance_variable_set(variable_name, opts[attribute]) if opts.has_key?(attribute)
+        end
+      end
+    end
+
+    
+  end
+end

data/lib/gearbox/rdf_collection.rb

@@ -9,7 +9,7 @@ module Gearbox
     # ============
     # = Behavior =
     # ============
-    include RDF::Enumerable
+    include RDF::Queryable
     
     def initialize
       @source = {}
@@ -21,18 +21,23 @@ module Gearbox
     # @param [Block] block Optional block.  Creates an external iterator if omitted.
     # @return [nil, Enumerator] Returns either nil, or an external iterator.
     def each(&block)
-      if block_given?
-        @source.each(&block)
-      else
-        Enumerator.new(self, :each)
-      end
+      local_repository.each(&block)
+    end
+    
+    def each_with_field_names(&block)
+      @source.each(&block)
     end
     
+    attr_accessor :source
+    
     # Set RDF::Statements to the underlying collection.  Normalizes the keys.
     # @param [String, Symbol] key
     # @param [RDF::Statement] obj.  RDF::Statement that will be added.
     def add_statement(key, obj)
-      @source[normalize_key(key)] = obj if obj.is_a?(RDF::Statement)
+      if obj.is_a?(RDF::Statement)
+        @source[normalize_key(key)] = obj 
+        local_repository << obj
+      end
     end
     alias :[]= :add_statement
     
@@ -57,7 +62,16 @@ module Gearbox
     # @param [Hash] hash.  Collection of statements.
     # @return [nil]
     def merge!(hash)
-      hash.each {|key, obj| add_statement(key, obj)}
+      hash.each_with_field_names {|key, obj| add_statement(key, obj)}
+    end
+    
+    attr_writer :local_repository
+    def local_repository
+      @local_repository ||= RDF::Repository.new
+    end
+    
+    def query(string)
+      SPARQL.execute(string, local_repository)
     end
     
     private