zine_brewer 1.3.0 → 1.6.1

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/settings.rb

@@ -1,249 +0,0 @@
-# Settings which can be configured for all view classes, a single
-# view class, or a single Mustache instance.
-class Mustache
-
-  def initialize_settings
-    @template = nil
-    @template_path = nil
-    @template_extension = nil
-    @template_name = nil
-    @template_file = nil
-    @raise_on_context_miss = nil
-  end
-
-  def self.initialize_settings
-    @template = nil
-    @template_path = nil
-    @template_extension = nil
-    @template_name = nil
-    @template_file = nil
-    @raise_on_context_miss = nil
-  end
-
-  initialize_settings
-
-  def self.inherited(subclass)
-    subclass.initialize_settings
-  end
-
-  #
-  # Template Path
-  #
-
-  # The template path informs your Mustache view where to look for its
-  # corresponding template. By default it's the current directory (".")
-  #
-  # A class named Stat with a template_path of "app/templates" will look
-  # for "app/templates/stat.mustache"
-
-  def self.template_path
-    @template_path ||= inheritable_config_for :template_path, '.'
-  end
-
-  def self.template_path=(path)
-    @template_path = File.expand_path(path)
-    @template = nil
-  end
-
-  def template_path
-    @template_path ||= self.class.template_path
-  end
-  alias_method :path, :template_path
-
-  def template_path=(path)
-    @template_path = File.expand_path(path)
-    @template = nil
-  end
-
-  # Alias for `template_path`
-  def self.path
-    template_path
-  end
-
-  # Alias for `template_path`
-  def self.path=(path)
-    self.template_path = path
-  end
-
-
-  #
-  # Template Extension
-  #
-
-  # A Mustache template's default extension is 'mustache', but this can be changed.
-
-  def self.template_extension
-    @template_extension ||= inheritable_config_for :template_extension, 'mustache'
-  end
-
-  def self.template_extension=(template_extension)
-    @template_extension = template_extension
-    @template = nil
-  end
-
-  def template_extension
-    @template_extension ||= self.class.template_extension
-  end
-
-  def template_extension=(template_extension)
-    @template_extension = template_extension
-    @template = nil
-  end
-
-
-  #
-  # Template Name
-  #
-
-  # The template name is the Mustache template file without any
-  # extension or other information. Defaults to `class_name`.
-  #
-  # You may want to change this if your class is named Stat but you want
-  # to re-use another template.
-  #
-  #   class Stat
-  #     self.template_name = "graphs" # use graphs.mustache
-  #   end
-
-  def self.template_name
-    @template_name || underscore
-  end
-
-  def self.template_name=(template_name)
-    @template_name = template_name
-    @template = nil
-  end
-
-  def template_name
-    @template_name ||= self.class.template_name
-  end
-
-  def template_name=(template_name)
-    @template_name = template_name
-    @template = nil
-  end
-
-
-  #
-  # Template File
-  #
-
-  # The template file is the absolute path of the file Mustache will
-  # use as its template. By default it's ./class_name.mustache
-
-  def self.template_file
-    @template_file || "#{path}/#{template_name}.#{template_extension}"
-  end
-
-  def self.template_file=(template_file)
-    @template_file = template_file
-    @template = nil
-  end
-
-  # The template file is the absolute path of the file Mustache will
-  # use as its template. By default it's ./class_name.mustache
-  def template_file
-    @template_file || "#{path}/#{template_name}.#{template_extension}"
-  end
-
-  def template_file=(template_file)
-    @template_file = template_file
-    @template = nil
-  end
-
-
-  #
-  # Template
-  #
-
-  # The template is the actual string Mustache uses as its template.
-  # There is a bit of magic here: what we get back is actually a
-  # Mustache::Template object, but you can still safely use `template=`
-  #  with a string.
-
-  def self.template
-    @template ||= templateify(File.read(template_file))
-  end
-
-  def self.template=(template)
-    @template = templateify(template)
-  end
-
-  # The template can be set at the instance level.
-  def template
-    return @template if @template
-
-    # If they sent any instance-level options use that instead of the class's.
-    if @template_path || @template_extension || @template_name || @template_file
-      @template = templateify(File.read(template_file))
-    else
-      @template = self.class.template
-    end
-  end
-
-  def template=(template)
-    @template = templateify(template)
-  end
-
-
-  #
-  # Raise on context miss
-  #
-
-  # Should an exception be raised when we cannot find a corresponding method
-  # or key in the current context? By default this is false to emulate ctemplate's
-  # behavior, but it may be useful to enable when debugging or developing.
-  #
-  # If set to true and there is a context miss, `Mustache::ContextMiss` will
-  # be raised.
-
-  def self.raise_on_context_miss?
-    @raise_on_context_miss
-  end
-
-  def self.raise_on_context_miss=(boolean)
-    @raise_on_context_miss = boolean
-  end
-
-  # Instance level version of `Mustache.raise_on_context_miss?`
-  def raise_on_context_miss?
-    self.class.raise_on_context_miss? || @raise_on_context_miss
-  end
-
-  def raise_on_context_miss=(boolean)
-    @raise_on_context_miss = boolean
-  end
-
-
-  #
-  # View Namespace
-  #
-
-  # The constant under which Mustache will look for views when autoloading.
-  # By default the view namespace is `Object`, but it might be nice to set
-  # it to something like `Hurl::Views` if your app's main namespace is `Hurl`.
-
-  def self.view_namespace
-    @view_namespace ||= inheritable_config_for(:view_namespace, Object)
-  end
-
-  def self.view_namespace=(namespace)
-    @view_namespace = namespace
-  end
-
-
-  #
-  # View Path
-  #
-
-  # Mustache searches the view path for .rb files to require when asked to find a
-  # view class. Defaults to "."
-
-  def self.view_path
-    @view_path ||= inheritable_config_for(:view_path, '.')
-  end
-
-  def self.view_path=(path)
-    @view_path = path
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/template.rb

@@ -1,128 +0,0 @@
-require 'cgi'
-
-require 'mustache/parser'
-require 'mustache/generator'
-
-class Mustache
-  # A Template represents a Mustache template. It compiles and caches
-  # a raw string template into something usable.
-  #
-  # The idea is this: when handed a Mustache template, convert it into
-  # a Ruby string by transforming Mustache tags into interpolated
-  # Ruby.
-  #
-  # You shouldn't use this class directly, instead:
-  #
-  # >> Mustache.render(template, hash)
-  class Template
-    attr_reader :source
-
-    # Expects a Mustache template as a string along with a template
-    # path, which it uses to find partials. Options may be passed.
-    def initialize(source, options = {})
-      @source = source
-      @options = options
-    end
-
-    # Renders the `@source` Mustache template using the given
-    # `context`, which should be a simple hash keyed with symbols.
-    #
-    # The first time a template is rendered, this method is overriden
-    # and from then on it is "compiled". Subsequent calls will skip
-    # the compilation step and run the Ruby version of the template
-    # directly.
-    def render(context)
-      # Compile our Mustache template into a Ruby string
-      compiled = "def render(ctx) #{compile} end"
-
-      # Here we rewrite ourself with the interpolated Ruby version of
-      # our Mustache template so subsequent calls are very fast and
-      # can skip the compilation stage.
-      instance_eval(compiled, __FILE__, __LINE__ - 1)
-
-      # Call the newly rewritten version of #render
-      render(context)
-    end
-
-    # Does the dirty work of transforming a Mustache template into an
-    # interpolation-friendly Ruby string.
-    def compile(src = @source)
-      Generator.new(@options).compile(tokens(src))
-    end
-    alias_method :to_s, :compile
-
-    # Returns an array of tokens for a given template.
-    #
-    # @return [Array] Array of tokens.
-    #
-    def tokens(src = @source)
-      Parser.new(@options).compile(src)
-    end
-
-    # Returns an array of tags.
-    #
-    # Tags that belong to sections will be of the form `section1.tag`.
-    #
-    # @return [Array] Returns an array of tags.
-    #
-    def tags
-      Template.recursor(tokens, []) do |token, section|
-        if [:etag, :utag].include?(token[1])
-          [ new_token=nil, new_section=nil, result=((section + [token[2][2][0]]).join('.')), stop=true ]
-        elsif [:section, :inverted_section].include?(token[1])
-          [ new_token=token[4], new_section=(section + [token[2][2][0]]), result=nil, stop=false ]
-        else
-          [ new_token=token, new_section=section, result=nil, stop=false ]
-        end
-      end.flatten.reject(&:nil?).uniq
-    end
-
-    # Returns an array of sections.
-    #
-    # Sections that belong to other sections will be of the form `section1.childsection`
-    #
-    # @return [Array] Returns an array of section.
-    #
-    def sections
-      Template.recursor(tokens, []) do |token, section|
-        if [:section, :inverted_section].include?(token[1])
-          new_section=(section + [token[2][2][0]])
-          [ new_token=token[4], new_section, result=new_section.join('.'), stop=false ]
-        else
-          [ new_token=token, new_section=section, result=nil, stop=false ]
-        end
-      end.flatten.reject(&:nil?).uniq
-    end
-
-    # Returns an array of partials.
-    #
-    # Partials that belong to sections are included, but the section name is not preserved
-    #
-    # @return [Array] Returns an array of partials.
-    #
-    def partials
-      Template.recursor(tokens, []) do |token, section|
-        if token[1] == :partial
-          [ new_token=token, new_section=section, result=token[2], stop=true ]
-        else
-          [ new_token=token, new_section=section, result=nil, stop=false ]
-        end
-      end.flatten.reject(&:nil?).uniq
-    end
-
-
-    # Simple recursive iterator for tokens
-    def self.recursor(toks, section, &block)
-      toks.map do |token|
-        next unless token.is_a? Array
-
-        if token.first == :mustache
-          new_token, new_section, result, stop = yield(token, section)
-          [ result ] + ( stop ? [] : recursor(new_token, new_section, &block))
-        else
-          recursor(token, section, &block)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/utils.rb

@@ -1,31 +0,0 @@
-class Mustache
-  module Utils
-    class String
-      def initialize string
-        @string = string
-      end
-
-      def classify
-        @string.split('/').map do |namespace|
-          namespace.split(/[-_]/).map do |part|
-            part[0] = part.chars.first.upcase
-            part
-          end.join
-        end.join('::')
-      end
-
-      def underscore(view_namespace)
-        @string
-          .dup
-          .split("#{view_namespace}::")
-          .last
-          .split('::')
-          .map do |part|
-            part[0] = part[0].downcase
-            part.gsub(/[A-Z]/) { |s| "_" << s.downcase }
-          end
-          .join('/')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/version.rb

@@ -1,3 +0,0 @@
-class Mustache
-  VERSION = '1.1.1'
-end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/man/mustache.1

@@ -1,165 +0,0 @@
-.\" generated with Ronn/v0.7.3
-.\" http://github.com/rtomayko/ronn/tree/0.7.3
-.
-.TH "MUSTACHE" "1" "November 2016" "DEFUNKT" "Mustache Manual"
-.
-.SH "NAME"
-\fBmustache\fR \- Mustache processor
-.
-.SH "SYNOPSIS"
-.
-.nf
-
-mustache <YAML> <FILE>
-mustache \-\-compile <FILE>
-mustache \-\-tokens <FILE>
-.
-.fi
-.
-.SH "DESCRIPTION"
-Mustache is a logic\-less templating system for HTML, config files, anything\.
-.
-.P
-The \fBmustache\fR command processes a Mustache template preceded by YAML frontmatter from standard input and prints one or more documents to standard output\.
-.
-.P
-YAML frontmatter begins with \fB\-\-\-\fR on a single line, followed by YAML, ending with another \fB\-\-\-\fR on a single line, e\.g\.
-.
-.IP "" 4
-.
-.nf
-
-\-\-\-
-names: [ {name: chris}, {name: mark}, {name: scott} ]
-\-\-\-
-.
-.fi
-.
-.IP "" 0
-.
-.P
-If you are unfamiliar with YAML, it is a superset of JSON\. Valid JSON should work fine\.
-.
-.P
-After the frontmatter should come any valid Mustache template\. See mustache(5) for an overview of Mustache templates\.
-.
-.P
-For example:
-.
-.IP "" 4
-.
-.nf
-
-{{#names}}
-  Hi {{name}}!
-{{/names}}
-.
-.fi
-.
-.IP "" 0
-.
-.P
-Now let\'s combine them\.
-.
-.IP "" 4
-.
-.nf
-
-$ cat data\.yml
-\-\-\-
-names: [ {name: chris}, {name: mark}, {name: scott} ]
-\-\-\-
-
-$ cat template\.mustache
-{{#names}}
-  Hi {{name}}!
-{{/names}}
-
-$ mustache data\.yml template\.mustache
-Hi chris!
-Hi mark!
-Hi scott!
-.
-.fi
-.
-.IP "" 0
-.
-.P
-If you provide multiple YAML documents (as delimited by \fB\-\-\-\fR), your template will be rendered multiple times\. Like a mail merge\.
-.
-.P
-For example:
-.
-.IP "" 4
-.
-.nf
-
-$ cat data\.yml
-\-\-\-
-name: chris
-\-\-\-
-name: mark
-\-\-\-
-name: scott
-\-\-\-
-
-$ cat template\.mustache
-Hi {{name}}!
-
-$ mustache data\.yml template\.mustache
-Hi chris!
-Hi mark!
-Hi scott!
-.
-.fi
-.
-.IP "" 0
-.
-.SH "OPTIONS"
-By default \fBmustache\fR will try to render a Mustache template using the YAML frontmatter you provide\. It can do a few other things, however\.
-.
-.TP
-\fB\-c\fR, \fB\-\-compile\fR
-Print the compiled Ruby version of a given template\. This is the code that is actually used when rendering a template into a string\. Useful for debugging but only if you are familiar with Mustache\'s internals\.
-.
-.TP
-\fB\-t\fR, \fB\-\-tokens\fR
-Print the tokenized form of a given Mustache template\. This can be used to understand how Mustache parses a template\. The tokens are handed to a generator which compiles them into a Ruby string\. Syntax errors and confused tags, therefore, can probably be identified by examining the tokens produced\.
-.
-.SH "INSTALLATION"
-If you have RubyGems installed:
-.
-.IP "" 4
-.
-.nf
-
-gem install mustache
-.
-.fi
-.
-.IP "" 0
-.
-.SH "EXAMPLES"
-.
-.nf
-
-$ mustache data\.yml template\.mustache
-$ cat data\.yml | mustache \- template\.mustache
-$ mustache \-c template\.mustache
-$ cat <<data | ruby mustache \- template\.mustache
-\-\-\-
-name: Bob
-age: 30
-\-\-\-
-data
-.
-.fi
-.
-.SH "COPYRIGHT"
-Mustache is Copyright (C) 2009 Chris Wanstrath
-.
-.P
-Original CTemplate by Google
-.
-.SH "SEE ALSO"
-mustache(5), gem(1), \fIhttp://mustache\.github\.io/\fR