alchemy_cms 3.2.1 → 3.3.0.rc1

data/app/models/alchemy/essence_richtext.rb

@@ -18,10 +18,14 @@ module Alchemy
 
     before_save :strip_content
 
-  private
+    def has_tinymce?
+      true
+    end
+
+    private
 
     def strip_content
-      self.stripped_body = strip_tags(self.body)
+      self.stripped_body = strip_tags(body)
     end
 
     # Stripping HTML Tags and only returns plain text.
@@ -42,6 +46,5 @@ module Alchemy
         html # already plain text
       end
     end
-
   end
 end

data/app/models/alchemy/language.rb

@@ -22,19 +22,23 @@ module Alchemy
     belongs_to :site
     has_many :pages
 
-    validates_presence_of :name
-    validates_presence_of :language_code
-    validates_presence_of :page_layout
-    validates_presence_of :frontpage_name
-    validates_uniqueness_of :language_code, scope: [:site_id, :country_code]
-    validate :presence_of_default_language
-    validate :publicity_of_default_language
+    before_validation :set_locale, if: -> { locale.blank? }
+
+    validates :name, presence: true
+    validates :page_layout, presence: true
+    validates :frontpage_name, presence: true
+
+    validates :language_code,
+      presence: true,
+      uniqueness: { scope: [:site_id, :country_code] },
+      format: { with: /\A[a-z]{2}\z/, if: -> { language_code.present? } }
 
-    validates_format_of :language_code, with: /\A[a-z]{2}\z/,
-      if: -> { language_code.present? }
+    validates :country_code,
+      format: { with: /\A[a-zA-Z]{2}\z/, if: -> { country_code.present? } }
 
-    validates_format_of :country_code, with: /\A[a-z]{2}\z/,
-      if: -> { country_code.present? }
+    validate :presence_of_default_language
+    validate :publicity_of_default_language
+    validate :presence_of_locale_file, if: -> { language_code.present? }
 
     before_save :remove_old_default,
       if: -> { default_changed? && self != Language.default }
@@ -52,10 +56,9 @@ module Alchemy
 
     scope :published,      -> { where(public: true) }
     scope :with_root_page, -> { joins(:pages).where(Page.table_name => {language_root: true}) }
-    scope :on_site,        ->(s) { s.present? ? where(site_id: s) : all }
+    scope :on_site,        ->(s) { s.present? ? where(site_id: s.id) : all }
 
     class << self
-
       # Store the current language in the current thread.
       def current=(v)
         RequestStore.store[:alchemy_current_language] = v
@@ -80,9 +83,9 @@ module Alchemy
 
     def label(attrib)
       if attrib.to_sym == :code
-        self.code
+        code
       else
-        I18n.t(self.code, default: self.name)
+        Alchemy.t(code, default: name)
       end
     end
 
@@ -98,11 +101,35 @@ module Alchemy
       @layout_root_page ||= Page.layout_root_for(id)
     end
 
+    # All available locales matching this language
+    #
+    # Matching either the code (+language_code+ + +country_code+) or the +language_code+
+    #
+    # @return [Array]
+    #
+    def matching_locales
+      @_matching_locales ||= ::I18n.available_locales.select do |locale|
+        locale.to_s.split('-')[0] == language_code
+      end
+    end
+
     private
 
+    def set_locale
+      self.locale = matching_locales.reverse.detect do |locale|
+        locale.to_s == code || locale.to_s == language_code
+      end
+    end
+
+    def presence_of_locale_file
+      if locale.nil?
+        errors.add(:locale, :missing_file)
+      end
+    end
+
     def publicity_of_default_language
-      if self.default? && !self.public?
-        errors.add(:public, I18n.t("Default language has to be public"))
+      if default? && !public?
+        errors.add(:public, Alchemy.t("Default language has to be public"))
         return false
       else
         return true
@@ -110,8 +137,8 @@ module Alchemy
     end
 
     def presence_of_default_language
-      if Language.default == self && self.default_changed?
-        errors.add(:default, I18n.t("We need at least one default."))
+      if Language.default == self && default_changed?
+        errors.add(:default, Alchemy.t("We need at least one default."))
         return false
       else
         return true
@@ -126,7 +153,7 @@ module Alchemy
     end
 
     def set_pages_language
-      pages.update_all language_code: self.code
+      pages.update_all language_code: code
     end
 
     def check_for_default
@@ -138,7 +165,7 @@ module Alchemy
     end
 
     def unpublish_pages
-      self.pages.update_all(public: false)
+      pages.update_all(public: false)
     end
   end
 end

data/app/models/alchemy/language/code.rb

@@ -10,13 +10,10 @@ module Alchemy::Language::Code
   end
 
   module ClassMethods
-
     def find_by_code(code)
       codes = code.split('-')
       codes << '' if codes.length == 1
-      find_by_language_code_and_country_code *codes
+      find_by_language_code_and_country_code(*codes)
     end
-
   end
-
 end

data/app/models/alchemy/page.rb

@@ -40,12 +40,12 @@ module Alchemy
     include Alchemy::Touching
 
     DEFAULT_ATTRIBUTES_FOR_COPY = {
-      :do_not_autogenerate => true,
-      :do_not_sweep => true,
-      :visible => false,
-      :public => false,
-      :locked => false,
-      :locked_by => nil
+      do_not_autogenerate: true,
+      do_not_sweep: true,
+      visible: false,
+      public: false,
+      locked: false,
+      locked_by: nil
     }
     SKIPPED_ATTRIBUTES_ON_COPY = %w(id updated_at created_at creator_id updater_id lft rgt depth urlname cached_tag_list)
     PERMITTED_ATTRIBUTES = [
@@ -66,18 +66,18 @@ module Alchemy
     ]
 
     acts_as_taggable
-    acts_as_nested_set(:dependent => :destroy)
+    acts_as_nested_set(dependent: :destroy)
 
     stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :folded_pages
-    has_many :legacy_urls, :class_name => 'Alchemy::LegacyPageUrl'
+    has_many :legacy_urls, class_name: 'Alchemy::LegacyPageUrl'
     belongs_to :language
 
-    validates_presence_of :language, :on => :create, :unless => :root
-    validates_presence_of :page_layout, :unless => :systempage?
+    validates_presence_of :language, on: :create, unless: :root
+    validates_presence_of :page_layout, unless: :systempage?
     validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { systempage? || page_layout.blank? }
-    validates_presence_of :parent_id, :if => proc { Page.count > 1 }
+    validates_presence_of :parent_id, if: proc { Page.count > 1 }
 
     attr_accessor :do_not_sweep
     attr_accessor :do_not_validate_language
@@ -100,7 +100,6 @@ module Alchemy
     # Class methods
     #
     class << self
-
       alias_method :rootpage, :root
 
       # Used to store the current page previewed in the edit page template.
@@ -119,7 +118,7 @@ module Alchemy
       # @param language_id [Fixnum]
       #
       def language_root_for(language_id)
-        self.language_roots.find_by_language_id(language_id)
+        language_roots.find_by_language_id(language_id)
       end
 
       # Creates a copy of given source.
@@ -148,7 +147,7 @@ module Alchemy
       end
 
       def layout_root_for(language_id)
-        where({:parent_id => Page.root.id, :layoutpage => true, :language_id => language_id}).limit(1).first
+        where({parent_id: Page.root.id, layoutpage: true, language_id: language_id}).limit(1).first
       end
 
       def find_or_create_layout_root_for(language_id)
@@ -174,7 +173,7 @@ module Alchemy
         if source.children.any?
           source.copy_children_to(page)
         end
-        return page
+        page
       end
 
       def all_from_clipboard(clipboard)
@@ -184,17 +183,18 @@ module Alchemy
 
       def all_from_clipboard_for_select(clipboard, language_id, layoutpage = false)
         return [] if clipboard.blank?
-        clipboard_pages = self.all_from_clipboard(clipboard)
+        clipboard_pages = all_from_clipboard(clipboard)
         allowed_page_layouts = Alchemy::PageLayout.selectable_layouts(language_id, layoutpage)
         allowed_page_layout_names = allowed_page_layouts.collect { |p| p['name'] }
         clipboard_pages.select { |cp| allowed_page_layout_names.include?(cp.page_layout) }
       end
 
       def link_target_options
-        options = [[I18n.t(:default, scope: 'link_target_options'), '']]
+        options = [[Alchemy.t(:default, scope: 'link_target_options'), '']]
         link_target_options = Config.get(:link_target_options)
         link_target_options.each do |option|
-          options << [I18n.t(option, scope: 'link_target_options', default: option.to_s.humanize), option]
+          options << [Alchemy.t(option, scope: 'link_target_options',
+                                default: option.to_s.humanize), option]
         end
         options
       end
@@ -220,7 +220,7 @@ module Alchemy
         differences.stringify_keys!
         attributes = source.attributes.merge(differences)
         attributes.merge!(DEFAULT_ATTRIBUTES_FOR_COPY)
-        attributes.merge!('name' => new_name_for_copy(differences['name'], source.name))
+        attributes['name'] = new_name_for_copy(differences['name'], source.name)
         attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
       end
 
@@ -236,9 +236,8 @@ module Alchemy
       #
       def new_name_for_copy(custom_name, source_name)
         return custom_name if custom_name.present?
-        "#{source_name} (#{I18n.t('Copy')})"
+        "#{source_name} (#{Alchemy.t('Copy')})"
       end
-
     end
 
     # Instance methods
@@ -283,13 +282,13 @@ module Alchemy
     # Locks the page to given user without updating the timestamps
     #
     def lock_to!(user)
-      self.update_columns(locked: true, locked_by: user.id)
+      update_columns(locked: true, locked_by: user.id)
     end
 
     # Unlocks the page without updating the timestamps
     #
     def unlock!
-      if self.update_columns(locked: false, locked_by: nil)
+      if update_columns(locked: false, locked_by: nil)
         Page.current_preview = nil
       end
     end
@@ -302,7 +301,7 @@ module Alchemy
 
     def set_restrictions_to_child_pages
       descendants.each do |child|
-        child.update_attributes(:restricted => self.restricted?)
+        child.update_attributes(restricted: restricted?)
       end
     end
 
@@ -321,11 +320,11 @@ module Alchemy
     end
 
     def copy_children_to(new_parent)
-      self.children.each do |child|
+      children.each do |child|
         next if child == new_parent
         new_child = Page.copy(child, {
-          :language_id => new_parent.language_id,
-          :language_code => new_parent.language_code
+          language_id: new_parent.language_id,
+          language_code: new_parent.language_code
         })
         new_child.move_to_child_of(new_parent)
         child.copy_children_to(new_child) unless child.children.blank?
@@ -339,7 +338,7 @@ module Alchemy
     # The +published_at+ attribute is used as +cache_key+.
     #
     def publish!
-      update_columns(published_at: Time.now, public: true)
+      update_columns(published_at: Time.current, public: true)
     end
 
     # Updates an Alchemy::Page based on a new ordering to be applied to it
@@ -353,9 +352,9 @@ module Alchemy
     def update_node!(node)
       hash = {lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted}
 
-      if Config.get(:url_nesting) && !self.redirects_to_external? && self.urlname != node.url
-        LegacyPageUrl.create(page_id: self.id, urlname: self.urlname)
-        hash.merge!(urlname: node.url)
+      if Config.get(:url_nesting) && !redirects_to_external? && urlname != node.url
+        LegacyPageUrl.create(page_id: id, urlname: urlname)
+        hash[:urlname] = node.url
       end
 
       update_columns(hash)
@@ -388,12 +387,12 @@ module Alchemy
     end
 
     def set_language_from_parent_or_default
-      self.language = self.parent.language || Language.default
+      self.language = parent.language || Language.default
       set_language_code
     end
 
     def set_language_code
-      self.language_code = self.language.code
+      self.language_code = language.code
     end
 
     # Stores the old urlname in a LegacyPageUrl
@@ -402,8 +401,7 @@ module Alchemy
     end
 
     def update_published_at
-      self.published_at = Time.now
+      self.published_at = Time.current
     end
-
   end
 end

data/app/models/alchemy/page/page_cells.rb

@@ -1,15 +1,13 @@
 module Alchemy
   module Page::PageCells
-
     extend ActiveSupport::Concern
 
     included do
-      has_many :cells, :dependent => :destroy
-      after_create :create_cells, :if => :can_have_cells?, :unless => :systempage?
+      has_many :cells, dependent: :destroy
+      after_create :create_cells, if: :can_have_cells?, unless: :systempage?
     end
 
     module ClassMethods
-
       # Copy page cells
       #
       # @param source [Alchemy::Page]
@@ -19,14 +17,13 @@ module Alchemy
       def copy_cells(source, target)
         new_cells = []
         source.cells.each do |cell|
-          new_cells << Cell.create(:name => cell.name, :page_id => target.id)
+          new_cells << Cell.create(name: cell.name, page_id: target.id)
         end
         new_cells
       end
-
     end
 
-    # Returns true, if the page's page_layout defines cells.
+    # Returns true, if the page's definition defines cells.
     def can_have_cells?
       definition['cells'].present?
     end
@@ -55,7 +52,7 @@ module Alchemy
 
     # Returns element names that are not defined in a cell.
     def element_names_not_in_cell
-      layout_description['elements'].uniq - element_names_from_cells
+      definition['elements'].uniq - element_names_from_cells
     end
 
     private
@@ -63,9 +60,8 @@ module Alchemy
     # Creates cells that are defined in page's page_layout definition.
     def create_cells
       definition['cells'].each do |cellname|
-        cells.create!(:name => cellname)
+        cells.create!(name: cellname)
       end
     end
-
   end
 end

data/app/models/alchemy/page/page_elements.rb

@@ -1,25 +1,39 @@
 module Alchemy
   module Page::PageElements
-
     extend ActiveSupport::Concern
 
     included do
       attr_accessor :do_not_autogenerate
 
-      has_many :elements, -> { order(:position) }
-      has_many :contents, :through => :elements
-      has_and_belongs_to_many :to_be_sweeped_elements, -> { uniq },
+      has_many :elements, -> { where(parent_element_id: nil).not_trashed.order(:position) }
+      has_many :trashed_elements,
+        -> { Element.trashed.order(:position) },
+        class_name: 'Alchemy::Element'
+      has_many :descendent_elements,
+        -> { order(:position).not_trashed },
+        class_name: 'Alchemy::Element'
+      has_many :contents, through: :elements
+      has_many :descendent_contents,
+        through: :descendent_elements,
+        class_name: 'Alchemy::Content',
+        source: :contents
+      has_and_belongs_to_many :to_be_swept_elements, -> { uniq },
         class_name: 'Alchemy::Element',
         join_table: ElementToPage.table_name
 
-      after_create :autogenerate_elements, :unless => proc { systempage? || do_not_autogenerate }
-      after_update :trash_not_allowed_elements, :if => :page_layout_changed?
-      after_update :autogenerate_elements, :if => :page_layout_changed?
-      after_destroy { elements.each { |el| el.destroy unless el.trashed? } }
+      after_create :autogenerate_elements, unless: -> { systempage? || do_not_autogenerate }
+      after_update :trash_not_allowed_elements!, if: :page_layout_changed?
+      after_update :autogenerate_elements, if: :page_layout_changed?
+
+      after_destroy do
+        elements.each do |element|
+          next if element.trashed?
+          element.destroy
+        end
+      end
     end
 
     module ClassMethods
-
       # Copy page elements
       #
       # @param source [Alchemy::Page]
@@ -28,23 +42,61 @@ module Alchemy
       #
       def copy_elements(source, target)
         new_elements = []
-        source.elements.not_trashed.each do |element|
-          # detect cell for element
-          if element.cell
-            cell = target.cells.detect { |c| c.name == element.cell.name }
-          else
-            cell = nil
+        source.elements.not_trashed.each do |source_element|
+          cell = nil
+          if source_element.cell
+            cell = target.cells.find_by(name: source_element.cell.name)
           end
-          # if cell is nil also pass nil to element.cell_id
-          new_element = Element.copy(element, :page_id => target.id, :cell_id => (cell.blank? ? nil : cell.id))
-          # move element to bottom of the list
+          new_element = Element.copy source_element, {
+            page_id: target.id,
+            cell_id: cell.try(:id)
+          }
           new_element.move_to_bottom
           new_elements << new_element
         end
         new_elements
       end
+    end
 
+    # Finds elements of page.
+    #
+    # @param [Hash]
+    #   options hash
+    # @param [Boolean] (false)
+    #   Pass true, if you want to also have not published elements.
+    #
+    # @option options [Array] only
+    #   Returns only elements with given names
+    # @option options [Array] except
+    #   Returns all elements except the ones with given names
+    # @option options [Fixnum] count
+    #   Limit the count of returned elements
+    # @option options [Fixnum] offset
+    #   Starts with an offset while returning elements
+    # @option options [Boolean] random (false)
+    #   Return elements randomly shuffled
+    # @option options [Alchemy::Cell || String] from_cell
+    #   Return elements from given cell
+    #
+    # @return [ActiveRecord::Relation]
+    #
+    def find_elements(options = {}, show_non_public = false)
+      elements = elements_from_cell_or_self(options[:from_cell])
+      if options[:only].present?
+        elements = elements.named(options[:only])
+      elsif options[:except].present?
+        elements = elements.excluded(options[:except])
+      end
+      if options[:reverse_sort] || options[:reverse]
+        elements = elements.reverse_order
+      end
+      elements = elements.offset(options[:offset]).limit(options[:count])
+      if options[:random]
+        elements = elements.order("RAND()")
+      end
+      show_non_public ? elements : elements.published
     end
+    alias_method :find_selected_elements, :find_elements
 
     # All available element definitions that can actually be placed on current page.
     #
@@ -66,25 +118,36 @@ module Alchemy
     #     - name: text
     #       type: EssenceRichtext
     #
-    def available_element_definitions
-      @elements_for_layout ||= element_definitions
-      return [] if @elements_for_layout.blank?
-      @page_element_names = elements.not_trashed.pluck(:name)
+    def available_element_definitions(only_element_named = nil)
+      @_element_definitions ||= if only_element_named
+        definition = Element.definition_by_name(only_element_named)
+        element_definitions_by_name(definition['nestable_elements'])
+      else
+        element_definitions
+      end
+
+      return [] if @_element_definitions.blank?
+
+      @_existing_element_names = elements.not_trashed.pluck(:name)
       delete_unique_element_definitions!
       delete_outnumbered_element_definitions!
-      @elements_for_layout
+
+      @_element_definitions
     end
 
     # All names of elements that can actually be placed on current page.
     #
     def available_element_names
-      available_element_definitions.collect { |e| e['name'] }
+      @_available_element_names ||= available_element_definitions.map { |e| e['name'] }
     end
 
     # All element definitions defined for page's page layout
     #
+    # Warning: Since elements can be unique or limited in number,
+    # it is more safe to ask for +available_element_definitions+
+    #
     def element_definitions
-      element_definitions_by_name(element_definition_names)
+      @_element_definitions ||= element_definitions_by_name(element_definition_names)
     end
 
     # All names of elements that are defined in the corresponding
@@ -105,18 +168,10 @@ module Alchemy
     #     elements: [teaser]
     #
     def element_definition_names
-      element_names_from_page_definition | element_names_from_cell_definition
-    end
-
-    def element_names_from_page_definition
-      definition['elements'] || []
-    end
-
-    def element_names_from_cell_definition
-      cell_definitions.map { |d| d['elements'] }.flatten
+      element_names_from_definition | element_names_from_cell_definitions
     end
 
-    # Returns Element definitions with given name(s)
+    # Element definitions with given name(s)
     #
     # @param [Array || String]
     #   one or many Alchemy::Element names. Pass +'all'+ to get all Element definitions
@@ -125,6 +180,7 @@ module Alchemy
     #
     def element_definitions_by_name(names)
       return [] if names.blank?
+
       if names.to_s == "all"
         Element.definitions
       else
@@ -132,46 +188,6 @@ module Alchemy
       end
     end
 
-    # Finds elements of page.
-    #
-    # @param [Hash]
-    #   options hash
-    # @param [Boolean] (false)
-    #   Pass true, if you want to also have not published elements.
-    #
-    # @option options [Array] only
-    #   Returns only elements with given names
-    # @option options [Array] except
-    #   Returns all elements except the ones with given names
-    # @option options [Fixnum] count
-    #   Limit the count of returned elements
-    # @option options [Fixnum] offset
-    #   Starts with an offset while returning elements
-    # @option options [Boolean] random (false)
-    #   Return elements randomly shuffled
-    # @option options [Alchemy::Cell || String] from_cell
-    #   Return elements from given cell
-    #
-    # @return [ActiveRecord::Relation]
-    #
-    def find_elements(options = {}, show_non_public = false)
-      elements = elements_from_cell_or_self(options[:from_cell])
-      if options[:only].present?
-        elements = elements.named(options[:only])
-      elsif options[:except].present?
-        elements = elements.excluded(options[:except])
-      end
-      if options[:reverse_sort] || options[:reverse]
-        elements = elements.reverse_order
-      end
-      elements = elements.offset(options[:offset]).limit(options[:count])
-      if options[:random]
-        elements = elements.order("RAND()")
-      end
-      show_non_public ? elements : elements.published
-    end
-    alias_method :find_selected_elements, :find_elements
-
     # Returns all elements that should be feeded via rss.
     #
     # Define feedable elements in your +page_layouts.yml+:
@@ -181,17 +197,30 @@ module Alchemy
     #     feed_elements: [element_name, element_2_name]
     #
     def feed_elements
-      elements.named(definition['feed_elements'])
+      elements.available.named(definition['feed_elements'])
     end
 
-    # Returns an array of all EssenceRichtext contents ids
+    # Returns an array of all EssenceRichtext contents ids from not folded elements
     #
     def richtext_contents_ids
-      contents.essence_richtexts.pluck("#{Content.table_name}.id")
+      descendent_contents
+        .where(Element.table_name => {folded: false})
+        .select(&:has_tinymce?)
+        .collect(&:id)
+    end
+
+    def element_names_from_definition
+      definition['elements'] || []
     end
 
     private
 
+    def element_names_from_cell_definitions
+      @_element_names_from_cell_definitions ||= cell_definitions.map do |d|
+        d['elements']
+      end.flatten
+    end
+
     # Looks in the page_layout descripion, if there are elements to autogenerate.
     #
     # And if so, it generates them.
@@ -199,8 +228,8 @@ module Alchemy
     # If the page has cells, it looks if there are elements to generate.
     #
     def autogenerate_elements
-      elements_already_on_page = self.elements.available.pluck(:name)
-      elements = self.layout_description["autogenerate"]
+      elements_already_on_page = elements.available.pluck(:name)
+      elements = definition["autogenerate"]
       if elements.present?
         elements.each do |element|
           next if elements_already_on_page.include?(element)
@@ -211,37 +240,39 @@ module Alchemy
 
     # Returns a hash of attributes for given element name
     def attributes_for_element_name(element)
-      if self.has_cells? && (cell_definition = cell_definitions.detect { |c| c['elements'].include?(element) })
-        cell = self.cells.find_by_name(cell_definition['name'])
-        if cell
-          return {:page_id => self.id, :cell_id => cell.id, :name => element}
-        else
-          raise "Cell not found for page #{self.inspect}"
-        end
+      element_cell_definition = cell_definitions.detect { |c| c['elements'].include?(element) }
+      if has_cells? && element_cell_definition
+        cell = cells.find_by!(name: element_cell_definition['name'])
+        {page_id: id, cell_id: cell.id, name: element}
       else
-        return {:page_id => self.id, :name => element}
+        {page_id: id, name: element}
       end
     end
 
     # Trashes all elements that are not allowed for this page_layout.
-    def trash_not_allowed_elements
-      elements.select { |e| !definition['elements'].include?(e.name) }.map(&:trash!)
+    def trash_not_allowed_elements!
+      not_allowed_elements = elements.where([
+        "#{Element.table_name}.name NOT IN (?)",
+        element_names_from_definition
+      ])
+      not_allowed_elements.to_a.map(&:trash!)
     end
 
-    # Deletes unique and already present definitions from @elements_for_layout.
+    # Deletes unique and already present definitions from @_element_definitions.
     #
     def delete_unique_element_definitions!
-      @elements_for_layout.delete_if { |element|
-        element['unique'] && @page_element_names.include?(element['name'])
-      }
+      @_element_definitions.delete_if do |element|
+        element['unique'] && @_existing_element_names.include?(element['name'])
+      end
     end
 
-    # Deletes limited and outnumbered definitions from @elements_for_layout.
+    # Deletes limited and outnumbered definitions from @_element_definitions.
     #
     def delete_outnumbered_element_definitions!
-      @elements_for_layout.delete_if { |element|
-        element['amount'] && @page_element_names.select { |i| i == element['name'] }.count >= element['amount'].to_i
-      }
+      @_element_definitions.delete_if do |element|
+        outnumbered = @_existing_element_names.select { |name| name == element['name'] }
+        element['amount'] && outnumbered.count >= element['amount'].to_i
+      end
     end
 
     # Returns elements either from given cell or self
@@ -253,7 +284,7 @@ module Alchemy
       when 'String'
         cell_elements_by_name(cell)
       else
-        self.elements.not_in_cell
+        elements.not_in_cell
       end
     end
 
@@ -267,6 +298,5 @@ module Alchemy
         Element.none
       end
     end
-
   end
 end