-require_dependency "local_manifest/filer/symbol"
-require_dependency "local_manifest/filer/caption"
-require_dependency "local_manifest/filer/summary"
-require_dependency "local_manifest/filer/icon"
-require_dependency "local_manifest/filer/date"
-require_dependency "local_manifest/filer/edit"
+ManifestBase.require_modules "local_manifest/filer/",
+ %w|symbol caption summary icon date edit|
+
module LocalManifest
- class Filer
-
- def self.manager manifest, my_manifests
- filers = {}
- my_manifests.each {|item_name, filer_manifest|
- filers[item_name] = self.new(manifest, item_name, filer_manifest)
- }
- filers
- end
+ class Filer < ManifestBase::Base
+ include FilerModule
- attr :filer_manifest, :item_name, :manifest, :item_class,
+ attr :item_class,
:symbol, :caption, :summary, :icon, :date, :edit
- def initialize manifest, item_name, filer_manifest
- @manifest = manifest
- @item_name = item_name
- @filer_manifest = filer_manifest
- @item_class = ::Manifest.item_name_to_model @item_name
- self.set_default
- self.init
- end
def set_default
- @filer_manifest['symbol'] ||= {}
- @filer_manifest['caption'] ||= {}
- @filer_manifest['summary'] ||= {}
- @filer_manifest['icon'] ||= {}
- @filer_manifest['date'] ||= {}
- @filer_manifest['edit'] ||= {}
+ super
+ @item_class = ::Manifest.item_name_to_model @name
+ @json['symbol'] ||= {}
+ @json['caption'] ||= {}
+ @json['summary'] ||= {}
+ @json['icon'] ||= {}
+ @json['date'] ||= {}
+ @json['edit'] ||= {}
end
def init
- @symbol = FilerModule::SymbolFactory.factory self, @filer_manifest['symbol']
- @caption = FilerModule::CaptionFactory.factory self, @filer_manifest['caption']
- @summary = FilerModule::SummaryFactory.factory self, @filer_manifest['summary']
- @icon = FilerModule::IconFactory.factory self, @filer_manifest['icon']
- @date = FilerModule::DateFactory.factory self, @filer_manifest['date']
- @edit = FilerModule::EditFactory.factory self, @filer_manifest['edit']
+ super
+ @symbol = ManifestBase.load_type_args self, @json, 'symbol', SymbolFactory
+ @caption = ManifestBase.load_type_args self, @json, 'caption', CaptionFactory
+ @summary = ManifestBase.load_type_args self, @json, 'summary', SummaryFactory
+ @icon = ManifestBase.load_type_args self, @json, 'icon', IconFactory
+ @date = ManifestBase.load_type_args self, @json, 'date', DateFactory
+ @edit = ManifestBase.load_type_args self, @json, 'edit', EditFactory
+ end
+
+ def item_name
+ @name
end
def filer_name
- @item_name
+ @name
end
end
-require_dependency "local_manifest/filer/caption/base"
-require_dependency "local_manifest/filer/caption/default"
-require_dependency "local_manifest/filer/caption/template"
-require_dependency "local_manifest/filer/caption/none"
+ManifestBase.require_modules "local_manifest/filer/caption/",
+ %w|base default template none|
+
module LocalManifest
module FilerModule
- class CaptionFactory
+ class CaptionFactory < ManifestBase::Factory
include CaptionModule
- @@types = {
- 'default' => Default, 'template' => Template, 'none' => None
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'default'
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.filer_name} > caption\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.filer_name} > caption > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'default' => Default, 'template' => Template, 'none' => None
+ }
+ end
+
+ def self.default_type
+ 'default'
end
end
-
end
end
module LocalManifest
module FilerModule
module CaptionModule
- class Base
- attr :filer, :caption_manifest, :type
-
- def initialize filer, caption_manifest
- @filer = filer
- @caption_manifest = caption_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @caption_manifest['args'] ||= {}
+ super
end
def init
- @type = @caption_manifest['type']
- @args = @caption_manifest['args']
+ super
end
def filer_name
- @filer.item_name
+ @parent.name
end
- def filer_manifest
- @filer.filer_manifest
+ def filer
+ @parent
end
end
-require_dependency "local_manifest/filer/caption/default/face"
-require_dependency "local_manifest/filer/caption/default/link"
+ManifestBase.require_modules "local_manifest/filer/caption/default/",
+ %w|face link|
+
module LocalManifest
module FilerModule
module CaptionModule
def set_default
super
- @caption_manifest['args']['face'] ||= {}
- @caption_manifest['args']['link'] ||= {}
+ @args['face'] ||= {}
+ @args['link'] ||= {}
end
def init
super
- @face = FaceFactory.factory(self, @args['face'])
- @link = LinkFactory.factory(self, @args['link'])
+ @face = ManifestBase.load_type_args self, @args, 'face', FaceFactory
+ @link = ManifestBase.load_type_args self, @args, 'link', LinkFactory
end
def visible?
-require_dependency "local_manifest/filer/caption/default/face/face"
+ManifestBase.require_modules "local_manifest/filer/caption/default/face/",
+ %w|face|
+
module LocalManifest
module FilerModule
module CaptionModule
module DefaultModule
- class FaceFactory
+ class FaceFactory < ManifestBase::Factory
include FaceModule
- @@types = {
- 'column' => ColumnFace, 'method' => MethodFace, 'none' => NoneFace
- }
- def self.factory default_caption, my_manifest
- my_manifest['type'] ||= 'column'
- type = my_manifest['type']
- raise "undefined type for filers > #{default_caption.filer_name} > caption > default > face\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{default_caption.filer_name} > caption > default > face > #{type}\n" unless my_class
- my_class.new(default_caption, my_manifest)
+
+ def self.types
+ {
+ 'column' => ColumnFace, 'method' => MethodFace, 'none' => NoneFace
+ }
+ end
+
+ def self.default_type
+ 'column'
end
end
-
end
end
end
module CaptionModule
module DefaultModule
module FaceModule
- class BaseFace
- attr :caption, :face_manifest, :type
- def initialize caption, face_manifest
- @caption = caption
- @face_manifest = face_manifest
- self.set_default
- self.init
- end
+ class BaseFace < ManifestBase::TypeArgs
def set_default
- @face_manifest['args'] ||= {}
+ super
end
def init
- @type = @face_manifest['type']
- @args = @face_manifest['args']
+ super
end
end
class ColumnFace < BaseFace
attr :column_name
+
def set_default
super
- @face_manifest['args']['column_name'] ||= 'caption'
+ @args['column_name'] ||= 'caption'
end
def init
class MethodFace < BaseFace
attr :method_name
+
def set_default
super
- @face_manifest['args']['method_name'] ||= 'caption'
+ @args['method_name'] ||= 'caption'
end
def init
-require_dependency "local_manifest/filer/caption/default/link/link"
+ManifestBase.require_modules "local_manifest/filer/caption/default/link/",
+ %w|link|
+
module LocalManifest
module FilerModule
module CaptionModule
module DefaultModule
- class LinkFactory
+ class LinkFactory < ManifestBase::Factory
include LinkModule
- @@types = {
- 'action' => ActionLink, 'none' => NoneLink, 'url_column' => UrlColumnLink
- }
- def self.factory default_caption, my_manifest
- my_manifest['type'] ||= 'action'
- type = my_manifest['type']
- raise "undefined type for filers > #{default_caption.filer_name} > caption > default > link\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{default_caption.filer_name} > caption > default > link > #{type}\n" unless my_class
- my_class.new(default_caption, my_manifest)
+
+ def self.types
+ {
+ 'action' => ActionLink, 'none' => NoneLink, 'url_column' => UrlColumnLink
+ }
+ end
+
+ def self.default_type
+ 'action'
end
end
-
end
end
end
module CaptionModule
module DefaultModule
module LinkModule
- class BaseLink
- attr :caption, :link_manifest, :type
-
- def initialize caption, link_manifest
- @caption = caption
- @link_manifest = link_manifest
- self.set_default
- self.init
- end
+ class BaseLink < ManifestBase::TypeArgs
def set_default
- @link_manifest['args'] ||= {}
+ super
end
def init
- @type = @link_manifest['type']
- @args = @link_manifest['args']
+ super
end
def filer
- @caption.filer
+ @parent.filer
end
end
class ActionLink < BaseLink
- attr :action_name
+ attr :action_name
def set_default
super
- @link_manifest['args']['action_name'] ||= 'show'
+ @args['action_name'] ||= 'show'
end
def init
end
class UrlColumnLink < BaseLink
- attr :column_name
+ attr :column_name
def set_default
super
- @link_manifest['args']['column_name'] ||= 'url'
+ @args['column_name'] ||= 'url'
end
def init
def set_default
super
- @caption_manifest['args']['template_name'] ||= 'caption'
+ @args['template_name'] ||= 'caption'
end
def init
-require_dependency "local_manifest/filer/date/date"
+ManifestBase.require_modules "local_manifest/filer/date/",
+ %w|date|
+
module LocalManifest
module FilerModule
- class DateFactory
+ class DateFactory < ManifestBase::Factory
include DateModule
- @@types = {
- 'default' => Base
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'default'
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.filer_name} > date\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.filer_name} > date > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'default' => Base
+ }
+ end
+
+ def self.default_type
+ 'default'
end
end
module LocalManifest
module FilerModule
module DateModule
- class Base
- attr :filer, :date_manifest, :type
-
- def initialize filer, date_manifest
- @filer = filer
- @date_manifest = date_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @date_manifest['args'] ||= {}
+ super
end
def init
- @type = @date_manifest['type']
- @args = @date_manifest['args']
+ super
end
def visible?
-require_dependency "local_manifest/filer/edit/edit"
+ManifestBase.require_modules "local_manifest/filer/edit/",
+ %w|edit|
+
module LocalManifest
module FilerModule
- class EditFactory
+ class EditFactory < ManifestBase::Factory
include EditModule
- @@types = {
- 'default' => Default, 'none' => None, 'template' => Template, 'account' => Account
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'default'
- type = my_manifest['type']
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.item_name} > edit\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.item_name} > edit > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'default' => Default, 'none' => None, 'template' => Template,
+ 'account' => Account
+ }
+ end
+
+ def self.default_type
+ 'default'
end
end
module LocalManifest
module FilerModule
- module EditModule
- class Base
- attr :filer, :edit_manifest, :type
-
- def initialize filer, edit_manifest
- @filer = filer
- @edit_manifest = edit_manifest
- self.set_default
- self.init
- end
+ module EditModule
+ class Base < ManifestBase::TypeArgs
def set_default
- @edit_manifest['args'] ||= {}
+ super
end
def init
- @type = @edit_manifest['type']
- @args = @edit_manifest['args']
+ super
end
def visible?
def set_default
super
- @edit_manifest['args']['template_name'] ||= 'edit'
+ @args['template_name'] ||= 'edit'
end
def init
-require_dependency "local_manifest/filer/icon/icon"
+ManifestBase.require_modules "local_manifest/filer/icon/",
+ %w|icon|
+
module LocalManifest
module FilerModule
- class IconFactory
+ class IconFactory < ManifestBase::Factory
include IconModule
- @@types = {
- 'default' => Base
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'default'
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.filer_name} > icon\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.filer_name} > icon > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'default' => Base
+ }
+ end
+
+ def self.default_type
+ 'default'
end
end
module LocalManifest
module FilerModule
module IconModule
- class Base
- attr :filer, :icon_manifest, :type
-
- def initialize filer, icon_manifest
- @filer = filer
- @icon_manifest = icon_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @icon_manifest['args'] ||= {}
+ super
end
def init
- @type = @icon_manifest['type']
- @args = @icon_manifest['args']
+ super
end
def visible?
-require_dependency "local_manifest/filer/summary/summary"
+ManifestBase.require_modules "local_manifest/filer/summary/",
+ %w|summary|
+
module LocalManifest
module FilerModule
- class SummaryFactory
+ class SummaryFactory < ManifestBase::Factory
include SummaryModule
- @@types = {
- 'none' => None, 'template' => Template
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'template'
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.filer_name} > summary\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.filer_name} > summary > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'none' => None, 'template' => Template
+ }
+ end
+
+ def self.default_type
+ 'template'
end
end
module LocalManifest
module FilerModule
- module SummaryModule
- class Base
- attr :filer, :summary_manifest, :type
-
- def initialize filer, summary_manifest
- @filer = filer
- @summary_manifest = summary_manifest
- self.set_default
- self.init
- end
+ module SummaryModule
+ class Base < ManifestBase::TypeArgs
def set_default
- @summary_manifest['args'] ||= {}
+ super
end
def init
- @type = @summary_manifest['type']
- @args = @summary_manifest['args']
+ super
end
def visible?
def set_default
super
- @summary_manifest['args']['template_name'] ||= 'summary'
+ @args['template_name'] ||= 'summary'
end
def init
-require_dependency "local_manifest/filer/symbol/base"
-require_dependency "local_manifest/filer/symbol/default"
-require_dependency "local_manifest/filer/symbol/template"
+ManifestBase.require_modules "local_manifest/filer/symbol/",
+ %w|base default template|
+
module LocalManifest
module FilerModule
- class SymbolFactory
+ class SymbolFactory < ManifestBase::Factory
include SymbolModule
- @@types = {
- 'default' => Default, 'template' => Template
- }
- def self.factory filer, my_manifest
- my_manifest['type'] ||= 'default'
- type = my_manifest['type']
- raise "undefined type for filers > #{filer.filer_name} > symbol\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{filer.filer_name} > symbol > #{type}\n" unless my_class
- my_class.new(filer, my_manifest)
+ def self.types
+ {
+ 'default' => Default, 'template' => Template
+ }
+ end
+
+ def self.default_type
+ 'default'
end
end
module LocalManifest
module FilerModule
module SymbolModule
- class Base
- attr :filer, :symbol_manifest, :type
-
- def initialize filer, symbol_manifest
- @filer = filer
- @symbol_manifest = symbol_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @symbol_manifest['args'] ||= {}
+ super
end
def init
- @type = @symbol_manifest['type']
- @args = @symbol_manifest['args']
+ super
end
def visible?
end
def filer_name
- @filer.item_name
+ @parent.name
end
- def filer_manifest
- @filer.filer_manifest
+ def filer
+ @parent
end
end
-require_dependency "local_manifest/filer/symbol/default/face"
-require_dependency "local_manifest/filer/symbol/default/link"
+ManifestBase.require_modules "local_manifest/filer/symbol/default/",
+ %w|face link|
+
module LocalManifest
module FilerModule
module SymbolModule
def set_default
super
- @symbol_manifest['args']['face'] ||= {}
- @symbol_manifest['args']['link'] ||= {}
+ @args['face'] ||= {}
+ @args['link'] ||= {}
end
def init
super
- @face = FaceFactory.factory(self, @args['face'])
- @link = LinkFactory.factory(self, @args['link'])
+ @face = ManifestBase.load_type_args self, @args, 'face', FaceFactory
+ @link = ManifestBase.load_type_args self, @args, 'link', LinkFactory
end
def visible?
-require_dependency "local_manifest/filer/symbol/default/face/face"
+ManifestBase.require_modules "local_manifest/filer/symbol/default/face/",
+ %w|face|
+
module LocalManifest
module FilerModule
module SymbolModule
module DefaultModule
- class FaceFactory
+ class FaceFactory < ManifestBase::Factory
include FaceModule
- @@types = {
- 'image' => ImageFace, 'picture' => PictureFace
- }
- def self.factory default_symbol, my_manifest
- my_manifest['type'] ||= 'image'
- type = my_manifest['type']
- raise "undefined type for filers > #{default_symbol.filer_name} > symbol > default > face\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{default_symbol.filer_name} > symbol > default > face > #{type}\n" unless my_class
- my_class.new(default_symbol, my_manifest)
+
+ def self.types
+ {
+ 'image' => ImageFace, 'picture' => PictureFace
+ }
+ end
+
+ def self.default_type
+ 'image'
end
end
-
end
end
end
module SymbolModule
module DefaultModule
module FaceModule
- class BaseFace
- attr :symbol, :face_manifest, :type
-
- def initialize symbol, face_manifest
- @symbol = symbol
- @face_manifest = face_manifest
- self.set_default
- self.init
- end
+ class BaseFace < ManifestBase::TypeArgs
def set_default
- @face_manifest['args'] ||= {}
+ super
end
def init
- @type = @face_manifest['type']
- @args = @face_manifest['args']
+ super
+ end
+
+ def filer
+ @parent.filer
end
- def filer
- @symbol.filer
- end
-
end
class ImageFace < BaseFace
def set_default
super
- @face_manifest['args']['url'] ||= '/images/' + self.filer.item_name + '.gif'
+ @args['url'] ||= '/images/' + self.filer.item_name + '.gif'
end
def init
def set_default
super
- @face_manifest['args']['method_name'] ||= 'symbol_option'
+ @args['method_name'] ||= 'symbol_option'
end
def init
-require_dependency "local_manifest/filer/symbol/default/link/link"
+ManifestBase.require_modules "local_manifest/filer/symbol/default/link/",
+ %w|link|
+
module LocalManifest
module FilerModule
module SymbolModule
module DefaultModule
- class LinkFactory
+ class LinkFactory < ManifestBase::Factory
include LinkModule
- @@types = {
- 'action' => ActionLink, 'none' => NoneLink, 'url_column' => UrlColumnLink
- }
- def self.factory default_symbol, my_manifest
- my_manifest['type'] ||= 'action'
- type = my_manifest['type']
- raise "undefined type for filers > #{default_symbol.filer_name} > symbol > default > link\n" unless type
- my_class = @@types[type]
- raise "undefined class for filers > #{default_symbol.filer_name} > symbol > default > link > #{type}\n" unless my_class
- my_class.new(default_symbol, my_manifest)
+
+ def self.types
+ {
+ 'action' => ActionLink, 'none' => NoneLink, 'url_column' => UrlColumnLink
+ }
+ end
+
+ def self.default_type
+ 'action'
end
end
-
end
end
end
module SymbolModule
module DefaultModule
module LinkModule
- class BaseLink
- attr :symbol, :link_manifest, :type
-
- def initialize symbol, link_manifest
- @symbol = symbol
- @link_manifest = link_manifest
- self.set_default
- self.init
- end
+ class BaseLink < ManifestBase::TypeArgs
def set_default
- @link_manifest['args'] ||= {}
+ super
end
def init
- @type = @link_manifest['type']
- @args = @link_manifest['args']
+ super
end
def filer
- @symbol.filer
+ @parent.filer
end
end
class ActionLink < BaseLink
- attr :action_name
+ attr :action_name
def set_default
super
- @link_manifest['args']['action_name'] ||= 'show'
+ @args['action_name'] ||= 'show'
end
def init
end
class UrlColumnLink < BaseLink
- attr :column_name
+ attr :column_name
def set_default
super
- @link_manifest['args']['column_name'] ||= 'url'
+ @args['column_name'] ||= 'url'
end
def init
def set_default
super
- @symbol_manifest['args']['template_name'] ||= 'symbol'
+ @args['template_name'] ||= 'symbol'
end
def init
-require_dependency "local_manifest/list_group/list"
+ManifestBase.require_modules "local_manifest/list_group/",
+ %w|list|
+
module LocalManifest
- class ListGroup
+ class ListGroup < ManifestBase::Base
include ListGroupModule
- def self.manager manifest, my_manifests
- list_groups = {}
- my_manifests.each {|item_name, list_group_manifest|
- list_groups[item_name] = ListGroup.new(manifest, item_name, list_group_manifest)
- }
- list_groups
- end
- attr :manifest, :list_group_name, :list_group_manifest,
- :item_name, :tree_name, :lists
- def initialize manifest, list_group_name, list_group_manifest
- @manifest = manifest
- @list_group_name = list_group_name
- @list_group_manifest = list_group_manifest
- self.set_default
- self.init
- end
+ attr :item_name, :tree_name, :lists
def set_default
- @list_group_manifest['item_name'] ||= @list_group_name
- @list_group_manifest['lists'] ||= {}
+ super
+ @json['item_name'] ||= @name
+ @json['lists'] ||= {}
end
def init
- @item_name = @list_group_manifest['item_name']
- @tree_name = @list_group_manifest['tree_name']
- @lists = {}
- @list_group_manifest['lists'].each {|list_name, list_manifest|
- @lists[list_name] = ListFactory.factory self, list_name, list_manifest
- }
+ super
+ @item_name = @json['item_name']
+ @tree_name = @json['tree_name']
+ @lists = ManifestBase.load_type_name_args self, @json, 'lists', ListFactory
end
end
-require_dependency "local_manifest/list_group/list/base"
-require_dependency "local_manifest/list_group/list/public"
-require_dependency "local_manifest/list_group/list/private"
-require_dependency "local_manifest/list_group/list/system_resource"
-require_dependency "local_manifest/list_group/list/filter"
-require_dependency "local_manifest/list_group/list/through_filter"
-require_dependency "local_manifest/list_group/list/foreign_filter"
-require_dependency "local_manifest/list_group/list/play"
+ManifestBase.require_modules "local_manifest/list_group/list/",
+ %w|base public private system_resource filter through_filter foreign_filter play|
+
module LocalManifest
module ListGroupModule
- class ListFactory
+ class ListFactory < ManifestBase::Factory
include ListModule
def self.types
}
end
- def self.factory list_group, list_name, my_manifest
- my_manifest['type'] ||= 'public'
- type = my_manifest['type']
- raise "undefined type for list_groups > #{list_group.item_name} > #{list_name}\n" unless type
- my_class = self.types[type]
- raise "undefined class for list_groups > #{list_group.item_name} > #{list_name} > #{type}\n" unless my_class
- my_class.new(list_group, list_name, my_manifest)
+ def self.default_type
+ 'public'
end
end
-require_dependency "local_manifest/list_group/list/where"
-require_dependency "local_manifest/list_group/list/includes"
+ManifestBase.require_modules "local_manifest/list_group/list/",
+ %w|where includes|
+
module LocalManifest
module ListGroupModule
module ListModule
- class Base
- attr :list_group, :list_name, :list_manifest, :type,
- :model_manifest, :model_list_manifest, :model,
+ class Base < ManifestBase::TypeNameArgs
+ attr :model_manifest, :model_list_manifest, :model,
:where, :includes, :tree_name
- def initialize list_group, list_name, list_manifest
- @list_group = list_group
- @list_name = list_name
- @list_manifest = list_manifest
- self.set_default
- self.init
- end
def set_default
- @list_manifest['args'] ||= {}
- @list_manifest['args']['where'] ||= {}
- @list_manifest['args']['includes'] ||= {}
- @list_manifest['args']['tree_name'] ||= @list_group.tree_name
+ super
+ @args['where'] ||= {}
+ @args['includes'] ||= {}
+ @args['tree_name'] ||= @parent.tree_name
end
def init
- @type = @list_manifest['type']
- @args = @list_manifest['args']
- @where = WhereFactory.factory self, @args['where']
- @includes = IncludeFactory.factory self, @args['includes']
+ super
+ @where = ManifestBase.load_type_args self, @args, 'where', WhereFactory
+ @includes = ManifestBase.load_type_args self, @args, 'includes', IncludeFactory
@tree_name = @args['tree_name']
@model_manifest = ::Manifest.manifest.models[self.item_name]
end
def item_name
- @list_group.item_name
+ @parent.item_name
+ end
+
+ def list_group
+ @parent
end
end
def set_default
super
- @list_manifest['args']['filter_item_name'] ||= @list_name.gsub(/^by_/, '')
- @list_manifest['args']['filter_key'] ||= @list_manifest['args']['filter_item_name'] + '_id'
+ @args['filter_item_name'] ||= @name.gsub(/^by_/, '')
+ @args['filter_key'] ||= @args['filter_item_name'] + '_id'
end
def init
def set_default
super
- @list_manifest['args']['tree_name'] ||= 'owner'
+ @args['tree_name'] ||= 'owner'
end
def init
-require_dependency "local_manifest/list_group/list/includes/base"
-require_dependency "local_manifest/list_group/list/includes/method"
-require_dependency "local_manifest/list_group/list/includes/auto"
-require_dependency "local_manifest/list_group/list/includes/none"
+ManifestBase.require_modules "local_manifest/list_group/list/includes/",
+ %w|base method auto none|
+
module LocalManifest
module ListGroupModule
module ListModule
- class IncludeFactory
+ class IncludeFactory < ManifestBase::Factory
include IncludeModule
- @@types = {
- 'method' => IncludeMethod, 'auto' => IncludeAuto, 'none' => IncludeNone
- }
- def self.factory list, my_manifest
- my_manifest['type'] ||= 'auto'
- type = my_manifest['type']
- raise "undefined type for lists > #{list.item_name} > #{list.list_name} > includes\n" unless type
- my_class = @@types[type]
- raise "undefined class for lists > #{list.item_name} > #{list.list_name} > includes > #{type}\n" unless my_class
- my_class.new(list, my_manifest)
+ def self.types
+ {
+ 'method' => IncludeMethod, 'auto' => IncludeAuto, 'none' => IncludeNone
+ }
+ end
+
+ def self.default_type
+ 'auto'
end
end
module IncludeModule
class IncludeAuto < Base
attr :tree_name
+
def set_default
super
- @includes_manifest['args']['tree_name'] ||= @list.tree_name
+ @args['tree_name'] ||= @parent.tree_name
end
def init
end
def tree_manifest
- self.model_manifest.tree[@list.list_group.tree_name]
+ self.model_manifest.tree[self.list_group.tree_name]
end
def includes
end
end
+ def list_group
+ @parent.list_group
+ end
+
end
end
module ListGroupModule
module ListModule
module IncludeModule
- class Base
- attr :list, :includes_manifest, :type
- def initialize list, includes_manifest
- @list = list
- @includes_manifest = includes_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @includes_manifest['args'] ||= {}
+ super
end
def init
- @type = @includes_manifest['type']
- @args = @includes_manifest['args']
+ super
end
def item_name
- @list.item_name
+ @parent.item_name
end
def list_name
- @list.list_name
+ @parent.list_name
end
def model
- @list.model
+ @parent.model
end
end
module IncludeModule
class IncludeMethod < Base
attr :method_name
+
def set_default
super
- @includes_manifest['args']['method_name'] ||= self.list_name + '_list_includes'
+ @args['method_name'] ||= @parent.name + '_list_includes'
end
def init
module LocalManifest
module ListGroupModule
module ListModule
- class PlayList
- attr :list_group, :list_name, :list_manifest
-
- def initialize list_group, list_name, list_manifest
- @list_group = list_group
- @list_name = list_name
- @list_manifest = list_manifest
- self.set_default
- self.init
- end
+ class PlayList < Base
def set_default
return
-require_dependency "local_manifest/list_group/list/where/base"
-require_dependency "local_manifest/list_group/list/where/method"
-require_dependency "local_manifest/list_group/list/where/auto"
+ManifestBase.require_modules "local_manifest/list_group/list/where/",
+ %w|base method auto|
+
module LocalManifest
module ListGroupModule
module ListModule
- class WhereFactory
+ class WhereFactory < ManifestBase::Factory
include WhereModule
- @@types = {
- 'method' => WhereMethod, 'auto' => WhereAuto
- }
- def self.factory list, my_manifest
- my_manifest['type'] ||= 'auto'
- type = my_manifest['type']
- raise "undefined type for lists > #{list.item_name} > #{list.list_name} > where\n" unless type
- my_class = @@types[type]
- raise "undefined class for lists > #{list.item_name} > #{list.list_name} > where > #{type}\n" unless my_class
- my_class.new(list, my_manifest)
+ def self.types
+ {
+ 'method' => WhereMethod, 'auto' => WhereAuto
+ }
+ end
+
+ def self.default_type
+ 'auto'
end
end
module ListGroupModule
module ListModule
module WhereModule
- class Base
- attr :list, :where_manifest, :type
- def initialize list, where_manifest
- @list = list
- @where_manifest = where_manifest
- self.set_default
- self.init
- end
+ class Base < ManifestBase::TypeArgs
def set_default
- @where_manifest['args'] ||= {}
+ super
end
def init
- @type = @where_manifest['type']
- @args = @where_manifest['args']
+ super
end
def item_name
- @list.item_name
+ @parent.item_name
end
def list_name
- @list.list_name
+ @parent.list_name
end
def model
- @list.model
+ @parent.model
end
end
module WhereModule
class WhereMethod < Base
attr :method_name
+
def set_default
super
- @where_manifest['args']['method_name'] ||= self.list_name + '_list_where'
+ @args['method_name'] ||= @parent.name + '_list_where'
end
def init
module LocalManifest
class LocalManifest
cattr_accessor :manifest
- attr :list_groups, :profilers, :filers, :forms
+ attr :list_groups, :profilers, :filers, :forms, :module_names
# call me before load routes.rb
# routes.rb needs engine_resources manifest in system_resources
# ex. it's adding license_groups routes
def initialize local_json
+ @module_names = []
@local_json = local_json || {}
end
def init
# managers can't initialize before load application.rb
return unless defined? ::Pettanr
- @list_groups = ListGroup.manager(self, @local_json['list_groups'] || {})
- @filers = Filer.manager(self, @local_json['filers'] || {})
- @profilers = Profiler.manager(self, @local_json['profilers'] || {})
+ @list_groups = ListGroup.load(self, @local_json, 'list_groups')
+ @filers = Filer.load(self, @local_json, 'filers')
+ @profilers = Profiler.load(self, @local_json, 'profilers')
@forms = Form.base_manager(self, @local_json['forms'] || {})
@forms.merge(Form.extend_manager(self, @local_json['forms'] || {}))
end
-require_dependency "local_manifest/profiler/column"
-require_dependency "local_manifest/profiler/list"
-require_dependency "local_manifest/profiler/association"
+ManifestBase.require_modules "local_manifest/profiler/",
+ %w|list association|
+
module LocalManifest
- class Profiler
-
- def self.manager manifest, my_manifests
- profilers = {}
- my_manifests.each {|item_name, profiler_manifest|
- profilers[item_name] = self.new(manifest, item_name, profiler_manifest)
- }
- profilers
- end
+ class Profiler < ManifestBase::Base
+ include ProfilerModule
- attr :profiler_manifest, :item_name, :manifest,
- :column_names, :lists, :associations
- def initialize manifest, item_name, profiler_manifest
- @manifest = manifest
- @item_name = item_name
- @profiler_manifest = profiler_manifest
- self.set_default
- self.init
- end
+ attr :column_names, :lists, :associations
def set_default
- @profiler_manifest['column_names'] ||= []
- @profiler_manifest['lists'] ||= {}
- @profiler_manifest['associations'] ||= {}
+ super
+ @json['column_names'] ||= []
+ @json['lists'] ||= {}
+ @json['associations'] ||= {}
end
def init
- @column_names = ['id'] + @profiler_manifest['column_names'] + ['created_at', 'updated_at']
- @lists = {}
- @profiler_manifest['lists'].each {|list_name, list_manifest|
- @lists[list_name] = ProfilerModule::List.new(self, list_name, list_manifest)
- }
- @associations = ProfilerModule::Association.new(self, @profiler_manifest['associations'])
+ super
+ @column_names = ['id'] + @json['column_names'] + ['created_at', 'updated_at']
+ @lists = ManifestBase.load_type_name_args self, @json, 'lists', List
+ @associations = ManifestBase.load_value self, @json, 'associations', Association
+ end
+
+ def item_name
+ @name
end
def each_column
-require_dependency "local_manifest/profiler/association/belongs_to"
-require_dependency "local_manifest/profiler/association/has_many"
-require_dependency "local_manifest/profiler/association/has_one"
+ManifestBase.require_modules "local_manifest/profiler/association/",
+ %w|belongs_to has_many has_one|
+
module LocalManifest
module ProfilerModule
- class Association
+ class Association < ManifestBase::Values
include AssociationModule
- attr :profiler, :association_manifest,
- :belongs_to, :has_many, :has_one
- def initialize profiler, association_manifest
- @profiler = profiler
- @association_manifest = association_manifest
- self.set_default
- self.init
- end
+ attr :belongs_to, :has_many, :has_one
def set_default
- @association_manifest['belongs_to'] ||= []
- @association_manifest['has_many'] ||= []
- @association_manifest['has_one'] ||= []
+ super
+ @values['belongs_to'] ||= []
+ @values['has_many'] ||= []
+ @values['has_one'] ||= []
end
def init
- @belongs_to = []
- @has_many = []
- @has_one = []
- @association_manifest['belongs_to'].each {|model_name|
- @belongs_to << BelongsTo.new(self, model_name)
- }
- @association_manifest['has_many'].each {|list_name|
- @has_many << HasMany.new(self, list_name)
- }
- @association_manifest['has_one'].each {|list_name|
- @has_one << HasOne.new(self, list_name)
- }
+ super
+ @belongs_to = ManifestBase.load_names self, @values, 'belongs_to', BelongsTo
+ @has_many = ManifestBase.load_names self, @values, 'has_many', HasMany
+ @has_one = ManifestBase.load_names self, @values, 'has_one', HasOne
end
- def profiler_name
- @profiler.model_name
+ def profiler
+ @parent
end
- def profiler_manifest
- @profiler.profiler_manifest
+ def profiler_name
+ @parent.name
end
end
module LocalManifest
module ProfilerModule
module AssociationModule
- class BelongsTo
- attr :association, :model_name
- def initialize association, model_name
- @association = association
- @model_name = model_name
- self.set_default
- self.init
- end
+ class BelongsTo < ManifestBase::Names
+ attr :model_name
def set_default
+ super
end
def init
+ super
+ @model_name = @name
end
def model
end
def association_name
- @association.association_name
+ @parent.name
end
end
module LocalManifest
module ProfilerModule
module AssociationModule
- class HasMany
- attr :association, :profiler_list_name,
- :model_name, :list_name, :list
- def initialize association, profiler_list_name
- @association = association
- @profiler_list_name = profiler_list_name
- self.set_default
- self.init
- end
+ class HasMany < ManifestBase::Names
+ attr :model_name, :list_name, :list
def set_default
+ super
end
def init
- if list_manifest = self.profiler.lists[@profiler_list_name]
+ super
+ if list_manifest = self.profiler.lists[@name]
@model_name = list_manifest.model_name
@list_name = list_manifest.list_name
else
- n = @profiler_list_name.split '.'
+ n = @name.split '.'
if n.size > 1
@table_name = n[0]
@model_name = @table_name.singularize
@list_name = n[1]
else
- raise "undefined list for profilers > #{self.profiler.item_name} > has_many > #{@profiler_list_name}\n"
+ ManifestBase::alert_undefined_message 'list', self.module_message
end
end
@list = Locmare::ListGroup.list @model_name, @list_name
end
def association_name
- @association.association_name
+ @parent.association_name
end
def profiler
- @association.profiler
+ @parent.profiler
end
def profiler_manifest
- @association.profiler_manifest
+ @parent.profiler_manifest
end
end
module LocalManifest
module ProfilerModule
module AssociationModule
- class HasOne
- attr :association, :profiler_list_name,
- :model_name, :list_name, :list
- def initialize association, profiler_list_name
- @association = association
- @profiler_list_name = profiler_list_name
- self.set_default
- self.init
- end
+ class HasOne < ManifestBase::Names
+ attr :model_name, :list_name, :list
def set_default
+ super
end
def init
- if list_manifest = self.profiler.lists[@profiler_list_name]
- @model_name = list_manifest.model_name
- @list_name = list_manifest.list_name
+ super
+ if list_manifest = self.profiler.lists[@name]
+ @model_name = @parent.model_name
+ @list_name = @parent.list_name
else
- n = @profiler_list_name.split '.'
+ n = @name.split '.'
if n.size > 1
@model_name = n[0]
@list_name = n[1]
else
- raise "undefined list for profilers > #{self.profiler.item_name} > has_one > #{@profiler_list_name}\n"
+ ManifestBase::alert_undefined_message 'list', self.module_message
end
end
@list = Locmare::ListGroup.list @model_name, @list_name
end
def association_name
- @association.association_name
+ @parent.association_name
end
def profiler
- @association.profiler
+ @parent.profiler
end
def profiler_manifest
- @association.profiler_manifest
+ @parent.profiler_manifest
end
end
+++ /dev/null
-module LocalManifest
- module ProfilerModule
- class Column
- def initialize item_name, column_name, item, operators, manifest
- @item_name = item_name
- @column_name = column_name
- @item = item
- @operators = operators
- @manifest = manifest
-
- @model = @item_name.classify.constantize
- @model_attributes = @manifest.model(@item_name).attributes
- @column_conf = @model_attributes[@column_name]
- end
-
- def label view
- @model.human_attribute_name(@column_name)
- end
-
- def date?
- case @column_conf['type']
- when 'datetime'
- if self.value
- true
- else
- false
- end
- else
- false
- end
- end
-
- def value
- @item.attributes[@column_name]
- end
-
- def disp_value view
- if self.date?
- view.l self.value
- else
- self.value
- end
- end
-
- def note?
- if @column_conf['source']
- case @column_conf['source']['type']
- when 'magic_number'
- true
- when 'model'
- false
- else
- false
- end
- else
- false
- end
- end
-
- def note view
- if self.note?
- '(' + view.t_selected_item(@column_conf['source']['key'], self.value) + ')'
- else
- end
- end
-
- end
-
- end
-end
attr :item_name, :actions
def set_default
+ super
@json['item_name'] ||= ::Manifest.singularize(@name)
@json['actions'] ||= {}
end
def init
+ super
@item_name = @json['item_name']
- @actions = ManifestBase.load_type_name_args self, @json, 'actions', ActionFactory, 'list'
+ @actions = ManifestBase.load_type_name_args self, @json, 'actions', ActionFactory
end
end
}
end
+ def self.default_type
+ 'list'
+ end
+
end
end
def set_default
super
- @args ||= {}
@args['item_name'] ||= self.parent.item_name # not parent.name. follow singularized name
end
attr :attributes, :associations, :tree, :list, :peta, :extend_column_name
def set_default
+ super
@json['attributes'] ||= {}
@json['associations'] ||= {}
@json['tree'] ||= {}
end
def init
+ super
@attributes = ManifestBase.load_name_values self, @json, 'attributes', Attribute
@associations = ManifestBase.load_value self, @json, 'associations', Association
@tree = {}
@json['tree'].each {|tree_name, parent_model_name|
@tree[tree_name] = Tree.new(self, tree_name, parent_model_name)
}
- @peta = ManifestBase.load_type_args(self, @json, 'peta', PetaFactory, 'item')
+ @peta = ManifestBase.load_type_args(self, @json, 'peta', PetaFactory)
@extend_column_name = @json['extend_column_name']
- @list = List.new(self, @json['list'])
+ @list = ManifestBase.load_value self, @json, 'list', List
end
def model_name
-require_dependency "manifest/model/association/belongs_to"
-require_dependency "manifest/model/association/has_many"
-require_dependency "manifest/model/association/has_one"
+ManifestBase.require_modules "manifest/model/association/",
+ %w|belongs_to has_many has_one|
+
module Manifest
module ModelModule
class Association < ManifestBase::Values
def set_default
super
- @args['belongs_to'] ||= {}
- @args['has_many'] ||= {}
- @args['has_one'] ||= {}
+ @values['belongs_to'] ||= {}
+ @values['has_many'] ||= {}
+ @values['has_one'] ||= {}
end
def init
super
- @belongs_to = {}
- @has_many = {}
- @has_one = {}
- @args['belongs_to'].each {|name, json|
- @belongs_to[name] = BelongsTo.new(self, name, json)
- }
- @args['has_many'].each {|name, json|
- @has_many[name] = HasMany.new(self, name, json)
- }
- @args['has_one'].each {|name, json|
- @has_one[name] = HasOne.new(self, name, json)
- }
+ @belongs_to = ManifestBase.load_name_values self, @values, 'belongs_to', BelongsTo
+ @has_many = ManifestBase.load_name_values self, @values, 'has_many', HasMany
+ @has_one = ManifestBase.load_name_values self, @values, 'has_one', HasOne
end
def model_name
module Manifest
module ModelModule
module AssociationModule
- class BelongsTo
- attr :association, :belongs_to_name, :belongs_to_manifest,
- :id_column, :model_name
- def initialize association, belongs_to_name, belongs_to_manifest
- @association = association
- @belongs_to_name = belongs_to_name
- @belongs_to_manifest = belongs_to_manifest
- self.set_default
- self.init
- end
+ class BelongsTo < ManifestBase::NameValues
+ attr :id_column, :model_name
def set_default
- @belongs_to_manifest['model_name'] ||= @belongs_to_name
- @belongs_to_manifest['id_column'] ||= @belongs_to_name + '_id'
+ super
+ @values['model_name'] ||= @name
+ @values['id_column'] ||= @name + '_id'
end
def init
- @model_name = @belongs_to_manifest['model_name']
- @id_column = @belongs_to_manifest['id_column']
+ super
+ @model_name = @values['model_name']
+ @id_column = @values['id_column']
end
def model
end
def association_name
- @association.association_name
+ @parent.association_name
end
end
module Manifest
module ModelModule
module AssociationModule
- class HasMany
- attr :association, :has_many_name, :has_many_manifest,
- :model_name, :foreign_key, :through
- def initialize association, has_many_name, has_many_manifest
- @association = association
- @has_many_name = has_many_name
- @has_many_manifest = has_many_manifest
- self.set_default
- self.init
- end
+ class HasMany < ManifestBase::NameValues
+ attr :model_name, :foreign_key, :through
def set_default
- @has_many_manifest['model_name'] ||= @has_many_name.singularize
- @has_many_manifest['foreign_key'] ||= @association.model_name + '_id'
+ super
+ @values['model_name'] ||= @name.singularize
+ @values['foreign_key'] ||= @parent.model_name + '_id'
end
def init
- @model_name = @has_many_manifest['model_name']
- @foreign_key = @has_many_manifest['foreign_key']
- @through = @has_many_manifest['through']
+ super
+ @model_name = @values['model_name']
+ @foreign_key = @values['foreign_key']
+ @through = @values['through']
end
def model
end
def association_name
- @association.association_name
+ @parent.association_name
end
end
module Manifest
module ModelModule
module AssociationModule
- class HasOne
- attr :association, :has_one_name, :has_one_manifest,
- :model_name, :foreign_key
- def initialize association, has_one_name, has_one_manifest
- @association = association
- @has_one_name = has_one_name
- @has_one_manifest = has_one_manifest
- self.set_default
- self.init
- end
+ class HasOne < ManifestBase::NameValues
+ attr :model_name, :foreign_key
def set_default
- @has_one_manifest['model_name'] ||= @has_one_name
- @has_one_manifest['foreign_key'] ||= @association.model_name + '_id'
+ super
+ @values['model_name'] ||= @name
+ @values['foreign_key'] ||= @parent.model_name + '_id'
end
def init
- @model_name = @has_one_manifest['model_name']
- @foreign_key = @has_one_manifest['foreign_key']
+ super
+ @model_name = @values['model_name']
+ @foreign_key = @values['foreign_key']
end
def model
end
def association_name
- @association.association_name
+ @parent.association_name
end
end
def set_default
super
- raise "undefined type for #{self.module_message}\n" unless @args['type']
- @args['primary_key'] ||= 0
- @args['rules'] ||= {}
+ ManifestBase.alert_undefined_message 'type', self.module_message unless @values['type']
+ @values['primary_key'] ||= 0
+ @values['rules'] ||= {}
end
def init
super
- @primary_key = @args['primary_key']
- @rules = @args['rules']
- if @args['source']
- @source = SourceFactory.factory(self, @name, @args['source'])
+ @primary_key = @values['primary_key']
+ @rules = @values['rules']
+ if @values['source']
+ @source = ManifestBase.load_type_args self, @values, 'source', SourceFactory
end
end
+ def model_name
+ @parent.name
+ end
+
end
end
-require_dependency "manifest/model/attribute/source/model"
-require_dependency "manifest/model/attribute/source/magic_number"
+ManifestBase.require_modules "manifest/model/attribute/source/",
+ %w|base model magic_number|
+
module Manifest
module ModelModule
module AttributeModule
- class SourceFactory
+ class SourceFactory < ManifestBase::Factory
include SourceModule
- @@types = {
- 'model' => ModelSource, 'magic_number' => MagicNumberSource
- }
- def self.factory attribute, attribute_name, my_manifest
- type = my_manifest['type']
- raise "undefined type for models > #{attribute.mode_name} > attributes > #{attribute_name} > source\n" unless type
- my_class = @@types[type]
- raise "undefined class for models > #{attribute.mode_name} > attributes > #{attribute_name} > source > #{type}\n" unless my_class
- my_class.new(attribute, my_manifest)
+
+ def self.types
+ {
+ 'model' => ModelSource, 'magic_number' => MagicNumberSource
+ }
+ end
+
+ def self.default_type
+ 'magic_number'
end
end
--- /dev/null
+module Manifest
+ module ModelModule
+ module AttributeModule
+ module SourceModule
+ class Base < ManifestBase::TypeArgs
+
+ def set_default
+ super
+ end
+
+ def init
+ super
+ end
+
+ def model_name
+ @parent.model_name
+ end
+
+ end
+
+ end
+ end
+ end
+end
module ModelModule
module AttributeModule
module SourceModule
- class MagicNumberSource
- attr :attribute, :source_manifest, :type, :select_item_name
-
- def initialize attribute, source_manifest
- @attribute = attribute
- @source_manifest = source_manifest
- self.set_default
- self.init
- end
+ class MagicNumberSource < Base
+ attr :select_item_name
def set_default
- @source_manifest['args'] ||= {}
- raise "undefined select_item_name for models > #{@attribute.model_name} > attributes > #{@attribute.attribute_name} > source\n" unless @source_manifest['args']['select_item_name']
+ super
+ ManifestBase.alert_undefined_message 'select_item_name', self.module_message unless @args['select_item_name']
end
def init
- @args = @source_manifest['args']
- @type = @source_manifest['type']
+ super
@select_item_name = @args['select_item_name']
end
- def model_name
- @attribute.model_name
- end
-
- def attribute_name
- @attribute.attribute_name
- end
-
end
end
module ModelModule
module AttributeModule
module SourceModule
- class ModelSource
- attr :attribute, :source_manifest, :type,
- :resource_model_name, :resource_list_name, :select_item_name, :caption_name
-
- def initialize attribute, source_manifest
- @attribute = attribute
- @source_manifest = source_manifest
- self.set_default
- self.init
- end
+ class ModelSource < Base
+ attr :resource_model_name, :resource_list_name,
+ :select_item_name, :caption_name
def set_default
- @source_manifest['args'] ||= {}
- @source_manifest['args']['resource_model_name'] ||= (@attribute.name.gsub('_id', ''))
- @source_manifest['args']['resource_list_name'] ||= 'select_items'
- @source_manifest['args']['select_item_name'] ||= self.model_name + '_' + @attribute.name.gsub('_id', '') + '_items'
- @source_manifest['args']['caption_name'] ||= 'caption'
+ super
+ @args['resource_model_name'] ||= (@parent.name.gsub('_id', ''))
+ @args['resource_list_name'] ||= 'select_items'
+ @args['select_item_name'] ||= self.model_name + '_' + @parent.name.gsub('_id', '') + '_items'
+ @args['caption_name'] ||= 'caption'
end
def init
- @args = @source_manifest['args']
- @type = @source_manifest['type']
+ super
@resource_model_name = @args['resource_model_name']
@resource_list_name = @args['resource_list_name']
@select_item_name = @args['select_item_name']
@caption_name = @args['caption_name']
end
- def model_name
- @attribute.parent_name
- end
-
- def attribute_name
- @attribute.name
- end
-
end
end
module Manifest
module ModelModule
- class List
- attr :model, :list_manifest,
- :default_page_size, :max_page_size
- def initialize model, list_manifest
- @model = model
- @list_manifest = list_manifest
- self.set_default
- self.init
- end
+ class List < ManifestBase::Values
+ attr :default_page_size, :max_page_size
def set_default
- @list_manifest['default_page_size'] ||= 25
- @list_manifest['max_page_size'] ||= 100
+ super
+ @values['default_page_size'] ||= 25
+ @values['max_page_size'] ||= 100
end
def init
- @default_page_size = @list_manifest['default_page_size']
- @max_page_size = @list_manifest['max_page_size']
+ super
+ @default_page_size = @values['default_page_size']
+ @max_page_size = @values['max_page_size']
end
end
}
end
+ def self.default_type
+ 'item'
+ end
+
end
end
def set_default
super
- ManifestBase.undefined_message 'leaf_tree_name', self.module_message unless @args['leaf_tree_name']
+ ManifestBase.alert_undefined_message 'leaf_tree_name', self.module_message unless @args['leaf_tree_name']
end
def init
def set_default
super
- raise "undefined element_tree_name for #{self.module_message}\n" unless @args['element_tree_name']
+ ManifestBase.alert_undefined_message 'element_tree_name', self.module_message unless @args['element_tree_name']
end
def init
def set_default
super
- raise "undefined element_tree_name for #{self.module_message}\n" unless @args['element_tree_name']
+ ManifestBase.alert_undefined_message 'element_tree_name', self.module_message unless @args['element_tree_name']
end
def init
raise "#{message} for #{message}\n"
end
- def undefined_message name, location
+ def alert_undefined_message name, location
alert_message 'undefined ' + name, location
end
}]
end
- def load_type_args _self, jsons, module_name, klass, default_type = nil
- klass.factory_type_args(_self, jsons[module_name], module_name, default_type)
+ def load_type_args _self, jsons, module_name, klass
+ klass.factory_type_args(_self, jsons[module_name], module_name)
end
- def load_type_name_args _self, jsons, module_name, klass, default_type = nil
+ def load_type_name_args _self, jsons, module_name, klass
Hash[jsons[module_name].map {|_name, _json|
- [_name, klass.factory(_self, _name, _json, module_name, default_type)]
+ [_name, klass.factory(_self, _name, _json, module_name)]
}]
end
+ # LocalManifest::Profiler::Association::HasMany
+ def load_names _self, json, module_name, klass
+ json[module_name].map {|_name|
+ klass.new(_self, _name, module_name)
+ }
+ end
+
end
extend ModuleMethods
{}
end
- def self.factory parent, name, json, module_name, default_type = nil
+ def self.default_type
+ nil
+ end
+
+ def self.factory parent, name, json, module_name
module_message = ManifestBase.module_message(parent.module_names, [module_name, name])
- json['type'] ||= default_type
+ json['type'] ||= self.default_type
type = json['type']
- raise "undefined type for #{module_message}\n" unless type
+ alert_undefined_message 'type', module_message unless type
my_class = self.types[type]
- raise "undefined class for #{module_message} > #{type}\n" unless my_class
+ alert_undefined_message 'class', module_message unless my_class
my_class.new(parent, name, json, module_name)
end
- def self.factory_type_args parent, json, module_name, default_type = nil
+ def self.factory_type_args parent, json, module_name
module_message = ManifestBase.module_message(parent.module_names, [module_name])
- json['type'] ||= default_type
+ json['type'] ||= self.default_type
type = json['type']
- raise "undefined type for #{module_message}\n" unless type
+ alert_undefined_message 'type', module_message unless type
my_class = self.types[type]
- raise "undefined class for #{module_message} > #{type}\n" unless my_class
+ alert_undefined_message 'class', module_message unless my_class
my_class.new(parent, json, module_name)
end
require_dependency "manifest_base/base"
-require_dependency "manifest_base/factory"
+ManifestBase.require_modules "manifest_base/",
+ %w|factory values name_values type_args type_name_args names|
end
def set_default
- @args = @json
+ @values = @json
end
def init
--- /dev/null
+module ManifestBase
+ class Names
+ attr :parent, :name, :module_name
+
+ def initialize parent, name, module_name
+ @parent = parent
+ @name = name
+ @module_name = module_name
+ self.set_default
+ self.init
+ end
+
+ def set_default
+ end
+
+ def init
+ end
+
+ def module_names
+ self.parent.module_names + [@module_name, @name]
+ end
+
+ def module_message
+ ManifestBase.module_message(self.module_names)
+ end
+
+ def parent_name
+ @parent.name
+ end
+
+ def parent_json
+ @parent.json
+ end
+
+ end
+end
+
end
def set_default
+ @json['args'] ||= {}
@type = @json['type']
@args = @json['args']
end
end
def set_default
- @args = @json
+ @values = @json
end
def init
OSDN Git Service
