neo4j-meta_model 0.0.1 → 0.1.0

data/app/controllers/neo4j/meta_model/meta/properties_controller.rb

@@ -0,0 +1,38 @@
+module Neo4j
+  module MetaModel
+    module Meta
+      class PropertiesController < ApplicationController
+        before_action :get_property, only: [:edit, :show, :update, :destroy]
+
+        def destroy
+          @property.destroy
+
+          render json: nil
+        end
+
+        def create
+          property = Property.create(property_params)
+
+          render json: property
+        end
+
+        def update
+          @property.update_attributes(property_params)
+
+          render json: @property
+        end
+
+        private
+
+        def get_property
+          @property = Property.find(params[:id])
+        end
+
+        def property_params
+          model = params[:property].delete(:model_id)
+          params.require(:property).permit(:name, :type).merge(model: model)
+        end
+      end
+    end
+  end
+end

data/app/controllers/neo4j/meta_model/meta_controller.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module MetaModel
+    class MetaController < ApplicationController
+      def index
+
+      end
+    end
+  end
+end

data/app/controllers/neo4j/meta_model/models_controller.rb

@@ -0,0 +1,71 @@
+module Neo4j
+  module MetaModel
+    class ModelsController < ApplicationController
+      before_action :get_model
+      before_action :get_meta_model
+      before_action :get_record, only: [:show, :edit, :update]
+
+      layout 'layouts/meta_model'
+      def meta_index
+        @hierarchy = Model.order(:class_name).hierarchically
+      end
+
+      def index
+        @records = @model.all.to_a
+        respond_to do |format|
+          format.html
+          format.json { render json: @records, root: :records }
+        end
+      end
+
+      def show
+      end
+
+      def edit
+      end
+
+      def update
+        @record.update_attributes(params[:data])
+
+        redirect_to action: :show
+      end
+
+      def new
+        @record = @model.new
+      end
+
+      def create
+        record = @model.create(params[:data])
+
+        redirect_to action: :show, id: record.id
+      end
+
+      def destroy
+        @record.destroy
+
+        redirect_to action: :index, model: params[:model]
+      end
+
+      private
+
+      def get_record
+        @record = @model.find(params[:id])
+      end
+
+      def get_meta_model
+        @meta_model = Model.where(class_name: model_param_class_name).first if model_param_class_name
+      end
+
+      def get_model
+        @model = "Neo4j::MetaModel::#{model_param_class_name}".constantize if model_param_class_name
+      end
+
+      def model_param_class_name
+        if params[:model]
+          @model_param_class_name ||= params[:model].classify
+        end
+      end
+    end
+
+  end
+end

data/app/helpers/neo4j/meta_model/application_helper.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module MetaModel
+    module ApplicationHelper
+      def action_and_controller_javascript_include_tag
+        capture do
+          concat javascript_include_tag controller_path if Rails.root.join("app/assets/javascripts/#{controller_path}.js.coffee").exist?
+          concat javascript_include_tag "#{controller_path}/#{action_name}" if Rails.root.join("app/assets/javascripts/#{controller_path}/#{action_name}.js.coffee").exist?
+        end
+      end
+    end
+  end
+end

data/app/helpers/neo4j/meta_model/model_helper.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module MetaModel
+    module ModelHelper
+      def hierarchical_render(hierarchy, level = 0, &block)
+        hierarchy.each do |object, sub_hierarchy|
+          block.call object, level
+          hierarchical_render(sub_hierarchy, level + 1, &block)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/neo4j/meta_model/model_base.rb

@@ -0,0 +1,45 @@
+module Neo4j
+  module MetaModel
+    module ModelBase
+      extend ActiveSupport::Concern
+
+      LOADED_CLASSES = []
+      included do |base|
+        LOADED_CLASSES << self
+      end
+
+      module ClassMethods
+        def inherited(base)
+          LOADED_CLASSES << base
+        end
+
+        def meta_model_class
+          name.gsub(/^Neo4j::MetaModel::/, '')
+        end
+
+        def naming_column
+          # Probably want to allow the user to choose this
+          Neo4j::MetaModel::Model.where(class_name: meta_model_class).first.properties.detect {|p| p.type == 'String' }.name
+        end
+      end
+
+      def naming_column_value
+        self.read_attribute(self.class.naming_column)
+      end
+
+      def meta_model_class
+        self.class.meta_model_class
+      end
+
+      def association_values
+        self.class.associations.each_with_object({}) do |(key, _), result|
+          result[key] = self.send(key)
+        end
+      end
+
+      def _description
+        self.try(:name) || self.try(:title) || self.try(:description) || self.id
+      end
+    end
+  end
+end

data/app/models/neo4j/meta_model/has_association.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module MetaModel
+    class HasAssociation
+      include Neo4j::ActiveRel
+
+      from_class 'Neo4j::MetaModel::Model'
+      to_class 'Neo4j::MetaModel::Model'
+      type 'has_association_to'
+
+
+      # one_to_many refers to from_class has_many to_classes
+      # many_to_one refers to from_class has_one  to_class
+      property :join_type, type: String
+      validates_inclusion_of :join_type, :in => %w( many_to_one one_to_many many_to_many )
+
+      # Name of associations on each side
+      property :name, type: String
+      property :opposite_name, type: String
+
+      property :relationship_type, type: String
+
+      def from_model
+        from_node
+      end
+
+      def to_model
+        to_node
+      end
+
+      def from_model=(other)
+        self.from_node = other
+      end
+
+      def to_model=(other)
+        self.to_node = other
+      end
+
+      def from_model_id=(id)
+        self.from_model = Model.find(id)
+      end
+
+      def to_model_id=(id)
+        self.to_model = Model.find(id)
+      end
+
+    end
+  end
+end

data/app/models/neo4j/meta_model/meta_model_base.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module MetaModel
+    class MetaModelBase
+      include Neo4j::ActiveNode
+      include ActiveModel::Serialization
+
+    end
+  end
+end

data/app/models/neo4j/meta_model/model.rb

@@ -0,0 +1,53 @@
+module Neo4j
+  module MetaModel
+    class Model < MetaModelBase
+      property :class_name, type: String
+
+      has_one :out, :superclass_model, type: :inherits_from, model_class: 'Neo4j::MetaModel::Model'
+
+      has_one :out, :id_property, type: :has_id_property, model_class: 'Neo4j::MetaModel::Property'
+      has_many :out, :properties, type: :has_property, model_class: 'Neo4j::MetaModel::Property'
+
+      has_many :both, :assocs, model_class: 'Neo4j::MetaModel::Model', rel_class: 'Neo4j::MetaModel::HasAssociation'
+
+      before_destroy :destroy_properties
+
+      def to_param
+        self.class_name.tableize
+      end
+
+    #  def property_ids
+    #    properties(:p).pluck(p: :uuid)
+    #  end
+
+      def has_associations
+        assocs.each_rel.to_a
+      end
+
+      def self.hierarchically
+        Hash.new.tap do |result|
+          model_parents = Hash[*all.query_as(:model).optional_match("model-[:inherits_from]->(parent)").pluck(:model, :parent).flatten]
+
+          all.query_as(:model).where('NOT(model-[:inherits_from]->())').pluck(:model).each do |model|
+            result[model] = {}
+          end
+
+          all.query_as(:model).match('p=model-[:inherits_from*1..]->()').pluck('nodes(p)').each do |path|
+            path.reverse.inject(result) do |sub_result, model|
+              sub_result[model] ||= {}
+              sub_result[model]
+            end
+          end
+
+        end
+      end
+
+      private
+
+      def destroy_properties
+        properties.each(&:destroy)
+        id_property.try(:destroy)
+      end
+    end
+  end
+end

data/app/models/neo4j/meta_model/property.rb

@@ -0,0 +1,13 @@
+module Neo4j
+  module MetaModel
+    class Property < MetaModelBase
+      property :name, type: String
+      property :type, type: String
+
+      validates_inclusion_of :type, :in => %w( String DateTime Boolean Integer )
+
+      has_one :in, :model, origin: :properties, model_class: 'Neo4j::MetaModel::Model'
+
+    end
+  end
+end

data/app/serializers/neo4j/meta_model/has_association_serializer.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module MetaModel
+    class HasAssociationSerializer < ActiveModel::Serializer
+      attributes :id, :join_type, :name, :opposite_name, :relationship_type, :from_model, :to_model
+
+      def from_model
+        object.from_node.id
+      end
+
+      def to_model
+        object.to_node.id
+      end
+    end
+  end
+end

data/app/serializers/neo4j/meta_model/model_serializer.rb

@@ -0,0 +1,13 @@
+module Neo4j
+  module MetaModel
+    class ModelSerializer < ActiveModel::Serializer
+      attributes :id, :class_name
+
+  #    embed :ids, include: true
+
+      has_many :properties
+      has_many :has_associations
+    #  has_one :superclass_model
+    end
+  end
+end

data/app/serializers/neo4j/meta_model/property_serializer.rb

@@ -0,0 +1,8 @@
+module Neo4j
+  module MetaModel
+    class PropertySerializer < ActiveModel::Serializer
+      attributes :id, :name, :type
+    end
+  end
+
+end

data/app/views/{meta_model → neo4j/meta_model}/models/_form.html.slim

@@ -9,15 +9,17 @@
     .col-sm-10
       - case association.type
       - when :has_one
-        = select_tag "data[#{key}]", options_from_collection_for_select(association.target_class.all.to_a, :id, :naming_column_value, record.send(key).id), class: 'form-control'
+        = select_tag "data[#{key}]", options_from_collection_for_select(association.target_class.all.to_a, :id, :naming_column_value, record.send(key).try(:id)), include_blank: 'Select one from the options below', class: 'form-control'
       - when :has_many
         .has-many-association data-option-type="#{association.target_class.meta_model_class.tableize.singularize}" data-options="#{association.target_class.all.to_json(methods: :naming_column_value)}"
           select.form-control rv-on-change="view.add"
-            option Please select
+            option Select from the options below to add to the list
             option rv-each-option="view.current_options < objects" rv-value="option.id"
               | { option.naming_column_value }
 
-          .list-group
+          .help-block Click to remove an item from the list
+
+          .list-group data-object-ids="#{record.send(key).map(&:id).to_json}"
             a.list-group-item rv-each-object="objects < objects" rv-data-id="object.id" rv-on-click="view.delete"
               input type="hidden" name="data[#{key}][]" rv-value="object.id"
               | { object.naming_column_value }
@@ -31,11 +33,18 @@ coffee:
 
     initialize: ->
       el = $(@el)
-      @options = _(el.data('options')).map((element) ->
-        element[el.data('option-type')]
-      ).value()
 
-      @objects = [@options[0]]
+      @objects = []
+      object_ids = el.find('.list-group').data('object-ids')
+
+      @options = _(el.data('options')).map((element) =>
+        e = element[el.data('option-type')]
+
+        if e.id in object_ids
+          @objects.push e
+
+        e
+      ).value()
 
     render: ->
       @binding = rivets.bind $(@el), {@objects, view: @}
@@ -46,7 +55,6 @@ coffee:
       @binding.unbind()
 
     current_options: =>
-      console.log('current_options!');
       _(@options).difference(@objects).value()
 
 

data/config/routes.rb

@@ -1,4 +1,4 @@
-MetaModel::Engine.routes.draw do
+Neo4j::MetaModel::Engine.routes.draw do
   namespace :meta do
     resources :models do
       collection do

data/lib/meta_models.rb

@@ -1,9 +1,9 @@
 require 'ext/hash.rb'
 
 def create_models
-  models = MetaModel::Model.hierarchically.to_a_recursive.flatten
+  models = Neo4j::MetaModel::Model.hierarchically.to_a_recursive.flatten
 
-  MetaModel::ModelBase::LOADED_CLASSES.each do |loaded_class|
+  Neo4j::MetaModel::ModelBase::LOADED_CLASSES.each do |loaded_class|
     loaded_namespace, loaded_class = loaded_class.name.to_s.reverse.split('::', 2).reverse.map(&:reverse)
 
     namespace = loaded_namespace.blank? ? Object : loaded_namespace.constantize
@@ -11,12 +11,13 @@ def create_models
     namespace.send(:remove_const, loaded_class.to_sym)
   end
 
-  MetaModel::ModelBase::LOADED_CLASSES.clear
+  Neo4j::MetaModel::ModelBase::LOADED_CLASSES.clear
 
   models.each do |model|
-    code = "module MetaModel\n"
+    code = "module Neo4j\n"
+    code << "module MetaModel\n"
     code << "class #{model.class_name}"
-    code << " < MetaModel::#{model.superclass_model.class_name}" if model.superclass_model
+    code << " < Neo4j::MetaModel::#{model.superclass_model.class_name}" if model.superclass_model
     code << "\n"
 
     code << "  include Neo4j::ActiveNode\n"
@@ -31,7 +32,7 @@ def create_models
     model.assocs.each_with_rel do |other_model, rel|
       # Primary association
       if rel.from_node.class_name == model.class_name
-        options = {type: rel.relationship_type, model_class: 'MetaModel::' + other_model.class_name}
+        options = {type: rel.relationship_type, model_class: 'Neo4j::MetaModel::' + other_model.class_name}
 
         has_type = case rel.join_type
                     when 'many_to_many', 'many_to_one'
@@ -45,7 +46,7 @@ def create_models
 
       # Reverse association
       if rel.to_node.class_name == model.class_name
-        options = {model_class: 'MetaModel::' + other_model.class_name, origin: rel.name}
+        options = {model_class: 'Neo4j::MetaModel::' + other_model.class_name, origin: rel.name}
 
         has_type = case rel.join_type
                     when 'many_to_many', 'one_to_many'
@@ -59,6 +60,7 @@ def create_models
 
     end
 
+    code << "end\n"
     code << "end\n"
     code << "end"