cheesy-gallery 0.5.0 → 1.1.0

data/sorbet/rbi/gems/kramdown.rbi

@@ -0,0 +1,250 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: ignore
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/kramdown/all/kramdown.rbi
+#
+# kramdown-2.3.1
+
+module Kramdown
+  def self.data_dir; end
+end
+class Kramdown::Element
+  def attr; end
+  def block?; end
+  def children; end
+  def children=(arg0); end
+  def initialize(type, value = nil, attr = nil, options = nil); end
+  def inspect; end
+  def options; end
+  def self.category(el); end
+  def span?; end
+  def type; end
+  def type=(arg0); end
+  def value; end
+  def value=(arg0); end
+end
+class Kramdown::Error < RuntimeError
+end
+module Kramdown::Parser
+end
+module Kramdown::Utils
+  def self.camelize(name); end
+  def self.deep_const_get(str); end
+  def self.snake_case(name); end
+end
+module Kramdown::Utils::Configurable
+  def configurable(name); end
+end
+module Kramdown::Converter
+  def self.add_math_engine(data, *args, &block); end
+  def self.add_syntax_highlighter(data, *args, &block); end
+  def self.configurables; end
+  def self.math_engine(data); end
+  def self.syntax_highlighter(data); end
+  extend Kramdown::Utils::Configurable
+end
+module Kramdown::Options
+  def self.defaults; end
+  def self.define(name, type, default, desc, &block); end
+  def self.defined?(name); end
+  def self.definitions; end
+  def self.merge(hash); end
+  def self.parse(name, data); end
+  def self.simple_array_validator(val, name, size = nil); end
+  def self.simple_hash_validator(val, name); end
+  def self.str_to_sym(data); end
+end
+class Kramdown::Options::Boolean
+  def self.===(other); end
+end
+class Kramdown::Options::Definition < Struct
+  def default; end
+  def default=(_); end
+  def desc; end
+  def desc=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def type; end
+  def type=(_); end
+  def validator; end
+  def validator=(_); end
+end
+class Kramdown::Document
+  def initialize(source, options = nil); end
+  def inspect; end
+  def method_missing(id, *attr, &block); end
+  def options; end
+  def root; end
+  def root=(arg0); end
+  def try_require(type, name); end
+  def warnings; end
+end
+class Kramdown::Parser::Base
+  def adapt_source(source); end
+  def add_text(text, tree = nil, type = nil); end
+  def extract_string(range, strscan); end
+  def initialize(source, options); end
+  def options; end
+  def parse; end
+  def root; end
+  def self.allocate; end
+  def self.new(*arg0); end
+  def self.parse(source, options = nil); end
+  def source; end
+  def warning(text); end
+  def warnings; end
+end
+class Kramdown::Parser::Kramdown < Kramdown::Parser::Base
+  def add_header(level, text, id); end
+  def add_link(el, href, title, alt_text = nil, ial = nil); end
+  def after_block_boundary?; end
+  def before_block_boundary?; end
+  def configure_parser; end
+  def correct_abbreviations_attributes; end
+  def fetch_pattern(type, indentation); end
+  def handle_extension(name, opts, body, type, line_no = nil); end
+  def handle_kramdown_html_tag(el, closed, handle_body); end
+  def initialize(source, options); end
+  def new_block_el(*args); end
+  def normalize_link_id(id); end
+  def paragraph_end; end
+  def parse; end
+  def parse_abbrev_definition; end
+  def parse_attribute_list(str, opts); end
+  def parse_atx_header; end
+  def parse_autolink; end
+  def parse_blank_line; end
+  def parse_block_extensions; end
+  def parse_block_html; end
+  def parse_block_math; end
+  def parse_blockquote; end
+  def parse_blocks(el, text = nil); end
+  def parse_codeblock; end
+  def parse_codeblock_fenced; end
+  def parse_codespan; end
+  def parse_definition_list; end
+  def parse_emphasis; end
+  def parse_eob_marker; end
+  def parse_escaped_chars; end
+  def parse_extension_start_tag(type); end
+  def parse_first_list_line(indentation, content); end
+  def parse_footnote_definition; end
+  def parse_footnote_marker; end
+  def parse_header_contents; end
+  def parse_horizontal_rule; end
+  def parse_html_entity; end
+  def parse_inline_math; end
+  def parse_line_break; end
+  def parse_link; end
+  def parse_link_definition; end
+  def parse_list; end
+  def parse_paragraph; end
+  def parse_setext_header; end
+  def parse_smart_quotes; end
+  def parse_span_extensions; end
+  def parse_span_html; end
+  def parse_spans(el, stop_re = nil, parsers = nil, text_type = nil); end
+  def parse_table; end
+  def parse_typographic_syms; end
+  def replace_abbreviations(el, regexps = nil); end
+  def reset_env(opts = nil); end
+  def restore_env(env); end
+  def save_env; end
+  def self.define_parser(name, start_re, span_start = nil, meth_name = nil); end
+  def self.has_parser?(name); end
+  def self.parser(name = nil); end
+  def span_parser_regexps(parsers = nil); end
+  def span_pattern_cache(stop_re, span_start); end
+  def update_attr_with_ial(attr, ial); end
+  def update_ial_with_ial(ial, opts); end
+  def update_link_definitions(link_defs); end
+  def update_raw_text(item); end
+  def update_tree(element); end
+  include Kramdown
+  include Kramdown::Parser::Html::Parser
+end
+module Kramdown::Utils::Entities
+  def entity(point_or_name); end
+  def self.entity(point_or_name); end
+end
+class Kramdown::Utils::Entities::Entity < Struct
+  def char; end
+  def code_point; end
+  def code_point=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Kramdown::Parser::Html < Kramdown::Parser::Base
+  def parse; end
+  include Kramdown::Parser::Html::Parser
+end
+module Kramdown::Parser::Html::Constants
+end
+module Kramdown::Parser::Html::Parser
+  def handle_html_start_tag(line = nil); end
+  def handle_raw_html_tag(name); end
+  def parse_html_attributes(str, line = nil, in_html_tag = nil); end
+  def parse_raw_html(el, &block); end
+  include Kramdown::Parser::Html::Constants
+end
+class Kramdown::Parser::Html::ElementConverter
+  def convert_a(el); end
+  def convert_b(el); end
+  def convert_code(el); end
+  def convert_em(el); end
+  def convert_h1(el); end
+  def convert_h2(el); end
+  def convert_h3(el); end
+  def convert_h4(el); end
+  def convert_h5(el); end
+  def convert_h6(el); end
+  def convert_i(el); end
+  def convert_pre(el); end
+  def convert_script(el); end
+  def convert_strong(el); end
+  def convert_table(el); end
+  def convert_textarea(el); end
+  def extract_text(el, raw); end
+  def handle_math_tag(el); end
+  def initialize(root); end
+  def is_math_tag?(el); end
+  def is_simple_table?(el); end
+  def process(el, do_conversion = nil, preserve_text = nil, parent = nil); end
+  def process_children(el, do_conversion = nil, preserve_text = nil); end
+  def process_html_element(el, do_conversion = nil, preserve_text = nil); end
+  def process_text(raw, preserve = nil); end
+  def remove_text_children(el); end
+  def remove_whitespace_children(el); end
+  def self.convert(root, el = nil); end
+  def set_basics(el, type, opts = nil); end
+  def strip_whitespace(el); end
+  def wrap_text_children(el); end
+  include Kramdown::Parser::Html::Constants
+  include Kramdown::Utils::Entities
+end
+class Kramdown::Parser::Kramdown::Data < Struct
+  def method; end
+  def method=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def span_start; end
+  def span_start=(_); end
+  def start_re; end
+  def start_re=(_); end
+end

data/sorbet/rbi/gems/liquid.rbi

@@ -0,0 +1,649 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/liquid/all/liquid.rbi
+#
+# liquid-4.0.3
+
+module Liquid
+  def self.cache_classes; end
+  def self.cache_classes=(arg0); end
+end
+class Liquid::ParseTreeVisitor
+  def add_callback_for(*classes, &block); end
+  def children; end
+  def initialize(node, callbacks); end
+  def self.for(node, callbacks = nil); end
+  def visit(context = nil); end
+end
+class Liquid::Lexer
+  def initialize(input); end
+  def tokenize; end
+end
+class Liquid::Parser
+  def argument; end
+  def consume(type = nil); end
+  def consume?(type); end
+  def expression; end
+  def id?(str); end
+  def initialize(input); end
+  def jump(point); end
+  def look(type, ahead = nil); end
+  def variable_signature; end
+end
+class Liquid::I18n
+  def deep_fetch_translation(name); end
+  def initialize(path = nil); end
+  def interpolate(name, vars); end
+  def locale; end
+  def path; end
+  def t(name, vars = nil); end
+  def translate(name, vars = nil); end
+end
+class Liquid::I18n::TranslationError < StandardError
+end
+class Liquid::Drop
+  def [](method_or_key); end
+  def context=(arg0); end
+  def inspect; end
+  def invoke_drop(method_or_key); end
+  def key?(_name); end
+  def liquid_method_missing(method); end
+  def self.invokable?(method_name); end
+  def self.invokable_methods; end
+  def to_liquid; end
+  def to_s; end
+end
+class Liquid::TablerowloopDrop < Liquid::Drop
+  def col0; end
+  def col; end
+  def col_first; end
+  def col_last; end
+  def first; end
+  def increment!; end
+  def index0; end
+  def index; end
+  def initialize(length, cols); end
+  def last; end
+  def length; end
+  def rindex0; end
+  def rindex; end
+  def row; end
+end
+class Liquid::ForloopDrop < Liquid::Drop
+  def first; end
+  def increment!; end
+  def index0; end
+  def index; end
+  def initialize(name, length, parentloop); end
+  def last; end
+  def length; end
+  def name; end
+  def parentloop; end
+  def rindex0; end
+  def rindex; end
+end
+class String
+  def to_liquid; end
+end
+class Symbol
+  def to_liquid; end
+end
+class Array
+  def to_liquid; end
+end
+class Hash
+  def to_liquid; end
+end
+class Numeric
+  def to_liquid; end
+end
+class Range
+  def to_liquid; end
+end
+class Time
+  def to_liquid; end
+end
+class DateTime < Date
+  def to_liquid; end
+end
+class Date
+  def to_liquid; end
+end
+class TrueClass
+  def to_liquid; end
+end
+class FalseClass
+  def to_liquid; end
+end
+class NilClass
+  def to_liquid; end
+end
+class Liquid::Error < StandardError
+  def line_number; end
+  def line_number=(arg0); end
+  def markup_context; end
+  def markup_context=(arg0); end
+  def message_prefix; end
+  def template_name; end
+  def template_name=(arg0); end
+  def to_s(with_prefix = nil); end
+end
+class Liquid::ArgumentError < Liquid::Error
+end
+class Liquid::ContextError < Liquid::Error
+end
+class Liquid::FileSystemError < Liquid::Error
+end
+class Liquid::StandardError < Liquid::Error
+end
+class Liquid::SyntaxError < Liquid::Error
+end
+class Liquid::StackLevelError < Liquid::Error
+end
+class Liquid::TaintedError < Liquid::Error
+end
+class Liquid::MemoryError < Liquid::Error
+end
+class Liquid::ZeroDivisionError < Liquid::Error
+end
+class Liquid::FloatDomainError < Liquid::Error
+end
+class Liquid::UndefinedVariable < Liquid::Error
+end
+class Liquid::UndefinedDropMethod < Liquid::Error
+end
+class Liquid::UndefinedFilter < Liquid::Error
+end
+class Liquid::MethodOverrideError < Liquid::Error
+end
+class Liquid::InternalError < Liquid::Error
+end
+class Liquid::Interrupt
+  def initialize(message = nil); end
+  def message; end
+end
+class Liquid::BreakInterrupt < Liquid::Interrupt
+end
+class Liquid::ContinueInterrupt < Liquid::Interrupt
+end
+class Liquid::Strainer
+  def initialize(context); end
+  def invoke(method, *args); end
+  def self.add_filter(filter); end
+  def self.create(context, filters = nil); end
+  def self.filter_methods; end
+  def self.global_filter(filter); end
+  def self.invokable?(method); end
+end
+class Liquid::Expression
+  def self.parse(markup); end
+end
+class Liquid::Expression::MethodLiteral
+  def initialize(method_name, to_s); end
+  def method_name; end
+  def to_liquid; end
+  def to_s; end
+end
+class Liquid::Context
+  def [](expression); end
+  def []=(key, value); end
+  def add_filters(filters); end
+  def apply_global_filter(obj); end
+  def clear_instance_assigns; end
+  def environments; end
+  def errors; end
+  def evaluate(object); end
+  def exception_renderer; end
+  def exception_renderer=(arg0); end
+  def find_variable(key, raise_on_not_found: nil); end
+  def global_filter; end
+  def global_filter=(arg0); end
+  def handle_error(e, line_number = nil); end
+  def initialize(environments = nil, outer_scope = nil, registers = nil, rethrow_errors = nil, resource_limits = nil); end
+  def internal_error; end
+  def interrupt?; end
+  def invoke(method, *args); end
+  def key?(key); end
+  def lookup_and_evaluate(obj, key, raise_on_not_found: nil); end
+  def merge(new_scopes); end
+  def partial; end
+  def partial=(arg0); end
+  def pop; end
+  def pop_interrupt; end
+  def push(new_scope = nil); end
+  def push_interrupt(e); end
+  def registers; end
+  def resource_limits; end
+  def scopes; end
+  def squash_instance_assigns_with_environments; end
+  def stack(new_scope = nil); end
+  def strainer; end
+  def strict_filters; end
+  def strict_filters=(arg0); end
+  def strict_variables; end
+  def strict_variables=(arg0); end
+  def template_name; end
+  def template_name=(arg0); end
+  def warnings; end
+end
+module Liquid::ParserSwitching
+  def markup_context(markup); end
+  def parse_with_selected_parser(markup); end
+  def strict_parse_with_error_context(markup); end
+end
+class Liquid::Tag
+  def blank?; end
+  def initialize(tag_name, markup, parse_context); end
+  def line_number; end
+  def name; end
+  def nodelist; end
+  def options; end
+  def parse(_tokens); end
+  def parse_context; end
+  def raw; end
+  def render(_context); end
+  def self.new(*arg0); end
+  def self.parse(tag_name, markup, tokenizer, options); end
+  def tag_name; end
+  include Liquid::ParserSwitching
+end
+class Liquid::Block < Liquid::Tag
+  def blank?; end
+  def block_delimiter; end
+  def block_name; end
+  def initialize(tag_name, markup, options); end
+  def nodelist; end
+  def parse(tokens); end
+  def parse_body(body, tokens); end
+  def render(context); end
+  def unknown_tag(tag, _params, _tokens); end
+end
+class Liquid::BlockBody
+  def blank?; end
+  def check_resources(context, node_output); end
+  def create_variable(token, parse_context); end
+  def initialize; end
+  def nodelist; end
+  def parse(tokenizer, parse_context); end
+  def raise_missing_tag_terminator(token, parse_context); end
+  def raise_missing_variable_terminator(token, parse_context); end
+  def registered_tags; end
+  def render(context); end
+  def render_node_to_output(node, output, context, skip_output = nil); end
+  def whitespace_handler(token, parse_context); end
+end
+class Liquid::Document < Liquid::BlockBody
+  def parse(tokens, parse_context); end
+  def self.parse(tokens, parse_context); end
+  def unknown_tag(tag, parse_context); end
+end
+class Liquid::Variable
+  def evaluate_filter_expressions(context, filter_args, filter_kwargs); end
+  def filters; end
+  def filters=(arg0); end
+  def initialize(markup, parse_context); end
+  def lax_parse(markup); end
+  def line_number; end
+  def line_number=(arg0); end
+  def markup_context(markup); end
+  def name; end
+  def name=(arg0); end
+  def options; end
+  def parse_context; end
+  def parse_filter_expressions(filter_name, unparsed_args); end
+  def parse_filterargs(p); end
+  def raw; end
+  def render(context); end
+  def strict_parse(markup); end
+  def taint_check(context, obj); end
+  include Liquid::ParserSwitching
+end
+class Liquid::Variable::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::VariableLookup
+  def ==(other); end
+  def evaluate(context); end
+  def initialize(markup); end
+  def lookups; end
+  def name; end
+  def self.parse(markup); end
+  def state; end
+end
+class Liquid::VariableLookup::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::RangeLookup
+  def evaluate(context); end
+  def initialize(start_obj, end_obj); end
+  def self.parse(start_markup, end_markup); end
+  def to_integer(input); end
+end
+class Liquid::BlankFileSystem
+  def read_template_file(_template_path); end
+end
+class Liquid::LocalFileSystem
+  def full_path(template_path); end
+  def initialize(root, pattern = nil); end
+  def read_template_file(template_path); end
+  def root; end
+  def root=(arg0); end
+end
+class Liquid::ResourceLimits
+  def assign_score; end
+  def assign_score=(arg0); end
+  def assign_score_limit; end
+  def assign_score_limit=(arg0); end
+  def initialize(limits); end
+  def reached?; end
+  def render_length; end
+  def render_length=(arg0); end
+  def render_length_limit; end
+  def render_length_limit=(arg0); end
+  def render_score; end
+  def render_score=(arg0); end
+  def render_score_limit; end
+  def render_score_limit=(arg0); end
+  def reset; end
+end
+class Liquid::Template
+  def apply_options_to_context(context, options); end
+  def assigns; end
+  def errors; end
+  def initialize; end
+  def instance_assigns; end
+  def parse(source, options = nil); end
+  def profiler; end
+  def registers; end
+  def render!(*args); end
+  def render(*args); end
+  def resource_limits; end
+  def root; end
+  def root=(arg0); end
+  def self.default_exception_renderer; end
+  def self.default_exception_renderer=(arg0); end
+  def self.default_resource_limits; end
+  def self.error_mode; end
+  def self.error_mode=(arg0); end
+  def self.file_system; end
+  def self.file_system=(obj); end
+  def self.parse(source, options = nil); end
+  def self.register_filter(mod); end
+  def self.register_tag(name, klass); end
+  def self.tags; end
+  def self.taint_mode; end
+  def self.taint_mode=(arg0); end
+  def tokenize(source); end
+  def warnings; end
+  def with_profiling(context); end
+end
+class Liquid::Template::TagRegistry
+  def [](tag_name); end
+  def []=(tag_name, klass); end
+  def delete(tag_name); end
+  def each(&block); end
+  def initialize; end
+  def lookup_class(name); end
+  include Enumerable
+end
+module Liquid::StandardFilters
+  def abs(input); end
+  def append(input, string); end
+  def apply_operation(input, operand, operation); end
+  def at_least(input, n); end
+  def at_most(input, n); end
+  def capitalize(input); end
+  def ceil(input); end
+  def compact(input, property = nil); end
+  def concat(input, array); end
+  def date(input, format); end
+  def default(input, default_value = nil); end
+  def divided_by(input, operand); end
+  def downcase(input); end
+  def escape(input); end
+  def escape_once(input); end
+  def first(array); end
+  def floor(input); end
+  def h(input); end
+  def join(input, glue = nil); end
+  def last(array); end
+  def lstrip(input); end
+  def map(input, property); end
+  def minus(input, operand); end
+  def modulo(input, operand); end
+  def newline_to_br(input); end
+  def nil_safe_casecmp(a, b); end
+  def nil_safe_compare(a, b); end
+  def plus(input, operand); end
+  def prepend(input, string); end
+  def raise_property_error(property); end
+  def remove(input, string); end
+  def remove_first(input, string); end
+  def replace(input, string, replacement = nil); end
+  def replace_first(input, string, replacement = nil); end
+  def reverse(input); end
+  def round(input, n = nil); end
+  def rstrip(input); end
+  def size(input); end
+  def slice(input, offset, length = nil); end
+  def sort(input, property = nil); end
+  def sort_natural(input, property = nil); end
+  def split(input, pattern); end
+  def strip(input); end
+  def strip_html(input); end
+  def strip_newlines(input); end
+  def times(input, operand); end
+  def truncate(input, length = nil, truncate_string = nil); end
+  def truncatewords(input, words = nil, truncate_string = nil); end
+  def uniq(input, property = nil); end
+  def upcase(input); end
+  def url_decode(input); end
+  def url_encode(input); end
+  def where(input, property, target_value = nil); end
+end
+class Liquid::StandardFilters::InputIterator
+  def compact; end
+  def concat(args); end
+  def each; end
+  def empty?; end
+  def initialize(input); end
+  def join(glue); end
+  def reverse; end
+  def uniq(&block); end
+  include Enumerable
+end
+class Liquid::Condition
+  def and(condition); end
+  def attach(attachment); end
+  def attachment; end
+  def child_condition; end
+  def child_relation; end
+  def else?; end
+  def equal_variables(left, right); end
+  def evaluate(context = nil); end
+  def initialize(left = nil, operator = nil, right = nil); end
+  def inspect; end
+  def interpret_condition(left, right, op, context); end
+  def left; end
+  def left=(arg0); end
+  def operator; end
+  def operator=(arg0); end
+  def or(condition); end
+  def right; end
+  def right=(arg0); end
+  def self.operators; end
+end
+class Liquid::Condition::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::ElseCondition < Liquid::Condition
+  def else?; end
+  def evaluate(_context); end
+end
+module Liquid::Utils
+  def self.slice_collection(collection, from, to); end
+  def self.slice_collection_using_each(collection, from, to); end
+  def self.to_date(obj); end
+  def self.to_integer(num); end
+  def self.to_number(obj); end
+end
+class Liquid::Tokenizer
+  def initialize(source, line_numbers = nil); end
+  def line_number; end
+  def shift; end
+  def tokenize; end
+end
+class Liquid::ParseContext
+  def [](option_key); end
+  def depth; end
+  def depth=(arg0); end
+  def error_mode; end
+  def initialize(options = nil); end
+  def line_number; end
+  def line_number=(arg0); end
+  def locale; end
+  def locale=(arg0); end
+  def partial; end
+  def partial=(value); end
+  def partial_options; end
+  def trim_whitespace; end
+  def trim_whitespace=(arg0); end
+  def warnings; end
+end
+class Liquid::Assign < Liquid::Tag
+  def assign_score_of(val); end
+  def blank?; end
+  def from; end
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+  def to; end
+end
+class Liquid::Assign::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Break < Liquid::Tag
+  def interrupt; end
+end
+class Liquid::Capture < Liquid::Block
+  def blank?; end
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+end
+class Liquid::Case < Liquid::Block
+  def blocks; end
+  def initialize(tag_name, markup, options); end
+  def left; end
+  def nodelist; end
+  def parse(tokens); end
+  def record_else_condition(markup); end
+  def record_when_condition(markup); end
+  def render(context); end
+  def unknown_tag(tag, markup, tokens); end
+end
+class Liquid::Case::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Comment < Liquid::Block
+  def blank?; end
+  def render(_context); end
+  def unknown_tag(_tag, _markup, _tokens); end
+end
+class Liquid::Continue < Liquid::Tag
+  def interrupt; end
+end
+class Liquid::Cycle < Liquid::Tag
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+  def variables; end
+  def variables_from_string(markup); end
+end
+class Liquid::Cycle::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Decrement < Liquid::Tag
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+end
+class Liquid::For < Liquid::Block
+  def collection_name; end
+  def collection_segment(context); end
+  def from; end
+  def initialize(tag_name, markup, options); end
+  def lax_parse(markup); end
+  def limit; end
+  def nodelist; end
+  def parse(tokens); end
+  def render(context); end
+  def render_else(context); end
+  def render_segment(context, segment); end
+  def set_attribute(key, expr); end
+  def strict_parse(markup); end
+  def unknown_tag(tag, markup, tokens); end
+  def variable_name; end
+end
+class Liquid::For::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::If < Liquid::Block
+  def blocks; end
+  def initialize(tag_name, markup, options); end
+  def lax_parse(markup); end
+  def nodelist; end
+  def parse(tokens); end
+  def parse_binary_comparisons(p); end
+  def parse_comparison(p); end
+  def push_block(tag, markup); end
+  def render(context); end
+  def strict_parse(markup); end
+  def unknown_tag(tag, markup, tokens); end
+end
+class Liquid::If::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Ifchanged < Liquid::Block
+  def render(context); end
+end
+class Liquid::Include < Liquid::Tag
+  def attributes; end
+  def initialize(tag_name, markup, options); end
+  def load_cached_partial(template_name, context); end
+  def parse(_tokens); end
+  def parse_context; end
+  def read_template_from_file_system(context); end
+  def render(context); end
+  def template_name_expr; end
+  def variable_name_expr; end
+end
+class Liquid::Include::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Increment < Liquid::Tag
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+end
+class Liquid::Raw < Liquid::Block
+  def blank?; end
+  def ensure_valid_markup(tag_name, markup, parse_context); end
+  def initialize(tag_name, markup, parse_context); end
+  def nodelist; end
+  def parse(tokens); end
+  def render(_context); end
+end
+class Liquid::TableRow < Liquid::Block
+  def attributes; end
+  def collection_name; end
+  def initialize(tag_name, markup, options); end
+  def render(context); end
+  def variable_name; end
+end
+class Liquid::TableRow::ParseTreeVisitor < Liquid::ParseTreeVisitor
+  def children; end
+end
+class Liquid::Unless < Liquid::If
+  def render(context); end
+end