speech: {\r
},\r
},\r
- field_names: [\r
+ form_field_names: [\r
'caption',\r
'id',\r
'panel_id',\r
},\r
},\r
speech_balloon_template_settings: {\r
- label: {\r
- type: 'none',\r
- },\r
- tag: {\r
- type: 'hidden',\r
- },\r
+ row_break: true,\r
},\r
},\r
field_names: [\r
},\r
},\r
speech_balloon_template_settings: {\r
- label: {\r
- type: 'none',\r
- },\r
- tag: {\r
- type: 'hidden',\r
- },\r
+ row_break: true,\r
},\r
},\r
field_names: [\r
},\r
},\r
speech_balloon_template_settings: {\r
- label: {\r
- type: 'none',\r
- },\r
- tag: {\r
- type: 'hidden',\r
- },\r
+ row_break: true,\r
},\r
writing_format_settings: {\r
label: {\r
parent_model_name: 'speech_balloon',\r
boost: {\r
speech_balloon_template: {\r
+ resource_name: 'speech_balloon_template',\r
extend_item_name: 'balloon',\r
},\r
},\r
writing_format: {\r
},\r
speech_balloon_template: {\r
+ resource_name: 'speech_balloon_template',\r
extend_item_name: 'speech',\r
},\r
},\r
def render_form
respond_to do |format|
format.html {
- @form = Locmare::Form.new @item.item_name, @item, true, true, @operators
+ @form = Locmare::Bucket.factory @item.item_name, @item, true, true, @operators
render @form.template_name, :locals => {
:form => @form
}
end
def update
- SpeechBalloon.fold_extend_settings params
- @speech_balloon = SpeechBalloon.show(params[:id], @operators)
+ @item = SpeechBalloon.show(params[:id], @operators)
+ @speech_balloon = @item
+ @form = Locmare::Bucket.factory @item.item_name, @item, true, true, @operators
+ @form.fold_extend_settings params
@speech_balloon.attributes = params[:speech_balloon]
@speech_balloon_template = @speech_balloon.speech_balloon_template
- @speech_balloon.boosts 'post'
params[:speech_balloon][:balloon_attributes][:system_picture_id] = @speech_balloon.balloon.select_system_picture
@speech_balloon.overwrite @panel.id
respond_to do |format|
- if @speech_balloon.valid? and @speech_balloon.store(@operators, params[:speech_balloon])
+ if @speech_balloon.save
flash[:notice] = I18n.t('flash.notice.updated', :model => SpeechBalloon.model_name.human)
format.html { redirect_to @speech_balloon }
format.json { head :ok }
self.overwrite operators
res = false
Panel.transaction do
- self.panel_elements.each do |elm|
- elm.boost
- end
+ self.boosts 'post'
#self.publish = nil
res = self.save
unless validate_child
Pettanr::Application.configure do
-
+autoload = true
+if autoload
ActiveSupport::Dependencies.autoload_paths << File::join( Rails.root, 'lib')
ActiveSupport::Dependencies.explicitly_unloadable_constants << 'Peta'
ActiveSupport::Dependencies.explicitly_unloadable_constants << 'Editor'
ActiveSupport::Dependencies.explicitly_unloadable_constants << 'ManifestBase'
ActiveSupport::Dependencies.explicitly_unloadable_constants << 'Manifest'
ActiveSupport::Dependencies.explicitly_unloadable_constants << 'LocalManifest'
+end
# Settings specified here will take precedence over those in config/application.rb
# In the development environment your application's code is reloaded on
i.license_settings = s.to_json
end
i.boosts 'post'
- i.save!
+ i.save! if i.original_picture
end
end
end
class CreateFolders < ActiveRecord::Migration
def change
- drop_table :folders
create_table :folders do |t|
t.string :name, :null => false
t.string :controller_name
ManifestBase.require_modules "local_manifest/bucket/",
- %w|member field_name|
+ %w|member form_field_name|
module LocalManifest
class Bucket < ManifestBase::Base
include BucketModule
- attr :members, :field_names
+ attr :members, :form_field_names
def set_default
super
@json['members'] ||= {}
- @json['field_names'] ||= {}
+ @json['form_field_names'] ||= {}
end
def init
super
@members = ManifestBase.load_name_values self, @json, 'members', Member
- @field_names = ManifestBase.load_value self, @json, 'field_names', FieldName
+ @form_field_names = ManifestBase.load_names self, @json, 'form_field_names', FormFieldName
end
- def item_name
- @name
+ def has_member?
+ @members.any?
end
- def each_column
- @column_names
+ def item_name
+ @name
end
end
-
end
module LocalManifest
module BucketModule
- class FieldName < ManifestBase::Values
- attr :form_name, :field_name
+ class FormFieldName < ManifestBase::Names
+ attr :form_names, :field_name, :form_name
def set_default
super
def init
super
- t = @values.split '.'
- @form_name = t.size < 2 ? self.bucket_name : t.first
- @field_name = t.last
+ @form_names = @name.split '.'
+ @field_name = @form_names.pop
+ @form_name = @form_names.join '.'
end
def bucket_name
end
end
-
end
end
require_dependency "locmare/bucket/member"
-require_dependency "locmare/bucket/field_name"
+require_dependency "locmare/bucket/form_field_name"
module Locmare
class Bucket
include BucketModule
attr :manifest, :bucket_name, :item, :mounted, :submit, :operators, :template_dir,
:fields
+
+ def self.factory bucket_or_form_name, item, mounted, submit, operators
+ bucket = LocalManifest.manifest.buckets[bucket_or_form_name]
+ c = if bucket and bucket.has_member?
+ Locmare::Bucket
+ else
+ Locmare::Form
+ end
+ c.new bucket_or_form_name, item, mounted, submit, operators
+ end
+
def initialize bucket_name, item, mounted, submit, operators
@bucket_name = bucket_name
@item = item
@operators = operators
@item.boosts 'post'
- self.init_fields
- @manifest = LocalManifest.manifest.forms[@form_name]
+ @manifest = LocalManifest.manifest.buckets[@bucket_name]
@template_dir = 'templates/r/form/'
- @fields = {}
+ @form_fields = []
+ @forms = {}
+ self.push_form @item.item_name, @item.item_name, @item
+ self.init_forms @item.item_name, @manifest, @item
+ self.init_fields
end
- def init_fields
- @manifest.each_field do |field_name, field_manifest|
- if boost_name = @item.class.find_boost_name(field_name)
- extend_form_name = @item.boosters[boost_name].model_name
- extend_item = @item.boosters[boost_name].extend_item
- @fields[field_name] = ExtendForm.new self, extend_form_name, extend_item, @mounted, @operators, field_name
- else
- @fields[field_name] = Field.new self, field_name, field_manifest
- end
+ def fold_extend_settings params
+ p params
+ p params[@item.item_name]['speech']
+ @item.class.fold_extend_settings params[@item.item_name]
+ self.members_fold_extend_settings @item, params[@item.item_name], @manifest
+ end
+
+ def members_fold_extend_settings fold_item, attr, man
+ p attr
+ man.members.each do |member_name, member_manifest|
+ member_item = fold_item.__send__ member_name
+ member_item.class.fold_extend_settings attr[member_name + '_attributes']
+ self.members_fold_extend_settings member_item, attr[member_name + '_attributes'], member_manifest
end
end
def each_field
- @manifest.field_names.each do |field_name|
- yield field_name, @fields[field_name]
+ @form_fields.each do |field_manifest|
+ yield field_manifest.field_name, field_manifest
+ end
+ end
+
+ def push_form key, form_name, item
+ @forms[key] = Locmare::Form.new form_name, item, @mounted, @submit, @operators
+ end
+
+ def init_forms key, man, item
+ man.members.each do |member_name, member_manifest|
+ form_name = member_name # write exchange function if you want
+ member_item = item.__send__(form_name)
+ new_key = key + '.' + form_name
+ self.push_form new_key, form_name, member_item
+ self.init_forms new_key, member_manifest, member_item
+ end
+ end
+
+ def init_fields
+ @manifest.form_field_names.each do |form_field_name|
+ r = form_field_name.form_name.blank? ? '' : '.' + form_field_name.form_name
+ key = @item.item_name + r
+ form = @forms[key]
+ field = form.fields[form_field_name.field_name]
+ @form_fields << field
end
end
end
end
+ def form_name
+ @bucket_name
+ end
+
end
end
@fields = {}
end
+ def fold_extend_settings params
+ @item.class.fold_extend_settings params[@item.item_name]
+ end
+
def each_field
@manifest.field_names.each do |field_name|
yield field_name, @fields[field_name]
module FormModule
class Field
include FieldModule
- attr :form, :field_name, :field_manifest,
- :label, :tag, :helpers, :options
- def initialize form, field_name, field_manifest
+ attr :form, :field_name_with_sub_form, :field_manifest,
+ :label, :tag, :helpers, :options,
+ :field_name, :sub_form_names
+ def initialize form, field_name_with_sub_form, field_manifest
@form = form
- @field_name = field_name
+ @field_name_with_sub_form = field_name_with_sub_form
@field_manifest = field_manifest
@label = LabelFactory.factory self, @field_manifest.label
@tag = TagFactory.factory self, @field_manifest.tag
@helpers[helper_name] = HelperFactory.factory self, helper_manifest
}
@options = {'data-model' => @field_manifest.form_name}
+ @sub_form_names = @field_name_with_sub_form.split '.'
+ @field_name = @sub_form_names.pop
end
def mounted
end
def item
- @form.item
+ i = @form.item
+ @sub_form_names.each do |n|
+ i = i.__send__(n) # has_many associate model does not work
+ end
+ i
end
def value
self.item.field_tag_attributes(@field_manifest.column_name, tag_options).merge(self.mount_option)
end
+ def sub_form_name
+ @sub_form_names.map{|name| '[' + name + '_attributes' + ']'}.join
+ end
+
def form_field_name
- self.form_name + '[' + @field_name + ']'
+ @form.form_name + self.sub_form_name + '[' + @field_name + ']'
end
def form_name
require_dependency "locmare/form"
require_dependency "locmare/profiler"
require_dependency "locmare/list_group"
+require_dependency "locmare/booster"
require_dependency "locmare/bucket"
r = []
::Manifest.manifest.items.each {|peta_name, peta_manifest|
next unless peta_manifest.element?
- next unless peta_manifest.parent_model_name == @model_name
- r << peta_manifest.model
+ next unless peta_manifest.parent_model_name == @name
+ r << ::Manifest.manifest.models[peta_name]
}
r
end
}]
end
- # LocalManifest::Profiler::Association::HasMany
def load_names _self, json, module_name, klass
json[module_name].map {|_name|
klass.new(_self, _name, module_name)
def self.load_manifest
super
# Class Methods
- f = self._content?
+ ct = self._content?
define_singleton_method("content?") do
- f
+ ct
end
- t = self._owner_type
+ ot = self._owner_type
define_singleton_method("owner_type") do
- t
+ ot
end
- m = self._owner_model
+ om = self._owner_model
define_singleton_method("owner_model") do
- m
+ om
end
- o = self._owner_column
+ oc = self._owner_column
define_singleton_method("owner_column") do
- o
+ oc
end
# Instance Methods
define_method("elements") do |tree_name|
def self.load_manifest
return nil unless self.my_manifest
- r = self._valid_encode_columns
+ vc = self._valid_encode_columns
define_singleton_method("valid_encode_columns") do
- r
+ vc
end
- r = self.my_manifest.child_models
+ cm = self.my_manifest.child_models
define_singleton_method("child_models") do
- r
+ cm
end
- r = self.my_manifest.child_element_names
+ cen = self.my_manifest.child_element_names
define_singleton_method("child_element_names") do
- r
+ cen
end
# Instance Methods
end
{}
end
- def self.fold_extend_settings params
+ def self.fold_extend_settings attr
self.my_peta.boost.each do |name, manifest|
- my_settings = params[self.item_name][manifest.settings_column_name]
+ my_settings = attr[manifest.settings_column_name]
if my_settings.is_a?(Hash)
- params[self.item_name][manifest.settings_column_name] = my_settings.to_json
+ attr[manifest.settings_column_name] = my_settings.to_json
end
end
- self.child_models.each do |child_model|
- child_model.fold_extend_settings params
- end
end
#InstanceMethods
}\r
},\r
"speech_balloon_template_settings": {\r
- "label": {\r
- "type": "none"\r
- },\r
- "tag": {\r
- "type": "hidden"\r
- }\r
+ "row_break": true\r
}\r
},\r
"field_names": [\r
}\r
},\r
"speech_balloon_template_settings": {\r
- "label": {\r
- "type": "none"\r
- },\r
- "tag": {\r
- "type": "hidden"\r
- }\r
+ "row_break": true\r
}\r
},\r
"field_names": [\r
}\r
},\r
"speech_balloon_template_settings": {\r
- "label": {\r
- "type": "none"\r
- },\r
- "tag": {\r
- "type": "hidden"\r
- }\r
+ "row_break": true\r
},\r
"writing_format_settings": {\r
"label": {\r
"balloon": {},\r
"speech": {}\r
},\r
- "field_names": [\r
+ "form_field_names": [\r
"caption",\r
"id",\r
"panel_id",\r