app/controllers/app/views.rb app/helpers/viewer_helpers.rb app/models/vm/builders/abstract.rb app/models/vm/builders/entity.rb app/models/vm/builders/field.rb app/models/vm/builders/fieldlet.rb app/models/vm/parsers/abstract.rb app/models/vm/parsers/entity.rb app/models/vm/parsers/field.rb app/models/vm/parsers/fieldlet.rb app/models/vm/parsers/preference.rb @@ -1,3 +1,24 @@ +== SchemaElements refactoring + +* change everything to instance methods and not class methods +* Think about view elements +* Naming and documentation +* ViewActions? think about it. + +== "Get" actions +* Filters in the views +* Special actionlets for altering views? + +== 'ViewInfo' +* Items within items +* configs +* config entry can be set by an action. +* item can be shown only if given view action returned true +* item can be filterd by pset (optimisation) + + + + Actions ======= TODO @@ -1,32 +1,40 @@ # App base controller module App - SCHEMA_ROUTES = {:directory => {}, :host => {}, :catch_all => nil} + VIEW_ROUTES = {:dir => {}, :host => {}, :catch_all => nil} class AppController < Application layout false + before :set_view before :set_namespace - - def set_namespace - if params[:directory] && namespace = App::SCHEMA_ROUTES[:directory][params[:directory]] - @namespace_path = "/#{params[:directory]}" - @namespace = namespace - return - end - - if namespace = App::SCHEMA_ROUTES[:host][request.host] - @namespace_path = '/' - @namespace = namespace - return - end - - if namespace = App::SCHEMA_ROUTES[:catch_all] - @namespace_path = '/' - @namespace = namespace - return - end - + protected + + ## + # setup the views according to the registerd view routes + # + def set_view + return if params[:dir] && @view = App::VIEW_ROUTES[:dir][params[:dir]] + return if @view = App::VIEW_ROUTES[:host][request.host] + return if @view = App::VIEW_ROUTES[:catch_all] raise NotFoundException end + + ## + # sets the schema's namespace + # + # + def set_namespace + @ns = @view::SCHEMA + end + + + ## + # Sets the response code to 200 + # and returns the body + # + def ok(body = '') + self.status = 200 + return body + end end end \ No newline at end of file app/controllers/app/app.rb @@ -3,63 +3,41 @@ module App provides :xml, :json layout false # no layouts - def index - @entities = [] #Entity.all_with_fieldlets - display @entities - end - def show - @entity = @namespace::Entity.find_with_fieldlets(params[:id]) - raise NotFoundException if !@entity - set_last_modified_headers() - display @entity + @entity = @ns::Entity.find_with_fieldlets(params[:id]) + raise NotFoundException if !@entity + set_last_modified_headers() + return display_entity() end def new - @entity = @namespace::Entity.get_subclass_by_id(params[:id]).new + @entity = @ns::Entity.get_subclass_by_id(params[:id]).new @entity.apply_constructor! apply_actions! - display @entity + return display_entity() end def create - @entity = @namespace::Entity.get_subclass_by_id(params[:id]).new + @entity = @ns::Entity.get_subclass_by_id(params[:id]).new apply_actions! - if @entity.save_changes - return render - else - raise BadRequest - end + return @entity.save_changes ? display_entity() : display_entity_errors() end - def edit - @entity = @namespace::Entity.find_with_fieldlets(params[:id]) - render - end def update - @entity = @namespace::Entity.find_with_fieldlets(params[:id]) + @entity = @ns::Entity.find_with_fieldlets(params[:id]) apply_actions! - if @entity.save_changes - return render - else - raise BadRequest - end + return @entity.save_changes ? display_entity() : display_entity_errors() end def destroy - @entity = @namespace::Entity[params[:id]] - if @entity.destroy - return render - else - raise BadRequest - end + @entity = @ns::Entity[params[:id]] + return @entity.destroy ? ok() : display_entity_errors() end - def search - entity_dataset = @namespace::Entity.filter('`display` LIKE ?', "#{params[:search]}%") + entity_dataset = @ns::Entity.filter('`display` LIKE ?', "#{params[:search]}%") entity_dataset.filter!(:kind => params[:kind]) if params[:kind] entity_dataset.limit!(30) @@ -99,5 +77,23 @@ module App @entity.apply_actions!(params[:entity]) set_async_actions! end + + ## + # Shorthand for display @entity with the action name and the viewer + # + # @param [Hash] extra_hash extra keys to push to the display method + # + # @return [String] the response match + def display_entity(extra_hash = {}) + display @entity, nil, extra_hash.merge!({:view => @view}) + end + + ## + # Shorthand for displaying the errors for the entity + # + def display_entity_errors(extra_hash = {}) + display @entity.errors, nil, extra_hash.merge!({:view => @view}) + end + end end \ No newline at end of file app/controllers/app/entities.rb @@ -1,7 +1,7 @@ module Merb module GlobalHelpers # helpers defined here available to all views. - include HomeHelpers + include ViewsHelpers end end app/helpers/global_helpers.rb @@ -54,4 +54,5 @@ module App end + end \ No newline at end of file app/models/app/action.rb @@ -41,7 +41,9 @@ module App # Inheritance Mixin - for smart STI include InheritanceMixin include Namespacing - + + + # setup all the instance variables after_initialize do @fieldlets = Hash.new{|hash, key| hash[key] = {}} @@ -54,10 +56,12 @@ module App ## utility - + + # nice shit def fwf self.class.find_with_fieldlets(self.pk.to_s(16)) end + end end \ No newline at end of file app/models/app/entity.rb @@ -5,5 +5,12 @@ module App class Entity < Sequel::Model + ## + # load all the psets for the entity + # + def load_psests + + end + end end \ No newline at end of file app/models/app/entity/security.rb @@ -19,12 +19,23 @@ module VM primary_key [:guid] end set_primary_key :guid + + + ## + # Cached accessor for the scehma elements of this schema + # + def schema_elements + @schema_elements ||= schema_elements_dataset.all() + end + + + ## + # Dataset for the schema elements of the current schema + # + def schema_elements_dataset + SchemaElement.filter(:schema => self.pk).order(:parent_guid, :position) + end - one_to_many(:schema_elements, - :key => :schema, - :class => VM::SchemaElement) do |ds| - ds.order(:parent_guid, :position) - end before_destroy :unload! # unload before destroying after_destroy :destroy_schema_elements_on_destruction @@ -67,8 +78,8 @@ module VM def instansiate elements = @elements.values - @generated = elements.collect{|e| e.build_model(@namespace)} - elements.each{|e| e.set_extras(@namespace)} + @generated = elements.collect{|e| e.build(@namespace)} + elements.each{|e| e.set_extras!} @generated end @@ -78,47 +89,7 @@ module VM @namespace.const_set('SCHEMA', "%016x" % @values[:guid]) end - def register_routing - if self.prefs['routing'] == '*' || !self.prefs['routing'] # catch all - ::App::SCHEMA_ROUTES[:catch_all] = @namespace - return - end - - - if self.prefs['routing'] =~ /^\/\w+$/ #directory - ::App::SCHEMA_ROUTES[:directory][self.prefs['routing'].sub('/','')] = @namespace - return - end - - ::App::SCHEMA_ROUTES[:hosts][self.prefs['routing']] = @namespace - end - - def remove_routing - if self.prefs['routing'] == '*' || !self.prefs['routing'] # catch all - ::App::SCHEMA_ROUTES[:catch_all] = nil - return - end - - if self.prefs['routing'] =~ /^\/\w+$/ #directory - ::App::SCHEMA_ROUTES[:directory].delete self.prefs['routing'].sub('/','') - return - end - - ::App::SCHEMA_ROUTES[:hosts].delete self.prefs['routing'] - end - - #def setup_queue - # queue = nil - # - # if queue_options = self.prefs[:queue_options] - # queue = NiftyQ::Manager.new(queue_options[:provider], queue_options[:options]) - # end - # - # queue ||= NiftyQ::Manager.new(:sequel, {:db => @namespace::Entity.db}) - # - # @namespace.const_set('QUEUE', queue) - #end - + @@ -129,10 +100,8 @@ module VM self.instansiate() - puts "Loaded Schema #{"%016x" % @values[:guid]} (#{@generated.size} models) => #{self.prefs['routing']}" + puts "Loaded Schema #{"%016x" % @values[:guid]} (#{@generated.size} models)" - self.register_routing() -# self.setup_queue() @generated end @@ -141,13 +110,12 @@ module VM # the schema # def destroy_schema_elements_on_destruction - + self.shema_elements().each{|i| i.destroy} end attr_accessor :generated def unload! - self.remove_routing() ::App.send(:remove_const, "Schema#{"%016x" % @values[:guid]}".to_sym) app/models/vm/schema.rb @@ -1,8 +1,8 @@ module VM class SchemaElement < Sequel::Model include PreferencesTools - - @@element_types ||= {} + + @@builders ||= {} set_schema do bigint :schema, :unsigned => true, :null => false @@ -49,43 +49,70 @@ module VM return k.find_all{|x| x.values[:type] == type} if k return [] end - - def schema_element_type - @schema_element_type ||= SchemaElement.element_types[@values[:type].to_sym] - raise "No schema element type :#{@values[:type]}" if !@schema_element_type - return @schema_element_type - end - - def has_model? - @has_model ||= self.schema_element_type.has_model? - end - - def build_model(namespace = ::App) - raise "This schema element doesn't generate model!" if !has_model? - self.schema_element_type.build_model(namespace, self) - end - - def set_extras(namespace = ::App) - self.schema_element_type.set_extras_for_model(namespace, self) + + + ## + # Accessor for the builder of this element type + # + def builder(namespace) + @builder ||= self.builder_class.new(self,namespace) end - - def model_name - return false if not has_model? - @model_name ||= "#{self.schema_element_type.model_class_name}#{self.hex_guid()}" + + ## + # Get the builder class for the this schema element + # + # @return [Class] the builder class + def builder_class + @builder_class ||= @@builders[@values[:type].to_sym] + raise "No builder class for :#{@values[:type]}" if !@builder_class + return @builder_class + end + + + ## + # Builds the needed model in the given namespace + # + # @param [Module] namespace the module to generate the model in + # + # @return [Class] The generated model + def build(namespace = ::App) + @namespace = namespace + @model = self.builder(@namespace).build + end + + ## + # Setup the needed extras on the builded model + # + def set_extras! + @builder.set_extras! end + ## # get the generated model from the namespace - def generated(namespace) - namespace.const_get(self.model_name) - end - - def self.element_types - @@element_types + # + def model + raise "This element hasn't been built yet!" if !@model + @model end - - def self.register_element_type(symbol, klass) - @@element_types[symbol] = klass + + ## + # Accessor for the @@builders class var + # + def self.builders + @@builders end + + + ## + # Registers a builder for the given schema element type with the given class + # + # @param [Symbol] symbol the type to build with this builder + # @param [Class] klass the builder class + # + def self.register_builder(symbol, klass) + @@builders[symbol] = klass + end + def hex_guid @hex_guid ||= "%016x" % @values[:guid] app/models/vm/schema_element.rb @@ -6,14 +6,36 @@ module VM @@should_set_parent ||= {} @@schema_elements_types ||= {} + ## + # Sets whether the schema element should generate model on the App + # namespace + # def self.has_model! @@has_models[self] = true end + ## + # Should the schema element generate model on the App namespace + # def self.has_model? @@has_models[self] end + + ## + # Finds the model class defined in #model_class_name, in the given namespace + # + # If the model doesn't exist on the given namespace, we'll create it, inheriting + # from the main model, defined on the App namespace. + # + # @param [Model] namespace the namespace to find/create the model on + # + # @return [Class] the model class found/created on the namespace + # + # === Notes: + # * We set the NAMESPACE const on the created model to point to the given + # namespcae + # def self.find_or_create_model_class(namespace) if (namespace.constants.include? @@model_class_name[self]) return namespace.const_get(@@model_class_name[self]) @@ -25,6 +47,14 @@ module VM return model end + + ## + # Generate the model + # + # + # + # + def self.build_model(namespace, schema_element) identifier = schema_element.hex_guid preferences = schema_element.prefs #load prefs @@ -51,9 +81,7 @@ module VM end end end - - - + return model_klass end @@ -70,15 +98,26 @@ module VM # load extra methods if respond_to?(:model_extension) to_eval = model_extension(namespace,schema_element) - model_klass.class_eval &to_eval if to_eval.class == Proc + model_klass.class_eval(&to_eval) if to_eval.class == Proc model_klass.class_eval to_eval if to_eval.class == String end end + ## + # Sets the model class name, which the schema element will use to + # generate models on the App namespace + # + # @param [String] model_name the name of the model class + # def self.set_model_class_name(model_name) @@model_class_name[self] = model_name end + ## + # Return the model class name, which the schema element will use + # to generate models on the App namespace + # + # @return [String] model's class name def self.model_class_name @@model_class_name[self] end @@ -93,18 +132,18 @@ module VM # Register the schema element for parsing tags as the given symbol # def self.register_parser_for(symbol) - SchemaLoader.register_parser(symbol, self) + #SchemaLoader.register_parser(symbol, self) end ## - # accessor for @@should_set_parent + # Should the schema element save it's parent element id # def self.set_parent? @@should_set_parent[self] end ## - # sets the @@should_set_parent to true + # Sets whether the element should save it's parent element id # def self.set_parent! @@should_set_parent[self] = true @@ -122,6 +161,18 @@ module VM # # @overrideable # + # === Notes: + # * We're iterating through xml_node children and creates new SchemaElement + # for each of them + # + # * if the extra_parsing method is implemented, we call it with the newly created + # schema element, the xml node of it, it's position, it's parent element and the schema + # object + # + # * We yield the newly created SchemaElement and it's xml node for children parsing + # unless the dont_parse_children method is defined + # + ############ def self.parse(parent_element,xml_node, schema) xml_node.children.each_with_index do |element_node, position| element = schema["%016x" % element_node['id'].to_i(16)] app/models/vm/schema_elements/abstract.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class ActionSchemaElementType < AbstractSchemaElementType - register :action +# register :action set_model_class_name 'Action' has_model! register_parser_for :actions app/models/vm/schema_elements/action.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class ActionDoSchemaElementType < AbstractSchemaElementType - register_parser_for :do + #register_parser_for :do ## app/models/vm/schema_elements/action_do.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class ActionPrototypeSchemaElementType < AbstractSchemaElementType - register_parser_for :prototype + #register_parser_for :prototype PARSERS = { 'param' => :parse_param, app/models/vm/schema_elements/action_prototype.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class EntitySchemaElementType < AbstractSchemaElementType - register :entity + #register :entity set_model_class_name 'Entity' has_model! register_parser_for :entities app/models/vm/schema_elements/entity.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class FieldSchemaElementType < AbstractSchemaElementType - register :field + #register :field set_model_class_name 'Field' has_model! register_parser_for :fields @@ -21,7 +21,7 @@ module VM # find link fieldlet link_fieldlet = fieldlet_klasses.find{|f| f::PREFS['type'] == 'Link'}::IDENTIFIER end - + duplication_hash = nil if duplication duplication_hash = {} app/models/vm/schema_elements/field.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class FieldletSchemaElementType < AbstractSchemaElementType - register :fieldlet + #register :fieldlet set_model_class_name 'Fieldlet' has_model! register_parser_for :fieldlets app/models/vm/schema_elements/fieldlet.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class ParameterSchemaElementType < AbstractSchemaElementType - register_parser_for :params + #register_parser_for :params ## app/models/vm/schema_elements/parameter.rb @@ -1,7 +1,7 @@ module VM module SchemaElementTypes class PreferencesSchemaElementType < AbstractSchemaElementType - register_parser_for :preferences + #register_parser_for :preferences ## app/models/vm/schema_elements/preference.rb @@ -17,7 +17,7 @@ module VM # @param [String] xml_path the path of the xml schema file # def initialize(xml_path) - LibXML::XML::Parser.default_keep_blanks = false + LibXML::XML.default_keep_blanks = false @doc = LibXML::XML::Document.file(xml_path) @root = @doc.root @elements = [] @@ -92,13 +92,9 @@ module VM next end - parser.parse(schema_element,child, @schema) do |c_element, c_node| - if c_element - c_element[:parent_guid] = schema_element.guid if parser.set_parent? - c_element[:schema] = @schema.values[:guid] + parser.new(schema_element,child, @schema) do |c_element, c_node| parse_children(c_node, c_element) @elements << c_element - end end end end app/models/vm/schema_loader.rb @@ -13,8 +13,6 @@ Merb::Config.use { |c| c[:log_stream] = STDOUT c[:log_file] = nil - c[:default_viewer] = :extjs - c[:nifty_q] = { :provider => :sequel, :provider_options => {}, config/environments/development.rb @@ -47,4 +47,6 @@ Merb::Config.use do |c| # 'memory' or 'memcached'. You can of course use your favorite ORM # instead: 'datamapper', 'sequel' or 'activerecord'. c[:session_store] = 'memory' + + c[:default_viewer] = :extjs end config/init.rb @@ -5,6 +5,8 @@ */ + + Nifty.data.EntityCRUD = function(config){ // apply config Ext.apply(this,config); public/javascripts/nifty/core/entity_crud.js @@ -13,13 +13,15 @@ * the server * * @constructor - */ + */ + Nifty.data.Schema = function(schema_hash){ this.id = schema_hash.id; this.name = schema_hash.name; this.preferences = schema_hash.preferences; this.elements = schema_hash.elements; - + + //constructors for each class this.elementConstructors = {}; public/javascripts/nifty/data/schema.js @@ -108,6 +108,7 @@ Nifty.BootLoader.prototype = { */ setApplicationTitle: function(){ Ext.fly('app-name').update(this.schema.name); + }, /** public/viewers/extjs/javascripts/boot_loader.js Samples/Amazonifty/amazon.xml Samples/Amazonifty/viewer/d1d8ab47557f0f5a/info.css Samples/Amazonifty/viewer/d1d8ab47557f0f5a/info.js Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/1d03ca03e76d140e_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/1d03ca03e76d140e_small.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/71aa43efd0fdd671_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/71aa43efd0fdd671_small.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/fdae913172896bce_big.png Samples/Amazonifty/viewer/d1d8ab47557f0f5a/resources/fdae913172896bce_small.png app/controllers/app/home.rb app/helpers/home_helpers.rb app/views/app/entities/create.json.erb app/views/app/entities/update.json.erb app/views/app/home/index.html.erb app/views/layout/app.html.erb eb8ad88d667012e45d2c7d83a06092d2ac842d56 Shlomi Atar shlomiatar@gmail.com http://github.com/shlomiatar/nifty-vm/commit/6919d11fa28c29e737a68e4cf3213dc53e9ab28a 6919d11fa28c29e737a68e4cf3213dc53e9ab28a 2008-11-28T02:16:19-08:00 2008-11-28T02:16:19-08:00 * Refactored the schema parsing and building mechanisems * Moving to th "views" architecture d6042b3f6ba97357a07acdbd11c29ba63d06b5d0 Shlomi Atar shlomiatar@gmail.com