Execute the on_every_page blocks for *page*
421685
def do_page_blocks(page)
      @on_every_page_blocks.each do |block|
        block.call(page)
      end

      @on_pages_like_blocks.each do |pattern, blocks|
        blocks.each { |block| block.call(page) } if page.url.to_s =~ pattern
      end
    end
505773
function () /*:Void*/ {

        //set the current page
        this._curPage = this._pages.shift();

        this.fire(this.TEST_PAGE_BEGIN_EVENT, this._curPage);

        //load the frame - destroy history in case there are other iframes that
        //need testing
        this._frame.location.replace(this._curPage);

    }
346551
def assign_pages!
      payload["page"] = document.to_liquid
      payload["paginator"] = (document.pager.to_liquid if document.respond_to?(:pager))
    end
926992
def select_page(self, limit, offset=0, **kwargs):
        
        start = offset
        while True:
            result = self.select(limit=[start, limit], **kwargs)
            start += limit
            if result:
                yield result
            else:
                break
            if self.debug:
                break
376811
def each(&block)
      items = self.next.to_h['items']

      until items.empty?
        items.each(&block)
        items = self.next.to_h['items']
      end
    end
303842
function internalAction(scope, page) {

        // Block clicks we try to load the active page
        if (scope.page == page) {
            return;
        }

        // Block if we are forcing disabled 
        if(scope.isDisabled)
        {
            return;
        }

        // Update the page in scope
        scope.page = page;

        // Pass our parameters to the paging action
        scope.pagingAction({
            page: scope.page,
            pageSize: scope.pageSize,
            total: scope.total
        });

        // If allowed scroll up to the top of the page
        if (scope.scrollTop) {
            scrollTo(0, 0);
        }
    }
98243
def each(cmd_options={}, &block)
      all(cmd_options).each do |commit|
        block.call(commit)
      end
    end
149621
function internalAction(scope, page) {
                page = page.valueOf();
                // Block clicks we try to load the active page
                if (scope.page == page) {
                    return;
                }

                // Update the page in scope and fire any paging actions
                scope.page = page;
                scope.paginationAction({
                    page: page
                });

                // If allowed scroll up to the top of the page
                if (scope.scrollTop) {
                    scrollTo(0, 0);
                }
            }
738271
def each(&block)
      return enum_for(:each_page) unless block_given?
      response = self
      yield(response)
      until response.last_page?
        response = response.next_page
        yield(response)
      end
    end
1300501
def run(self, block=True, binary=False, cwd=None):
        """"""
        self.blocking = block

        # Use subprocess.
        if self.blocking:
            popen_kwargs = self._default_popen_kwargs.copy()
            popen_kwargs['universal_newlines'] = not binary
            if cwd:
                popen_kwargs['cwd'] = cwd
            s = subprocess.Popen(self._popen_args, **popen_kwargs)
        # Otherwise, use pexpect.
        else:
            pexpect_kwargs = self._default_pexpect_kwargs.copy()
            if binary:
                pexpect_kwargs['encoding'] = None
            if cwd:
                pexpect_kwargs['cwd'] = cwd
            # Enable Python subprocesses to work with expect functionality.
            pexpect_kwargs['env']['PYTHONUNBUFFERED'] = '1'
            s = PopenSpawn(self._popen_args, **pexpect_kwargs)
        self.subprocess = s
        self.was_run = True
99080
def generate_pages(self):
		
		for page in self.pages:
			self.generate_page(page.slug, template='page.html.jinja', page=page)
1206464
def each
      return enum_for(:each) unless block_given?

      index = 1

      until ((next_page = page_cache[index]).empty?) do
        yield next_page
        index = index + 1
      end

      return self
    end
1364384
public function execute(int $page, int $limit): void
    {
        $page = $page <= 1 ? 1 : $page;
        $rows = $this->getRows($page, $limit);

        $headers = [];
        $mode = 'a';
        if (1 === $page) {
            $headers = $this->getHeaders();
            $mode = 'w';
        }

        // Prepend columns to result
        if (!empty($headers)) {
            array_unshift($rows, $headers);
        }

        $this->create($rows, $mode);
    }
864874
def notblocked(page):
    """"""
    for blocked in PAGES_TO_BLOCK:
        if blocked[0] != '*':
            blocked = '*' + blocked
        rx = re.compile(blocked.replace('*', '[^$]*'))
        if rx.match(page):
            return False
    return True
78460
def each(&block)
      @btree.each do |index, entry|
        if entry.is_a?(Collisions)
          break unless entry.each do |c_entry|
            yield(c_entry.key, c_entry.value)
          end
        else
          yield(entry.key, entry.value)
        end
      end
    end
1250771
def each &block
    sql, *binds = SQLHelper.select(
        :prepared => true,
        :table    => name,
        :project  => @query_select,
        :where    => @query_where,
        :order    => @query_order,
        :limit    => @query_limit)
    pstmt = prepare :select, sql
    pstmt.enumerate(*binds, &block)
  end
187580
def on_load(name, options = {}, &block)
      @loaded[name].each do |base|
        execute_hook(name, base, options, block)
      end

      @load_hooks[name] << [block, options]
    end