Checks if the parents have unsaved changes

 @return [Boolean]
  true if the parents have unsaved changes

 @api private
517988
def dirty_parents?
      run_once(false) do
        parent_associations.any? do |association|
          association.__send__(:dirty_self?) || association.__send__(:dirty_parents?)
        end
      end
    end
249148
public function hasChanged()
    {
        foreach ($this->modelData as $property => $value) {
            if ($this->hasPropertyChanged($property)) {
                return true;
            }
        }

        // In case model data has been manually unset
        $manuallyUnsetProperties = array_diff_key($this->changeSnapshotData, $this->modelData);
        foreach ($manuallyUnsetProperties as $property => $value) {
            // If it wasn't null before, that's a change
            if ($value !== null) {
                return true;
            }
        }

        return false;
    }
551429
def parent
      assert_exists

      e = @element.parent

      if e.kind_of?(Nokogiri::XML::Element)
        WatirNokogiri.element_class_for(e.node_name.downcase).new(@parent, :element => e)
      end
    end
1097828
def reset(self):
        
        self.added = []
        self.changed = []
        self.removed = []
        self.parents = []
492834
def last_change_of(attribute)
      raise "#{attribute} is not audited for model #{self.class}. Audited attributes: #{self.class.audited_attributes}" unless self.class.audited_attributes.include? attribute.to_sym
      attribute = attribute.to_s # support symbol as well
      last = audits.size - 1
      last.downto(1) do |i|
        if audits[i].modifications[attribute] != audits[i-1].modifications[attribute]
          return audits[i].diff(audits[i-1])[attribute]
        end
      end
      nil
    end
911459
def parents
      parent = @ancestor
      (@ancestor.instance.path.size...self.instance.path.size).map do |i|
        parent.tap do
          parent = parent[self.instance.path[i]]
        end
      end.reverse
    end
1346043
def check_impl(self):
        

        c = False
        for change in self.collect():
            change.check()
            c = c or change.is_change()
        return c, None
622680
def modified(self):
        
        if self._removes:
            return True
        for v in self._value:
            if self._value[v].modified:
                return True
        for v in self._updates:
            if self._updates[v].modified:
                return True
        return False
819410
function(attr) {
        if (!arguments.length) {
          return !_.isEmpty(this.changed);
        }
        return this.changed && _.has(this.changed, attr);
      }
646661
def rearrange
      if self.parent_id
        self.parent_ids = parent.parent_ids + [self.parent_id]
      else
        self.parent_ids = []
      end

      self.depth = parent_ids.size

      rearrange_children! if self.parent_ids_changed?
    end
140214
def is_ignored(self, options):
        

        if not self.is_change():
            return False

        changes = self.collect()
        if not changes:
            return False

        for change in changes:
            if change.is_change() and not change.is_ignored(options):
                return False
        return True
250556
async function hasBreakingChange() {
  debug('checking for breaking changes between HEAD and upstream/master');
  const bodies = await exec('git log upstream/master.. --format=%b');

  if (/^BREAKING CHANGE:/.test(bodies)) {
    debug('found breaking change');

    return true;
  }
  debug('no breaking changes detected');

  return false;
}
593803
def persist!(saved = false)
      @new_record, @uri = false
      if changed?
        @previous_changes = changes if saved
        changed_attributes.clear
      end
      true
    end
1049694
def no_missing_parents(data_wrapper):
    '''
    '''
    db = data_wrapper.data_block
    ids = np.setdiff1d(db[:, COLS.P], db[:, COLS.ID])[1:]
    return CheckResult(len(ids) == 0, ids.astype(np.int) + 1)
128312
public function isEmbeddedOneChangedInParent()
    {
        if (!$rap = $this->getRootAndPath()) {
            return false;
        }

        if ($rap['root'] instanceof EmbeddedGroup) {
            return false;
        }

        $exPath = explode('.', $rap['path']);
        unset($exPath[count($exPath) -1 ]);

        $parentDocument = $rap['root'];
        foreach ($exPath as $embedded) {
            $parentDocument = $parentDocument->{'get'.ucfirst($embedded)}();
            if ($parentDocument instanceof EmbeddedGroup) {
                return false;
            }
        }

        $rap = $this->getRootAndPath();
        $exPath = explode('.', $rap['path']);
        $name = $exPath[count($exPath) - 1];

        return $parentDocument->isEmbeddedOneChanged($name);
    }
192399
def needs_sync(self):
        """"""

        affected_attributes = [
            'css_files', 'js_files',
            'scss_files', 'widgets']

        for attr in affected_attributes:
            if len(getattr(self, attr)) > 0:
                return True
        return False
1289464
def nested_records_changed_for_autosave?
      self.class.reflect_on_all_autosave_associations.any? do |reflection|
        association = association_instance_get(reflection.name)
        association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
      end
    end