neo4j-meta_model 0.0.1

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

@@ -0,0 +1,80 @@
+module MetaModel
+  module Meta
+    class ModelsController < ApplicationController
+      before_action :get_model, only: [:edit, :show, :update, :destroy]
+
+      def index
+        respond_to do |format|
+          format.html { @hierarchy = Model.all.hierarchically }
+          format.json { render json: Model.all }
+        end
+      end
+
+      def hierarchy
+        respond_to do |format|
+          format.json { render json: Model.all.hierarchically }
+        end
+      end
+
+      def show
+        respond_to do |format|
+          format.json do
+            render json: @model
+          end
+        end
+      end
+
+      def edit
+        @models = Model.all.order(:name)
+      end
+
+      def create
+        model = Model.create(model_params)
+
+        create_models
+
+        render json: model
+      end
+
+      def update
+        model_params.each do |key, value|
+          @model.send("#{key}=", value)
+        end
+        @model.save
+
+        create_models
+
+        render json: @model
+      end
+
+      def destroy
+        @model.destroy
+
+        create_models
+
+        render json: nil
+      end
+
+      private
+
+      def get_model
+        @model = if model_param_class_name
+                   Model.where(class_name: model_param_class_name).first
+                 end || Model.find(params[:id])
+      end
+
+      def model_param_class_name
+        if params[:id]
+          @model_param_class_name ||= params[:id].classify
+        end
+      rescue NameError
+      end
+
+      def model_params
+        superclass_model = params[:model].delete(:superclass_model_id)
+        params.require(:model).permit(:class_name, :superclass_model).merge(superclass_model: superclass_model)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,36 @@
+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

data/app/controllers/meta_model/meta_controller.rb

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

data/app/controllers/meta_model/models_controller.rb

@@ -0,0 +1,69 @@
+module MetaModel
+  class ModelsController < MetaModel::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 = "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

data/app/helpers/meta_model/application_helper.rb

@@ -0,0 +1,10 @@
+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

data/app/helpers/meta_model/model_helper.rb

@@ -0,0 +1,10 @@
+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

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

@@ -0,0 +1,43 @@
+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(/^MetaModel::/, '')
+      end
+
+      def naming_column
+        # Probably want to allow the user to choose this
+        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(:name) || self.try(:description) || self.id
+    end
+  end
+end

data/app/models/meta_model/has_association.rb

@@ -0,0 +1,46 @@
+module MetaModel
+  class HasAssociation
+    include Neo4j::ActiveRel
+
+    from_class 'MetaModel::Model'
+    to_class '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

data/app/models/meta_model/meta_model_base.rb

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

data/app/models/meta_model/model.rb

@@ -0,0 +1,51 @@
+module MetaModel
+  class Model < MetaModelBase
+    property :class_name, type: String
+
+    has_one :out, :superclass_model, type: :inherits_from, model_class: 'MetaModel::Model'
+
+    has_one :out, :id_property, type: :has_id_property, model_class: 'MetaModel::Property'
+    has_many :out, :properties, type: :has_property, model_class: 'MetaModel::Property'
+
+    has_many :both, :assocs, model_class: 'MetaModel::Model', rel_class: '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

data/app/models/meta_model/property.rb

@@ -0,0 +1,11 @@
+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: 'MetaModel::Model'
+
+  end
+end

data/app/serializers/meta_model/has_association_serializer.rb

@@ -0,0 +1,13 @@
+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

data/app/serializers/meta_model/model_serializer.rb

@@ -0,0 +1,11 @@
+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

data/app/serializers/meta_model/property_serializer.rb

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

data/app/views/layouts/meta_model.html.slim

@@ -0,0 +1,28 @@
+doctype html
+html
+head
+  title MetaModel
+
+  javascript:
+    var meta_model_root_path = '#{root_path}';
+
+  = stylesheet_link_tag    'meta_model', media: 'all'
+  = javascript_include_tag 'meta_model'
+
+  = csrf_meta_tags
+
+body
+  nav.navbar.navbar-default role="navigation"
+    .container-fluid
+      ul.nav.navbar-nav
+        li
+          = link_to 'Models', root_path
+
+        li
+          = link_to 'Admin', meta_path
+
+  .container
+    = yield
+
+  = action_and_controller_javascript_include_tag
+

data/app/views/meta_model/meta/associations/index.html.slim

@@ -0,0 +1,12 @@
+
+table
+  - @has_associations.each do |has_association|
+    tr
+      td = link_to 'Edit', action: :edit, id: has_association.id
+      td = has_association.from_node.class_name
+      td -
+      td = has_association.relationship_type
+      td = has_association.join_type
+      td ->
+      td = has_association.to_node.class_name
+

data/app/views/meta_model/meta/index.html.slim

@@ -0,0 +1,2 @@
+
+#ember-application

data/app/views/meta_model/meta/models/edit.html.slim

@@ -0,0 +1,39 @@
+= form_tag({action: :update}, method: :put, class: 'form-horizontal', role: :form) do
+
+  .form-group
+    label
+      .col-sm-2.control-label Class Name
+      .col-sm-10 = text_field_tag 'model_data[class_name]', @model.class_name, class: 'form-control'
+
+  .form-group
+    label
+      .col-sm-2.control-label Inherits from
+      .col-sm-10 = select_tag 'model_data[superclass_model]', options_from_collection_for_select(([OpenStruct.new] + @models.to_a), 'class_name', 'class_name', @model.superclass_model.try(:class_name)), class: 'form-control'
+
+  .properties.row
+    h2
+      | Properties 
+      a.add.btn.btn-default Add Property
+
+    - @model.properties.each do |property|
+      .well.property.col-sm-6
+        i.glyphicon.glyphicon-remove-circle.close.pull-right
+
+        .form-group
+          label
+            .col-sm-2.control-label Name
+            .col-sm-10 = text_field_tag 'model_data[properties][][name]', property.name, class: 'form-control'
+
+        .form-group
+          label
+            .col-sm-2.control-label Type
+            .col-sm-10 = select_tag 'model_data[properties][][type]', options_for_select(['String', 'DateTime'], property.type), class: 'form-control'
+
+
+  .form-group
+    = submit_tag 'Update', class: 'btn btn-primary'
+
+scss:
+  label {
+    width: 100%;
+  }

data/app/views/meta_model/models/_form.html.slim

@@ -0,0 +1,72 @@
+- record.attributes.each do |key, value|
+  .form-group
+    label.control-label.col-sm-2 = key.humanize
+    .col-sm-10 = text_field_tag "data[#{key}]", value, class: 'form-control'
+
+- record.class.associations.each do |key, association|
+  .form-group
+    label.control-label.col-sm-2 = key.to_s.humanize
+    .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'
+      - 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 rv-each-option="view.current_options < objects" rv-value="option.id"
+              | { option.naming_column_value }
+
+          .list-group
+            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 }
+
+
+
+coffee:
+ 
+  class HasManyAssociationView extends Backbone.View
+    el: '.has-many-association'
+
+    initialize: ->
+      el = $(@el)
+      @options = _(el.data('options')).map((element) ->
+        element[el.data('option-type')]
+      ).value()
+
+      @objects = [@options[0]]
+
+    render: ->
+      @binding = rivets.bind $(@el), {@objects, view: @}
+
+      @
+
+    remove: ->
+      @binding.unbind()
+
+    current_options: =>
+      console.log('current_options!');
+      _(@options).difference(@objects).value()
+
+
+    add: (event, object) =>
+      selected_id = $(event.target).val()
+      selected_option = _(@options).find((option) -> option.id is selected_id)
+
+      @objects.push selected_option
+
+      $(@el).find('select option').removeAttr('selected')
+
+    delete: (event, object) =>
+      selected_id = $(event.target).data('id')
+      selected_object = _(@options).find((option) -> option.id is selected_id)
+
+      index = _(@objects).indexOf(selected_object)
+      @objects.removeAt(index)
+
+  ready = ->
+    new HasManyAssociationView().render()
+
+  $('document').ready ready
+  $('document').on 'page:load', ready

data/app/views/meta_model/models/_has_many_association.html.slim

@@ -0,0 +1,4 @@
+ul
+  - record.send(key).each do |object|
+    li = object.naming_column_value
+

data/app/views/meta_model/models/_record_details.html.slim

@@ -0,0 +1,13 @@
+- link ||= false
+
+= link_to 'View', {action: :show, model: record.meta_model_class.to_s.tableize, id: record.id}, class: 'btn btn-default' if link
+
+= link_to 'Edit', {action: :edit, model: record.meta_model_class.to_s.tableize, id: record.id}, class: 'btn btn-default'
+
+= button_to 'Delete', {action: :destroy, model: record.meta_model_class.to_s.tableize, id: record.id}, method: :delete, class: 'btn btn-danger pull-right'
+
+dl.dl-horizontal
+  - record.attributes.each do |key, value|
+    dt = key
+    dd = value
+

data/app/views/meta_model/models/edit.html.slim

@@ -0,0 +1,6 @@
+
+= form_tag({action: :update}, method: 'put', class: 'form-horizontal', role: 'form') do
+  = render partial: 'form', locals: {record: @record}
+
+  .form-group
+    = submit_tag 'Update', class: 'btn btn-primary'

data/app/views/meta_model/models/index.html.slim

@@ -0,0 +1,14 @@
+ol.breadcrumb
+  li = link_to 'Models', root_path
+  li = @meta_model.class_name.pluralize
+
+h2 = @meta_model.class_name.pluralize
+
+= link_to 'Add', new_model_path(model: @meta_model)
+
+div.list-group
+  - @records.each do |record|
+    = link_to model_path(id: record), class: 'list-group-item' do
+      - if record.class != @model
+        span.badge = record.class.to_s
+      = record._description

data/app/views/meta_model/models/meta_index.html.slim

@@ -0,0 +1,6 @@
+h2 Models
+
+div.list-group
+  - hierarchical_render(@hierarchy) do |model, level|
+    = link_to ('   ' * level).html_safe + model.class_name, models_path(model: model), class: 'list-group-item'
+

data/app/views/meta_model/models/new.html.slim

@@ -0,0 +1,7 @@
+
+= form_tag({action: :create}, method: 'post', class: 'form-horizontal', role: 'form') do
+  = render partial: 'form', locals: {record: @record}
+
+  .form-group
+    = submit_tag 'Create', class: 'btn btn-primary'
+

data/app/views/meta_model/models/show.html.slim

@@ -0,0 +1,18 @@
+ol.breadcrumb
+  li = link_to 'Models', root_path
+  li = link_to @meta_model.class_name.pluralize, models_path(model: @meta_model.class_name)
+  li = @record._description
+
+= render partial: 'record_details', locals: {record: @record}
+
+- @model.associations.each do |name, association|
+  - logger.warn "@record: #{@record.inspect}"
+  - logger.warn "name: #{name.inspect}"
+  - result = @record.send(name)
+  - result = result.respond_to?(:each) ? result.to_a : (result ? [result] : [])
+  - if result.present?
+    h2 = name.to_s.humanize
+    div
+      - result.each do |sub_record|
+        = render partial: 'record_details', locals: {record: sub_record, link: true}
+

data/config/initializers/active_model_serializer.rb

@@ -0,0 +1,6 @@
+require 'active_model_serializers'
+
+ActiveModel::Serializer.setup do |config|
+  config.embed = :ids
+  config.embed_in_root = true
+end

data/config/routes.rb

@@ -0,0 +1,19 @@
+MetaModel::Engine.routes.draw do
+  namespace :meta do
+    resources :models do
+      collection do
+        get :hierarchy
+      end
+    end
+    resources :properties
+    resources :has_associations#, path: '/associations'#, param: :asso
+  end
+
+  get '/meta' => 'meta#index'
+
+
+  resources :models, path: '/:model'
+
+  root 'models#meta_index'#, as: :meta_models
+end
+