skylinecms 3.0.7

data/doc/MIGRATION.md

@@ -0,0 +1,45 @@
+Skyline Version Migration
+=========================
+
+First OS release -> Version 3.0.7
+---------------------------------
+
+**1. Template changes: render.peek_until** Peek until doesn't skip forward in the collection 
+anymore. The old behaviour was inconsistent with peek. All peek functions now only look forward.
+Replace all occurences of `var = peek_until...` and make sure they manually do `skip!(var.size)`
+a better sollution is to use `render_until`.
+
+**2. Template changes: @Page\_class** `@Page_class` is no longer accesible in the renderer. Use
+`site.root` if you need to access the root class.
+
+**3. Template changes: Renderer partials** You no longer need to pass the currently rendererd object
+to partials. You can access the currently rendered object by using `renderer.object`.
+
+**3. Custom sections: Buttons are no longer images** The helpers `button_image` has been removed
+and the syntax of `submit_button` and `submit_button_to` has changed. Search for occurences of one 
+of these three helpers and replace them accordingly:
+
+**button_image**
+
+    link_to button_image("small/delete.gif", :alt => :delete), ...
+    
+to
+
+    link_to button_text(:delete), ..., :class => "button small red"
+    
+**submit\_button\_to**
+
+    submit_button_to "small/delete.gif", ..., :value => :delete
+    
+to
+
+    submit_button_to :delete, ..., :class => "small red"
+    
+**submit\_button**
+
+    submit_button "small/delete.gif", ..., :value => :delete
+
+to
+
+    submit_button :delete, ..., :class => "small red"
+    

data/lib/skyline.rb

@@ -0,0 +1,22 @@
+# The Skyline contains all Skyline related (core) code and
+# defines some methods like the root (path) and version
+# of the Skyline core.
+module Skyline
+  
+  # The root of the Skyline tree.
+  #
+  # @return [Pathname] 
+  def root
+    @@root ||= Pathname.new(File.dirname(__FILE__) + "/../")
+  end
+  module_function :root
+  
+  # Shortcut for the current version
+  #
+  # @return [String] The current version in the format x.x.x
+  def version
+    Skyline::VERSION::STRING
+  end
+  module_function :version  
+end
+

data/lib/skyline/cli/base.rb

@@ -0,0 +1,21 @@
+require 'thor'
+
+require File.dirname(__FILE__) + '/init'
+require File.dirname(__FILE__) + '/../../skyline'
+require File.dirname(__FILE__) + '/../version'
+
+module Skyline
+  module Cli
+    class Base < Thor
+      include Thor::Actions
+      
+      add_runtime_options!      
+      
+      desc "init", "Setup Skyline in the current directory, this must be a valid Rails 2.3 application."
+      def init
+        invoke Skyline::Cli::Init
+      end
+      
+    end
+  end
+end

data/lib/skyline/cli/init.rb

@@ -0,0 +1,118 @@
+require 'pathname'
+require 'fileutils'
+
+module Skyline
+  module Cli
+    class Init < Thor::Group
+      include Thor::Actions
+      
+      def self.source_root
+        Skyline.root
+      end
+      
+      def verify_rails_dir
+        say "=> Verifying if this is a Rails(like) app"
+        unless (self.target_dir + "lib").exist? &&
+            (self.target_dir + "public").exist? &&
+            (self.target_dir + "config/environment.rb").exist?
+            
+          raise Thor::Error, "This does not seem like a valid Rails app (need lib, public and config/environment.rb)"
+        end
+      end
+      
+      def add_config_gem
+        environment_rb = (self.target_dir + "config/environment.rb")
+        if File.read(environment_rb) =~ /^\s*config.gem\s+[\":']skylinecms[\"']?(.+[\":']version[\"']?\s*=>\s*[\"'](.+)[\"'])?/i
+          say_status "exist", "Already found gem version #{$2}, not doing anything, check gem dependency manually", :blue
+        else
+          say "=> Adding config.gem line to environment.rb"
+          inject_into_file environment_rb, :after => "Rails::Initializer.run do |config|\n" do
+            "  config.gem \"skylinecms\", :version => \"#{Skyline::VERSION::STRING}\"\n"
+          end
+        end
+      end
+      
+      def create_stub_tasks_file
+        tasks_dir = (self.target_dir + "lib/tasks")
+        
+        say "=> Creating lib/tasks directory"
+        empty_directory tasks_dir
+        
+        say "=> Creating lib/tasks/skyline.rake"
+        copy_file self.template_dir + "tasks/skyline.rake", tasks_dir + "skyline.rake"
+      end
+      
+      def copy_assets
+        say "=> Copying assets"
+        
+        public_dir = (self.target_dir + "public/skyline")
+        if public_dir.exist? || File.symlink?(public_dir)
+          if shell.file_collision("public/skyline")
+            FileUtils.rm_rf(public_dir)
+          else
+            return
+          end
+        end
+        
+        directory "public/skyline/images", public_dir + "images", :recursive => true
+        directory "public/skyline/stylesheets", public_dir + "stylesheets", :recursive => true        
+        directory "public/skyline/javascripts", public_dir + "javascripts", :recursive => true                
+      end
+      
+      def create_skyline_config
+        say "=> Creating config/initializers/skyline_configuration.rb"
+        copy_file self.template_dir + "config/initializers/skyline_configuration.rb", self.target_dir + "config/initializers/skyline_configuration.rb"
+      end
+      
+      def create_development_upload_paths
+        say "=> Creating development upload paths"
+        empty_directory self.target_dir + "tmp"
+        empty_directory self.target_dir + "tmp/upload"        
+        empty_directory self.target_dir + "tmp/cache/media_files/cache"
+        empty_directory self.target_dir + "tmp/cache/rss_sections/cache"        
+      end
+      
+      def create_template_path
+        say "=> Creating skyline template path"
+        empty_directory self.target_dir + "app/templates"
+      end
+      
+      def add_default_pages_route
+        routes_rb = self.target_dir + "config/routes.rb"
+        route_string = "map.connect '*url', :controller => \"skyline/site/pages\", :action => \"show\""
+        
+        say "=> Add default pages route"
+        if File.read(routes_rb) =~ /#{Regexp.escape(route_string)}$/
+          say_status "exist", "default pages route", :blue
+        else
+          inject_into_file routes_rb, :after => "map.connect ':controller/:action/:id.:format'\n" do
+            "\n" +
+            "  # The default Skyline pages route\n" +
+            "  #{route_string}\n"
+          end
+        end
+      end
+      
+      def remove_default_rails_assets
+        say "=> Removing default rails assets"
+        %w{public/index.html public/images/rails.png}.each do |f|
+          if (self.target_dir + f).exist?
+            say_status "removing", f
+            FileUtils.rm(self.target_dir + f)
+          end
+        end
+      end
+      
+      protected
+      
+      def target_dir
+        @_target_dir ||= Pathname.new(Dir.pwd)
+      end
+      
+      def template_dir
+        @_template_dir ||= self.class.source_root + "lib/skyline/cli/init/templates/"
+      end
+      
+    end
+  end
+end

data/lib/skyline/cli/init/templates/config/initializers/skyline_configuration.rb

@@ -0,0 +1,5 @@
+Skyline::Configuration.configure do |config|  
+  config.assets_path = File.join(Rails.root,"tmp/upload")
+  config.media_file_cache_path = File.join(Rails.root,"tmp/cache/media_files/cache")
+  config.rss_section_cache_path = File.join(Rails.root,"tmp/cache/rss_sections/cache")
+end

data/lib/skyline/cli/init/templates/tasks/skyline.rake

@@ -0,0 +1,2 @@
+require 'skyline'
+import Skyline.root + "tasks/implementation.rake"

data/lib/skyline/configuration.rb

@@ -0,0 +1,112 @@
+# Contains the default skyline configuration. Currently this is also
+# the place to look for available configuration options.
+#
+# @todo This configuration class will soon change as it's not flexible enough
+#   for out purposes.
+class Skyline::Configuration < Configure
+  
+  defaults do |config|
+    config.name = File.expand_path(Rails.root).split("/").last
+    config.title = config.name.humanize
+    
+    config.sections = {:default => [
+                         "wysiwyg_section", 
+                         "heading_section", 
+                         "rss_section", 
+                         "iframe_section",
+                         "content_collection_section", 
+                         "content_item_section", 
+                         "splitter_section", 
+                         "link_section",
+                         "raw_section",
+                         "media_section",
+                         "redirect_section",
+                         "page_fragment_section"]
+                      }
+    
+    config.articles = []
+    config.content_classes = []
+    
+    config.rss_section_cache_timeout = 1.hour  
+    
+    config.solr_indexing = false
+    
+    config.custom_logo = false
+    config.skyline_logo = "/skyline/images/logo.png"
+    config.branding_name = ""
+    
+    # ie: [{:path => "/stylesheets/skyline.css", :if => "lte IE 7"}]
+    config.custom_stylesheets = []
+    
+    if Rails.env == "production"
+      config.assets_path = nil
+      config.media_file_cache_path = nil
+      config.rss_section_cache_path = nil
+    else
+      config.assets_path = File.join(Rails.root,"tmp/upload")
+      config.media_file_cache_path = File.join(Rails.root,"/tmp/media_files/cache")
+      config.rss_section_cache_path = File.join(Rails.root,"/tmp/rss_sections/cache")
+    end 
+    
+    unless ActiveSupport::Dependencies.load_once_path?(__FILE__)
+      # We need to reload the configuration because this file get's reloaded 
+      if (Rails.root + "config/initializers/skyline_configuration.rb").exist?
+        load Rails.root + "config/initializers/skyline_configuration.rb"
+      end    
+    end
+    
+    # enable/disable 'modules'
+    config.enable_multiple_variants = true
+    config.enable_locking = true
+    config.enable_enforce_only_one_user_editing = true
+    config.enable_publication_history = true
+  end  
+  
+  def after_configure
+    check_or_create_path(self["assets_path"],"assets_path")
+    check_or_create_path(self["media_file_cache_path"],"media_file_cache_path")
+    check_or_create_path(self["rss_section_cache_path"],"rss_section_cache_path")
+    
+    Skyline::MediaNode.assets_path = self["assets_path"]  
+    Skyline::MediaCache.cache_path = self["media_file_cache_path"]
+    Skyline::Sections::RssSection.cache_path = self["rss_section_cache_path"]
+    Skyline::Sections::RssSection.cache_timeout = self["rss_section_cache_timeout"]
+    
+    Skyline::Renderer.register_renderables(:sections,self["sections"])
+    Skyline::Renderer.register_renderables(:articles,self["articles"] + ["Skyline::Page"])  
+    
+    load_dependencies
+  end  
+  
+  def articles
+    self["articles"].map(&:constantize)
+  end  
+  
+  def content_classes
+    self["content_classes"].map(&:constantize)
+  end
+  
+  protected
+  
+  def load_dependencies
+    if self.solr_indexing
+      require "rsolr"
+      require "rsolr-ext"      
+    end
+  end
+  
+  # Check if a path is set, and if we're in production made raise an assertion
+  # if the path does not exist. It just creates the path in development mode.
+  def check_or_create_path(path, key="assets_path")
+    raise "#{key} must be set!" if path.blank?
+    unless File.directory?(path)
+      if Rails.env == "production"
+        raise("#{key} \"#{path}\" does not exist") 
+      else
+        require 'fileutils'
+        Rails.logger.warn "Creating #{key} directory in \"#{path}\""
+        FileUtils.mkdir_p(path)
+      end
+    end
+  end
+end

data/lib/skyline/content/class_meta_data.rb

@@ -0,0 +1,105 @@
+module Skyline::Content
+  module ClassMetaData
+      
+    # Returns singular name of this class, falls back on standard Rails humanization
+    def singular_name
+      self.settings.singular_label
+    end
+    
+    # Returns plural name of this class, falls back on standard Rails humanization    
+    def plural_name
+      self.settings.plural_label
+    end
+    
+    # Is this a hidden class within the asked scope?
+    # Currently scope is always :menu
+    def hidden?(scope=:menu)
+      self.settings.hidden == true || self.settings.hidden.kind_of?(Array) && self.settings.hidden.include?(scope)
+    end
+    
+    
+    # Returns the default_order_by_statement 
+    def default_order_by_statement #:nodoc:
+      self.settings.order_by || "id ASC"
+    end  
+      
+    
+    # General purpose method to set all kind of class options.
+    # Works with hashes and blocks:
+    #
+    #   settings :label => ["label","labels"]
+    #
+    #   settings do |o|
+    #     o.label = ["label","labels"]
+    #   end    
+    #
+    # = Options available
+    # <tt>label</tt>::   
+    #   Parameters can be an array having 2 elements ["singular", "plural"] or just a string, in which 
+    #   case it's assumed to be just singular.    
+    # <tt>return_to_self_after_save</tt>::   
+    #   Define wether or not after a save operation this object should return to itself
+    #   or to the listview. Defaults to return to listview (false/nil)
+    # <tt>identification_columns</tt>::   
+    #   An array describing the columns this object can be described with, the values
+    #   of these columns are joined with spaces. Parameter accepts also a single column name
+    #   defaults to the first available of possible_identification_columns.
+    # <tt>hidden</tt>::
+    #   One or more of the following: [:menu] or just true for all of the aforementioned    
+    # <tt>presenter</tt>::
+    #   The presenter to use in the listview defaults to :table, only other option is
+    #   :article at the moment. Use :article to make list orderable.
+    # <tt>order_by</tt>::
+    #   The default order of this model. Just a regular SQL order_by clause, can be a string or a symbol.
+    # <tt>orderable</tt>::
+    #   Make this object act as an orderable list. If set to true, model should contain a field named :position.
+    #   Also, a hash can be passed of the form {:column => "position", :scope => :document}. In this case, articles that belong to
+    #   a document can be sorted using their position to store order, and sorting will take place only within one document
+    #
+    # = Presenters
+    # == Article
+    # Displays a list with a Title and Subtitle and some fields (be warned this should be no more than 2 or 3).
+    # The article presenter also alows drag and drop ordering if orderable is enabled.
+    #
+    # Extra options for the article presenter are:
+    # <tt>title_field</tt>:: The field that should be used as a title in the list (defaults to first editable field if not specified)
+    # <tt>subtitle_field</tt>:: The field that should be used as a subtitle in the list (defaults to nothing)
+    #
+    # == Table
+    # The default table presenter. No extra options required.
+    # -
+    def settings(settings=nil,&block)
+      return get_settings if settings.nil? && !block_given?
+      s = MetaData::ClassSettings.new(settings.update(:owner => self))
+      yield s if block_given?
+      write_inheritable_attribute(:settings,s)
+      after_set_settings!
+      s
+    end
+            
+    protected
+    
+    def after_set_settings!
+      if self.settings.orderable
+        self.acts_as_orderable(self.settings.orderable)
+      end
+    end
+    
+    # @deprecated
+    def sort_order(*sort_statements) # :nodoc:
+      self.settings.order_by = sort_statements.map{|k| k.join(" ") }.join(",")
+    end
+    
+    # Define wether this class should show up in a specific scope.
+    # mostly used to hide classes in the CMS menu.
+    #   hidden :in => :menu
+    def hidden(options={}) #:nodoc:
+      options.reverse_merge! :in => :menu
+      self.settings.hidden = options[:in].kind_of?(Array) ? options[:in] : [options[:in]]
+    end
+    
+    def get_settings
+      read_inheritable_attribute(:settings) || write_inheritable_attribute(:settings,MetaData::ClassSettings.new(:owner => self))
+    end
+  end
+end

data/lib/skyline/content/content.rb

@@ -0,0 +1,315 @@
+# @private
+module Skyline::Content
+  module Content
+    def self.included(obj)
+      obj.extend(KlassMethods)
+     
+       if obj.ancestors.include?( ::ActiveRecord::Base)
+         obj.send(:after_save, "process_after_save")
+       end    
+     end 
+     
+     module KlassMethods  #:nodoc:
+    
+      def content?
+        true
+      end
+    
+      # Does this object have a published field
+      def publishable?
+        self.column_names.include?("published")
+      rescue
+        true
+      end
+    
+      # Does this object have tags
+      def taggable?
+        self.reflect_on_all_associations(:has_many).detect{|a| a.name == :associated_tags}
+#      rescue
+#        false
+      end      
+      
+      # Is this object filterable? 
+      # Basically means wether or not this object has fields with
+      # the metadata :filter set to true.
+      def filterable?
+        self.filterable_fields.any?
+      end
+    
+      # Does this object have a position field
+      def orderable?
+        false
+      end
+    
+      # Is this object exportable
+      def exportable?
+        false
+      end
+
+      # Is this object importable
+      def importable?
+        false
+      end
+    
+    
+      # Find objects for use in the CMS, these are wrappers
+      # for the standard find method of ActiveRecord::Base with
+      # some extra options.
+      #
+      # ==== Parameters
+      # See ActiveRecord::Base.find for more info on the standard parameters
+      #
+      # ==== Options
+      # :self_referential<Boolean>:: 
+      #   If false, will only find records where the associations to other objects
+      #   of the same class are null. Which basically means it get's the top level
+      #   of the hierarchy.
+      # :filter<Hash>::
+      #   
+      #--
+      def find_for_cms(*args)
+        skyline_options,options = extract_all_options!(args)
+    
+        with_skyline_scope(skyline_options) do
+         options.update(:order => self.default_order_by_statement)
+         find(*(args << options))
+        end
+      end
+    
+      # Same as find_for_cms but this method only returns a count.
+      #--
+      def count_for_cms(*args)
+        skyline_options,options = extract_all_options!(args)        
+        with_skyline_scope(skyline_options) do
+         count(*(args << options))
+        end         
+      end
+    
+      # Same as find_for_cms, but works with the will_paginate plugin
+      #--
+      def paginate_for_cms(*args)
+        skyline_options,options = extract_all_options!(args)        
+        with_skyline_scope(skyline_options) do
+         options.update(:order => self.default_order_by_statement)
+         paginate(*(args << options))
+        end         
+      end
+       
+      include FieldMetaData
+      include ClassMetaData
+      include Orderable 
+      include Exportable
+      # Versioning::Versionable is added direcly on the class
+    
+      private
+    
+      # Extract the skyline specific options from the options hash
+      #--
+      def extract_all_options!(args)
+        options = args.extract_options!
+        skyline_options = {}
+        [:self_referential,:filter].each do |k|
+          v = options.delete(k)
+          skyline_options[k] = v unless v.nil?
+        end
+        [skyline_options,options]
+      end
+              
+       # Self referential associations scope
+       def with_skyline_scope(options,&block)
+        find_scopes = []         
+    
+        if options[:self_referential] == false
+          conditions = self_referential_associations_conditions
+          find_scopes << {:conditions => conditions} if conditions
+        end
+        
+        if options[:filter]
+          conditions = extract_filter_options(options[:filter])
+          find_scopes << {:conditions => conditions} if conditions
+        end
+        
+        apply_scopes(find_scopes,&block)
+      end
+      
+      def apply_scopes(find_scopes=[],&block)
+        return yield if find_scopes.blank?
+        return with_scope(:find => find_scopes.first){apply_scopes(find_scopes[1..-1],&block)}
+      end
+     
+      # Special case of self referential associations, these 
+      # are associations that point to the same table/class to 
+      # create a tree hierarchy for instance.
+      #--
+      def self_referential_associations
+        @self_referential_assocs ||= self.reflect_on_all_associations(:has_many).find_all{|a| a.klass == self}
+      end
+       
+      # Extract only valid filter options. All fields which are not actually
+      # filterable will be removed.
+      def extract_filter_options(filter)
+        return nil unless filter.kind_of?(Hash)
+        filter_conditions = {}
+        filter.each do |k,v|
+          field = self.fields[k.to_sym]
+          next if !field || field && !field.filterable || v.blank?
+          filter_conditions[field.attribute_name] = v
+        end
+        filter_conditions
+      end
+       
+      def self_referential_associations_conditions
+        return nil if self_referential_associations.empty?
+        
+        self_referential_associations.collect do |assoc| 
+          (assoc.options[:foreign_key] || assoc.primary_key_name).to_s + " is null" 
+        end.join(" AND ")
+      end
+    
+    end # Klass Methods
+    
+    # The label of this object instance by which a
+    # human can identify this instance.
+     def human_id
+      id_columns = [self.class.settings.identification_columns].flatten.compact.find_all{|c| self.respond_to?(c)}
+      
+      if id_columns.blank?
+        self.send(possible_identification_columns.compact.find{|c| self.respond_to?(c)})
+      else
+        id_columns.map{|c| self.send(c)}.join(" ")
+      end
+     end
+     
+     # @deprecated
+     alias :identification :human_id 
+     
+     # List of fallback identification columns if it isn't specified
+     # in the implementation: titel, title, naam, name, url, id
+     def possible_identification_columns
+       %w{titel title naam name url id}
+     end     
+     
+     # Is this object a content object? Delegates to self.class.content?
+     def content?
+       self.class.content?
+     end
+     
+     def instantiated_by=(type) # :nodoc:
+       @type = type
+     end
+     def instantiated_by # :nodoc:
+       @type
+     end    
+     
+     # Set correct relation options for the relationship
+     # of self to obj
+     def relate_to(obj) # :nodoc:
+       return unless assoc = obj.class.reflect_on_association(self.instantiated_by)
+       case assoc.macro
+         when :has_many : obj.send(self.instantiated_by) << self
+         when :has_one : obj.send("#{self.instantiated_by}=",self) 
+        end
+     end
+     
+     protected
+     
+     def process_related_objects(field,values)
+       return unless assoc = field.reflection
+       case assoc.macro
+         when :has_and_belongs_to_many then process_habtm_related_objects(field,values,assoc)
+         when :has_many then
+           if assoc.through_reflection
+             process_has_many_through_related_objects(field,values,assoc)
+           else
+             process_has_many_related_objects(field,values,assoc)
+           end
+         else raise "You can't use related objects for #{assoc.macro} on #{self.class}"
+       end
+     end
+     
+     def process_habtm_related_objects(field,values,assoc)
+       target_order = values.delete("_order") # This is discarded, a HABTM relationship cannot have a positionfield
+       target_ids = values.map{|k,v| v["_target_id"].to_i }
+       current_ids = self.send("#{field.name.to_s.singularize}_ids")
+       if target_ids.sort != current_ids.sort
+         objects = assoc.klass.find(target_ids).inject({}){|mem,o|mem[o.id] = o; mem}
+         self.send("#{field.name}").clear
+         self.send("original_#{field.name}=",target_ids.map{|i| objects[i]})
+       end
+     end
+     
+     def process_has_many_through_related_objects(field,values,assoc)
+       order_map = {}   
+       position_column = nil    
+       if (target_order = values.delete("_order")) && assoc.through_reflection.klass.orderable?
+         target_order = target_order.split(",").each_with_index{|v,k| order_map[v]=k + 1}
+         position_column = assoc.through_reflection.klass.position_column
+       end
+       
+       target_ids = values.map{|k,v| v["_target_id"].to_i }
+       current = self.send(assoc.through_reflection.name).inject({}){|mem,o|mem[o.id] = o; mem}
+       
+       # Removal!
+       deletable = (current.keys - values.keys.map(&:to_i))
+       self.destroy_associated += current.values_at(*deletable) if deletable.any?
+       
+       # Add & update
+       values.each do |k,v|
+         target_id = v.delete("_target_id")
+         params = {}
+         if tempid = k.to_s[/^n__?(n?\d+)/,1]
+           # new
+           params.update(assoc.source_reflection.primary_key_name => target_id)
+           params.update(position_column => order_map[tempid]) if position_column           
+           self.send(assoc.through_reflection.name).build(v.update(params))
+         else
+           # update join model, don't update target!
+           next unless current.has_key?(k.to_i)
+           params.update(position_column => order_map[k.to_s]) if position_column
+           current[k.to_i].attributes = v.update(params)
+           self.save_associated << current[k.to_i] unless self.destroy_associated.include?(current[k.to_i])
+         end
+       end
+     end
+     
+     def process_has_many_related_objects(field,values,assoc)
+       current = self.send(assoc.name).inject({}){|mem,o|mem[o.id] = o; mem}
+       
+       # Removal!
+       deletable = (current.keys - values.keys.map(&:to_i))
+       self.destroy_associated += current.values_at(*deletable) if deletable.any?
+       
+       # Add & update
+       values.each do |k,v|
+         if tempid = k.to_s[/^n__?(n?\d+)/,1]
+           # new
+           self.send(assoc.name).build(v)
+         else
+           next unless current.has_key?(k.to_i)
+           current[k.to_i].attributes = v
+           self.save_associated << current[k.to_i] unless self.destroy_associated.include?(current[k.to_i])
+         end
+       end       
+     end
+     
+     def save_associated
+       @_save_associated ||= []
+     end
+     
+     def destroy_associated
+       @_destroy_associated ||= []
+     end
+     def destroy_associated=(v)
+       @_destroy_associated = v
+     end
+    
+     def process_after_save
+       if self.destroy_associated.any?       
+         self.destroy_associated.each{|o| o.destroy } 
+      end
+      if self.save_associated.any?
+        self.save_associated.each{|o| o.save unless o.frozen? } 
+      end
+     end
+  end
+end