architect4r 0.3.2

data/lib/architect4r/generic_node.rb

@@ -0,0 +1,7 @@
+module Architect4r
+  
+  class GenericNode < Model::Node
+    
+  end
+  
+end

data/lib/architect4r/has_node.rb

@@ -0,0 +1,80 @@
+module Architect4r
+  
+  # has_node :node, AccountNode, :sync => [:firstname, :lastname]
+  module HasNode
+    
+    # Easier integration pattern
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      
+      def has_node(attr_name, model_name, options={})
+        
+        #if self.respond_to?(:after_create)
+          after_create :"architect4r_create_#{attr_name}"
+          after_update :"architect4r_sync_#{attr_name}"
+          after_destroy :"architect4r_destroy_#{attr_name}"
+        #end
+        
+        # Create a neo4j node
+        define_method("architect4r_create_#{attr_name}") do
+          return nil unless self.id
+          
+          new_node = model_name.new
+          new_node.write_attribute(:architect4r_sync_id, self.id)
+          
+          options[:sync].to_a.each do |prop|
+            new_node.send("#{prop}=", self.send(prop))
+          end
+          
+          if new_node.save
+            new_node
+          else
+            nil
+          end
+          instance_variable_set("@#{attr_name}", new_node)
+        end
+        
+        # Create a getter method
+        define_method(attr_name) do
+          # Only available if the database record is already created
+          return nil unless self.id
+          
+          # Get or create the graph db node
+          the_node = instance_variable_get("@#{attr_name}")
+          the_node ||= begin
+            linked_node = model_name.find_by_cypher("start s=node(#{model_name.model_root.id}) match s<-[:model_type]-d where d.architect4r_sync_id = #{self.id} return d", "d").first
+            linked_node ||= self.send("architect4r_create_#{attr_name}")
+            instance_variable_set("@#{attr_name}", linked_node)
+          end
+        end
+        
+        define_method("architect4r_destroy_#{attr_name}") do
+          self.send("#{attr_name}").destroy
+        end
+        
+        
+        # Keep the graph node in sync, so it reflects the name
+        #
+        define_method("architect4r_sync_#{attr_name}") do
+          changed = false
+          
+          options[:sync].to_a.each do |prop|
+            if self.node.send("#{prop}") != self.send(prop)
+              self.node.send("#{prop}=", self.send(prop))
+              changed = true
+            end
+          end
+          
+          if changed
+            self.node.save
+          end
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/architect4r/instance_manager.rb

@@ -0,0 +1,47 @@
+module Architect4r
+  class InstanceManager
+    
+    def initialize(path)
+      @path = path
+    end
+    
+    def server_path
+      @path
+    end
+    
+    def start
+      %x[#{server_path}/bin/neo4j start]
+    end
+    
+    def stop
+      %x[#{server_path}/bin/neo4j stop]
+    end
+    
+    def restart
+      %x[#{server_path}/bin/neo4j restart]
+    end
+    
+    def reset
+      self.stop
+      
+      # Reset the database
+      FileUtils.rm_rf("#{server_path}/data/graph.db")
+      FileUtils.mkdir("#{server_path}/data/graph.db")
+      
+      # Remove log files
+      FileUtils.rm_rf("#{server_path}/data/log")
+      FileUtils.mkdir("#{server_path}/data/log")
+      
+      # Start the server
+      self.start
+    end
+    
+    def reset_to_sample_data(from)
+      self.stop
+      FileUtils.rm_rf("#{server_path}/data/graph.db")
+      FileUtils.cp_r(from, "#{server_path}/data/graph.db/")
+      self.start
+    end
+    
+  end
+end

data/lib/architect4r/model/callbacks.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Architect4r
+  module Model
+
+    module Callbacks
+      extend ActiveSupport::Concern
+      
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations::Callbacks
+        
+        define_model_callbacks :initialize, :only => :after
+        define_model_callbacks :create, :destroy, :save, :update
+      end
+    end
+    
+  end
+end

data/lib/architect4r/model/connection.rb

@@ -0,0 +1,29 @@
+module Architect4r
+  module Model
+    module Connection
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+      
+        def connection
+          self.class.connection
+        end
+        
+      end
+      
+      module ClassMethods
+        
+        def use_server(server)
+          @connection = server
+        end
+        
+        def connection
+          # TODO: apply configuration
+          @connection || Server.new
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/architect4r/model/links_query_interface.rb

@@ -0,0 +1,23 @@
+module Architect4r
+  module Model
+    class LinksQueryInterface
+      
+      def initialize(owner)
+        @owner = owner
+      end
+      
+      def incoming
+        
+      end
+      
+      def outgoing
+        
+      end
+      
+      def both
+        
+      end
+      
+    end
+  end
+end

data/lib/architect4r/model/node.rb

@@ -0,0 +1,117 @@
+module Architect4r
+  
+  module Model
+    
+    class Node
+      
+      #
+      # architect4r extensions
+      #
+      include Architect4r::Model::Connection
+      include Architect4r::Model::Callbacks
+      include Architect4r::Model::Persistency
+      include Architect4r::Model::Queries
+      include Architect4r::Model::Relationships
+      
+      def self.inherited(subklass)
+        super
+        subklass.send(:include, ActiveModel::Conversion)
+        subklass.extend ActiveModel::Naming
+        subklass.send(:include, Architect4r::Model::Properties)
+        subklass.send(:include, Architect4r::Model::Validations)
+        
+        subklass.class_exec do
+          
+          def self.model_root
+            @model_root ||= begin
+              # Check if there is already a model root,
+              query = "start root = node(0) match (root)-[r:#{  model_root_relation_type}]->(x) where r.architect4r_type and r.architect4r_type = '#{name}' return x"
+              the_root = connection.execute_cypher(query).to_a.first
+              the_root &&= the_root['x']
+              
+              # otherwise create one
+              the_root ||= begin 
+                m_root = connection.create_node(:name => "#{name} Root")
+                connection.create_relationship(0, m_root, model_root_relation_type, { 'architect4r_type' => name })
+                m_root
+              end
+              
+              # Return model root node
+              GenericNode.send(:build_from_database, the_root)
+            end
+          end
+          
+        end
+      end
+      
+      attr_accessor :raw_data
+      
+      def initialize(properties={})
+        run_callbacks :initialize do
+          parse_properties(properties)
+        end
+      end
+      
+      # Create the document. Validation is enabled by default and will return
+      # false if the document is not valid. If all goes well, the document will
+      # be returned.
+      def create(options = {})
+        run_callbacks :create do
+          run_callbacks :save do
+            # only create valid records
+            return false unless perform_validations(options)
+        
+            # perform creation
+            if result = connection.create_node(self._to_database_hash)
+              self.raw_data = result
+          
+              # Link the node with a model root node
+              connection.create_relationship(self.id, self.class.model_root.id, 'model_type')
+            end
+        
+            # if something goes wrong we receive a nil value and return false
+            !result.nil?
+          end
+        end
+      end
+      
+      # Trigger the callbacks (before, after, around)
+      # only if the document isn't new
+      def update(options = {})
+        run_callbacks :update do
+          run_callbacks :save do
+            # Check if record can be updated
+            raise "Cannot save a destroyed document!" if destroyed?
+            raise "Calling #{self.class.name}#update on document that has not been created!" if new?
+        
+            # Check if we can continue
+            return false unless perform_validations(options)
+        
+            # perform update
+            result = connection.update_node(self.id, self._to_database_hash)
+        
+            # if something goes wrong we receive a nil value and return false
+            !result.nil?
+          end
+        end
+      end
+      
+      def destroy
+        run_callbacks :destroy do
+          if result = connection.delete_node(self.id)
+            @_destroyed = true
+            self.freeze
+          end
+          result
+        end
+      end
+      
+      def self.model_root_relation_type
+        'model_root'
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/architect4r/model/persistency.rb

@@ -0,0 +1,95 @@
+module Architect4r
+  module Model
+    module Persistency
+      extend ActiveSupport::Concern
+      
+      included do
+        
+      end
+      
+      module InstanceMethods
+        
+        # Creates the document in the db. Raises an exception
+        # if the document is not created properly.
+        def create!(options = {})
+          self.fail_validate!(self) unless self.create(options)
+        end
+        
+        def save(options = {})
+          self.new? ? create(options) : update(options)
+        end
+
+        def save!
+          self.class.fail_validate!(self) unless self.save
+          true
+        end
+        
+        def id
+          @id ||= if raw_data && raw_data['self'].present?
+            raw_data['self'].split('/').last.to_i
+          else
+            nil
+          end
+        end
+        alias :to_key :id
+        alias :to_param :id
+
+        def new?
+          # Persisted objects always have an id.
+          id.nil?
+        end
+        alias :new_record? :new?
+
+        def destroyed?
+          !!@_destroyed
+        end
+
+        def persisted?
+          !new? && !destroyed?
+        end
+
+        # Update the document's attributes and save. For example:
+        def update_attributes(hash)
+          update_attributes_without_saving hash
+          save
+        end
+
+        protected
+
+        def perform_validations(options = {})
+          (options[:validate].presence || true) ? valid? : true
+        end
+        
+      end
+      
+      module ClassMethods
+        
+        def create(*args, &block)
+          instance = new(*args, &block)
+          instance.create
+          instance
+        end
+        
+        # Defines an instance and save it directly to the database
+        def create!(*args, &block)
+          instance = new(*args, &block)
+          instance.create!
+          instance
+        end
+        
+        protected
+        
+        # Create an object from the database data
+        def build_from_database(data)
+          return nil if data.blank?
+          
+          # Create an instance of the object
+          obj = self.new(data['data'])
+          obj.raw_data = data
+          obj
+        end
+        
+      end
+    end
+  end
+end

data/lib/architect4r/model/properties.rb

@@ -0,0 +1,166 @@
+module Architect4r
+  
+  module Model
+    
+    module Properties
+      extend ActiveSupport::Concern
+      
+      included do
+        class_attribute(:properties) unless respond_to?(:properties)
+        self.properties ||= {}
+      end
+      
+      module InstanceMethods
+        def parse_properties(properties = {})
+          @properties_data = {}
+          update_attributes_without_saving(properties)
+        end
+        
+        # Return a hash of all properties which can be transformed into json
+        # Remove all nil values, as those cannot be stored in the graph
+        def _to_database_hash
+          @properties_data.merge('architect4r_type' => self.class.name).
+                           reject { |key, value| value.nil? }
+        end
+
+        # Read the casted value of an attribute defined with a property.
+        #
+        # ==== Returns
+        # Object:: the casted attibutes value.
+        def read_attribute(property, locale = nil)
+          property = "#{property}_#{locale}" if locale
+          @properties_data[property.to_s]
+        end
+
+        # Store a casted value in the current instance of an attribute defined
+        # with a property and update dirty status
+        def write_attribute(property, value, locale = nil)
+          # retrieve options for the attribute
+          opts = self.class.properties[property.to_s]
+          
+          # Check if we should store a localized version of the data
+          property = "#{property}_#{locale}" if locale
+          
+          # TODO: Mark dirty attribute tracking
+          
+          # Cast the value before storing it
+          cast_to = opts && opts[:cast_to] || Object
+          
+          @properties_data[property.to_s] = if value.nil?
+            nil
+          elsif cast_to == String
+            value.to_s
+          elsif cast_to == Integer
+            value.to_i
+          elsif cast_to == Float
+            value.to_f
+          elsif cast_to == TrueClass or cast_to == FalseClass
+            if value.kind_of?(Integer)
+              value == 1
+            else
+              %w[ true 1 t ].include?(value.to_s.downcase)
+            end
+          else
+            value
+          end
+        end
+        
+        def update_attributes_without_saving(hash)
+          return if hash.nil?
+          hash.each do |key, value|
+            if self.respond_to?("#{key}=")
+              self.send("#{key}=", value)
+            else
+              @properties_data[key] = value
+            end
+          end
+        end
+        alias :attributes= :update_attributes_without_saving
+        
+        
+      end
+      
+      module ClassMethods
+        
+        # Allow setting properties
+        def property(name, options = {})
+          unless self.properties.keys.find { |p| p == name.to_s }
+            define_property(name, options)
+          end
+        end
+        
+        def timestamps!
+          property(:updated_at, :cast_to => Time)
+          property(:created_at, :cast_to => Time)
+          
+          set_callback :save, :before do |object|
+            write_attribute('updated_at', Time.now)
+            write_attribute('created_at', Time.now) if object.new?
+          end
+        end
+        
+        protected
+        
+        # This is not a thread safe operation, if you have to set new properties at runtime
+        # make sure a mutex is used.
+        def define_property(name, options={})
+          # read only flag
+          read_only = options.delete(:read_only) || false
+          
+          # Store the property and its options
+          self.properties[name.to_s] = options
+          
+          # Create getter and setter methods
+          create_property_getter(name)
+          create_property_setter(name) unless read_only == true
+          
+          # Return property name just in case ;)
+          name
+        end
+        
+        # defines the getter for the property (and optional aliases)
+        def create_property_getter(name)
+          define_method(name) do
+            # Get property configuration
+            localize = self.class.properties[name.to_s][:localize]
+            
+            # Determine current locale
+            locale = localize ? I18n.locale : nil
+            
+            # Fetch property value
+            result = read_attribute(name, locale)
+            
+            # If there is a fallback locale, fetch its value if appropriate
+            if result.nil? && localize && localize != true && localize.to_s != locale.to_s
+              result = read_attribute(name, localize)
+            end
+            
+            # Finally return some data
+            result
+          end
+          
+          opts = self.properties[name.to_s]
+          
+          if opts[:cast_to].presence && opts[:cast_to] == TrueClass
+            define_method("#{name}?") do
+              value = read_attribute(name)
+              !(value.nil? || value == false)
+            end
+          end
+        end
+        
+        # defines the setter for the property (and optional aliases)
+        def create_property_setter(name)
+          define_method("#{name}=") do |value|
+            locale = self.class.properties[name.to_s][:localize] ? I18n.locale : nil
+            write_attribute(name, value, locale)
+          end
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end