#マニフェスト\r
-@elements = [\r
- {\r
- name: 'panel_picture',\r
- path_name: 'panel_pictures', \r
- parts: []\r
- },\r
- {\r
- name: 'speech_balloon',\r
- path_name: 'circle_speech_balloon/speech_balloons', \r
- parts: ['balloon', 'speech']\r
- },\r
- {\r
- name: 'ground_picture',\r
- path_name: 'ground_pictures', \r
- parts: []\r
- },\r
- {\r
- name: 'ground_color',\r
- path_name: 'ground_colors', \r
- parts: []\r
- },\r
-]\r
@forms = {\r
base: {\r
scroll: {\r
},\r
},\r
panel: {\r
+ peta: {\r
+ type: 'root',\r
+ args: {\r
+ element_tree_name: 'panel',\r
+ },\r
+ },\r
associations: {\r
belongs_to: {\r
author: {\r
profilers: window.profilers,\r
filers: window.filers,\r
list_groups: window.list_groups,\r
- elements: window.elements,\r
forms: window.forms,\r
}\r
}\r
models: window.models,\r
system_resources: window.system_resources,\r
magic_numbers: window.magic_numbers,\r
- select_items: window.select_items,\r
locals: {\r
list_groups: window.list_groups,\r
profilers: window.profilers,\r
filers: window.filers,\r
- elements: window.elements,\r
forms: window.forms,\r
}\r
}\r
#コマ
-class Panel < Peta::Content
+class Panel < Peta::Root
load_manifest
belongs_to :author
has_many :scroll_panels
validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
validates :publish, :presence => true, :numericality => true
- def self.each_element_class_names
- Manifest.manifest.system_resources.elements.each do |k, n|
- yield k
- end
- end
-
- def self.class_name_to_class k
- Object.const_get k
- end
-
- def self.each_element_classes
- self.each_element_class_names do |k|
- e = self.class_name_to_class k
- yield e
- end
- end
-
- def elements_by_class_name class_name
- self.__send__ class_name.tableize
- end
-
def supply_default
self.border = 2
self.publish = 0
r = {
:author => {}
}
- self.each_element_classes do |e|
- r.merge!(e.list_opt_for_panel)
+ self.child_models.each do |child_model|
+ r.merge!(child_model.list_opt_for_panel)
end
r
end
r = {
:author => {}
}
- self.each_element_classes do |e|
- r.merge!(e.show_opt_for_panel)
+ self.child_models('panel').each do |child_model|
+ r.merge!(child_model.show_opt_for_panel)
end
{:include => r}
end
def parts_element
- r = []
- self.class.each_element_class_names do |k|
- r += (self.elements_by_class_name(k) || [])
- end
- r
+ self.elements_items
end
def zorderd_elements
end
def validate_serial_list
- l = []
- self.class.each_element_class_names do |k|
- l << self.elements_by_class_name(k)
- end
[
- {:elements => l, :name => :t, :offset => 0},
- {:elements => l, :name => :z, :offset => 1}
+ {:elements => self.elements_items, :name => :t, :offset => 0},
+ {:elements => self.elements_items, :name => :z, :offset => 1}
]
end
def validate_child
def copy
attr = self.copy_attributes
- Panel.each_element_class_names do |n|
- attr.merge! Panel.class_name_to_class(n).panelize(self.elements_by_class_name(n).map {|elm| elm.copy_attributes})
+ self.class.child_models('panel') do |child_model|
+ attr.merge! child_model.panelize(self.element_items(child_model).map {|elm| elm.copy_attributes})
end
attr
end
end
def editize_element parent
- parent.class.child_element_names(@editor.name).each do |element_name|
+ parent.class.child_element_names(@root_item.class.element_tree_name).each do |element_name|
e = parent.__send__ element_name
e = [e] unless e.respond_to? :each
e.each do |element|
require_dependency "manifest/model/association"
require_dependency "manifest/model/list"
require_dependency "manifest/model/tree"
+require_dependency "manifest/model/peta"
module Manifest
class Model
end
attr :model_name, :model_manifest,
- :attributes, :associations, :tree, :lists, :extend_column_name
+ :attributes, :associations, :tree, :lists, :peta, :extend_column_name
def initialize manifest, model_name, model_manifest
@manifest = manifest
@model_name = model_name
@model_manifest['tree'] ||= {}
@model_manifest['lists'] ||= {}
@model_manifest['extend_column_name'] ||= 'classname'
+ @model_manifest['peta'] ||= {}
@model_manifest['attributes']['id'] = {
'type' => 'number',
'primary_key' => 1,
@model_manifest['tree'].each {|tree_name, parent_model_name|
@tree[tree_name] = ModelModule::Tree.new(self, tree_name, parent_model_name)
}
+ @peta = ModelModule::PetaFactory.factory(self, @model_manifest['peta'])
@extend_column_name = @model_manifest['extend_column_name']
@lists = {}
@model_manifest['lists'].each {|list_name, list_manifest|
false
end
- def each_child_model_manifest tree_name
+ def child_model_manifests tree_name
+ r = []
::Manifest.manifest.models.each {|child_model_name, child_model_manifest|
next unless child_model_manifest.tree[tree_name]
next unless child_model_manifest.tree[tree_name].parent_model_name == @model_name
- yield child_model_manifest
+ r << child_model_manifest
}
+ r
end
def child_models tree_name
- r = []
- self.each_child_model_manifest(tree_name) {|child_model_manifest|
- r << child_model_manifest.classify
+ self.child_model_manifests(tree_name).map {|child_model_manifest|
+ child_model_manifest.classify
}
- r
end
def child_element_names tree_name
- r = []
- self.each_child_model_manifest(tree_name) {|child_model_manifest|
- # has_one ?
- r << self.associations.child_element_name(child_model_manifest)
+ self.child_models(tree_name).map {|child_model|
+ self.associations.child_element_name(child_model)
}
- r
+ end
+
+ def child_element_name item_name
+ self.associations.child_element_name(child_model_manifest)
end
end
@model.model_manifest
end
- def child_element_name child_model_manifest
- if @has_one[child_model_manifest.model_name]
- child_model_manifest.model_name
+ def child_element_name child_model
+ if @has_one[child_model.item_name]
+ child_model.item_name
else
- child_model_manifest.table_name
+ child_model.table_name
end
end
--- /dev/null
+require_dependency "manifest/model/peta/base"
+require_dependency "manifest/model/peta/item"
+require_dependency "manifest/model/peta/owner"
+require_dependency "manifest/model/peta/content"
+require_dependency "manifest/model/peta/root"
+require_dependency "manifest/model/peta/element"
+module Manifest
+ module ModelModule
+ class PetaFactory
+ include PetaModule
+ @@types = {
+ 'item' => ItemPeta, 'owner' => OwnerPeta, 'content' => ContentPeta,
+ 'root' => RootPeta, 'element' => ElementPeta
+ }
+ def self.factory model, my_manifest
+ my_manifest['type'] ||= 'item'
+ type = my_manifest['type']
+ raise "undefined type for models > #{model.model_name} > peta \n" unless type
+ my_class = @@types[type]
+ raise "undefined class for models > #{model.fmodel_name} > peta > #{type}\n" unless my_class
+ my_class.new(model, my_manifest)
+ end
+
+ end
+
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class BasePeta
+ attr :model, :peta_manifest, :type
+
+ def initialize model, peta_manifest
+ @model = model
+ @peta_manifest = peta_manifest
+ self.set_default
+ self.init
+ end
+
+ def set_default
+ @peta_manifest['args'] ||= {}
+ end
+
+ def init
+ @type = @peta_manifest['type']
+ @args = @peta_manifest['args']
+ end
+
+ end
+
+ end
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class ContentPeta < BasePeta
+
+ def set_default
+ super
+ end
+
+ def init
+ super
+ end
+
+ end
+
+ end
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class ElementPeta < BasePeta
+
+ def set_default
+ super
+ end
+
+ def init
+ super
+ end
+
+ end
+
+ end
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class ItemPeta < BasePeta
+
+ def set_default
+ super
+ end
+
+ def init
+ super
+ end
+
+ end
+
+ end
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class OwnerPeta < BasePeta
+
+ def set_default
+ super
+ end
+
+ def init
+ super
+ end
+
+ end
+
+ end
+ end
+end
--- /dev/null
+module Manifest
+ module ModelModule
+ module PetaModule
+ class RootPeta < BasePeta
+ attr :element_tree_name
+
+ def set_default
+ super
+ raise "undefined element_tree_name for models> #{@model.model_name} > peta \n" unless @peta_manifest['args']['element_tree_name']
+ end
+
+ def init
+ super
+ @element_tree_name = @args['element_tree_name']
+ end
+
+ end
+
+ end
+ end
+end
require_dependency 'peta/content'
require_dependency 'peta/element'
require_dependency 'peta/element_part'
+require_dependency 'peta/root'
require_dependency 'peta/editize'
--- /dev/null
+module Peta
+ class Root < Content
+ self.abstract_class = true
+
+ # Dynamic Methods
+
+ def self._element_tree_name
+ self.my_manifest.peta.element_tree_name
+ end
+
+ def self.load_manifest
+ super
+ # Class Methods
+ n = self._element_tree_name
+ define_singleton_method("element_tree_name") do
+ n
+ end
+ # Instance Methods
+ define_method("element_items") do |element_model|
+ self.__send__ self.class.my_manifest.associations.child_element_name(element_model)
+ end
+ define_method("elements_items") do
+ self.class.child_models(self.class.element_tree_name).map {|child_model|
+ self.element_items child_model
+ }.flatten
+ end
+ end
+
+ # Class Methods
+
+ end
+end
+
}\r
},\r
"panel": {\r
+ "peta": {\r
+ "type": "root",\r
+ "args": {\r
+ "element_tree_name": "panel"\r
+ }\r
+ },\r
"associations": {\r
"belongs_to": {\r
"author": {}\r
}\r
}\r
},\r
- "elements": [\r
- {\r
- "name": "panel_picture",\r
- "path_name": "panel_pictures",\r
- "parts": []\r
- },\r
- {\r
- "name": "speech_balloon",\r
- "path_name": "circle_speech_balloon/speech_balloons",\r
- "parts": [\r
- "balloon",\r
- "speech"\r
- ]\r
- },\r
- {\r
- "name": "ground_picture",\r
- "path_name": "ground_pictures",\r
- "parts": []\r
- },\r
- {\r
- "name": "ground_color",\r
- "path_name": "ground_colors",\r
- "parts": []\r
- }\r
- ],\r
"forms": {\r
"base": {\r
"scroll": {\r