lsegal / yard / 947

pending completion

Build # 947

Build Type

Pull #1166

travis-ci

Committed by

web-flow

Commit Message

Deprecate safe_level of ERB.new in Ruby 2.6

The interface of `ERB.new` will change from Ruby 2.6.

> Add :trim_mode and :eoutvar keyword arguments to ERB.new.
> Now non-keyword arguments other than first one are softly deprecated
> and will be removed when Ruby 2.5 becomes EOL. [Feature #14256]

https://github.com/ruby/ruby/blob/2311087b6/NEWS#stdlib-updates-outstanding-ones-only

Pull Request Pull Request #1166: Deprecate safe_level of ERB.new in Ruby 2.6

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

17169 of 18364 relevant lines covered (93.49%)

1568.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.33

/lib/yard/templates/template.rb

# frozen_string_literal: true
require 'erb'

module YARD
  module Templates
    module Template
      attr_accessor :class, :section
      attr_reader :options

      class << self
        # Extra includes are mixins that are included after a template is created. These
        # mixins can be registered by plugins to operate on templates and override behaviour.
        #
        # Note that this array can be filled with modules or proc objects. If a proc object
        # is given, the proc will be called with the {Template#options} hash containing
        # relevant template information like the object, format, and more. The proc should
        # return a module or nil if there is none.
        #
        # @example Adding in extra mixins to include on a template
        #   Template.extra_includes << MyHelper
        # @example Conditionally including a mixin if the format is html
        #   Template.extra_includes << proc {|opts| MyHelper if opts.format == :html }
        # @return [Array<Module, Proc>] a list of modules to be automatically included
        #   into any new template module
        attr_accessor :extra_includes

        # @!parse extend ClassMethods
        # @private
        def included(klass)
          klass.extend(ClassMethods)
        end

        # Includes the {extra_includes} modules into the template object.
        #
        # @param [Template] template the template object to mixin the extra includes.
        # @param [SymbolHash] options the options hash containing all template information
        # @return [void]
        def include_extra(template, options)
          extra_includes.each do |mod|
            mod = mod.call(options) if mod.is_a?(Proc)
            next unless mod.is_a?(Module)
            template.extend(mod)
          end
        end
      end

      self.extra_includes = [
        proc do |options|
          {:html => Helpers::HtmlHelper,
            :text => Helpers::TextHelper,
            :dot  => Helpers::UMLHelper}[options.format]
        end
      ]

      include ErbCache
      include Helpers::BaseHelper
      include Helpers::MethodHelper

      module ClassMethods
        attr_accessor :path, :full_path

        # @return [Array<String>] a list of full paths
        # @note This method caches path results. Paths should not be modified
        #   after this method is called; call {#reset_full_paths} to reset cache.
        def full_paths
          reset_full_paths unless defined? @cached_included_modules
          return @full_paths if included_modules == @cached_included_modules

          @cached_included_modules = included_modules
          @full_paths = included_modules.inject([full_path]) do |paths, mod|
            paths |= mod.full_paths if mod.respond_to?(:full_paths)
            paths
          end
        end

        # Resets cache for {#full_paths}
        def reset_full_paths
          @cached_included_modules = nil
        end

        def initialize(path, full_paths)
          full_path = full_paths.shift
          self.path = path
          self.full_path = full_path
          include_inherited(full_paths)
          include_parent
          load_setup_rb
        end

        # Searches for a file identified by +basename+ in the template's
        # path as well as any mixed in template paths. Equivalent to calling
        # {ClassMethods#find_nth_file} with index of 1.
        #
        # @param [String] basename the filename to search for
        # @return [String] the full path of a file on disk with filename
        #   +basename+ in one of the template's paths.
        # @see find_nth_file
        def find_file(basename)
          find_nth_file(basename)
        end

        # Searches for the nth file (where n = +index+) identified
        # by basename in the template's path and any mixed in template paths.
        #
        # @param [String] basename the filename to search for
        # @param [Fixnum] index the nth existing file to return
        # @return [String] the full path of the nth file on disk with
        #   filename +basename+ in one of the template paths
        def find_nth_file(basename, index = 1)
          n = 1
          full_paths.each do |path|
            file = File.join(path, basename)
            if File.file?(file)
              return file if index == n
              n += 1
            end
          end

          nil
        end

        def is_a?(klass)
          return true if klass == Template
          super(klass)
        end

        # Creates a new template object to be rendered with {Template#run}
        def new(*args)
          obj = Object.new.extend(self)
          obj.class = self
          obj.send(:initialize, *args)
          obj
        end

        def run(*args)
          new(*args).run
        end

        # rubocop:disable Style/MethodName

        # Alias for creating {Engine.template}.
        def T(*path)
          Engine.template(*path)
        end

        # Alias for creating a {Section} with arguments
        # @see Section#initialize
        # @since 0.6.0
        def S(*args)
          Section.new(*args)
        end

        # rubocop:enable Style/MethodName

        private

        def include_parent
          pc = path.to_s.split('/')
          if pc.size > 1
            pc.pop
            pc = pc.join('/')
            begin
              include Engine.template(pc)
            rescue ArgumentError
              include Engine.template!(pc, full_path.gsub(%r{/[^/]+$}, ''))
            end
          end
        end

        def include_inherited(full_paths)
          full_paths.reverse.each do |full_path|
            include Engine.template!(path, full_path)
          end
        end

        def load_setup_rb
          setup_file = File.join(full_path, 'setup.rb')
          if File.file? setup_file
            module_eval(File.read(setup_file).taint, setup_file, 1)
          end
        end
      end

      def initialize(opts = TemplateOptions.new)
        opts_class = opts.class
        opts_class = TemplateOptions if opts_class == Hash
        @cache = {}
        @cache_filename = {}
        @sections = []
        @options = opts_class.new
        add_options(opts)
        Template.include_extra(self, options)
        init
      end

      # Loads a template specified by path. If +:template+ or +:format+ is
      # specified in the {#options} hash, they are prepended and appended
      # to the path respectively.
      #
      # @param [Array<String, Symbol>] path the path of the template
      # @return [Template] the loaded template module
      def T(*path) # rubocop:disable Style/MethodName
        path.unshift(options.template) if options.template
        path.push(options.format) if options.format
        self.class.T(*path)
      end

      # Sets the sections (and subsections) to be rendered for the template
      #
      # @example Sets a set of erb sections
      #   sections :a, :b, :c # searches for a.erb, b.erb, c.erb
      # @example Sets a set of method and erb sections
      #   sections :a, :b, :c # a is a method, the rest are erb files
      # @example Sections with subsections
      #   sections :header, [:name, :children]
      #   # the above will call header.erb and only renders the subsections
      #   # if they are yielded by the template (see #yieldall)
      # @param [Array<Symbol, String, Template, Array>] args the sections
      #   to use to render the template. For symbols and strings, the
      #   section will be executed as a method (if one exists), or rendered
      #   from the file "name.erb" where name is the section name. For
      #   templates, they will have {Template::ClassMethods#run} called on them.
      #   Any subsections can be yielded to using yield or {#yieldall}
      def sections(*args)
        @sections = Section.new(nil, *args) unless args.empty?
        @sections
      end

      # Initialization called on the template. Override this in a 'setup.rb'
      # file in the template's path to implement a template
      #
      # @example A default set of sections
      #   def init
      #     sections :section1, :section2, [:subsection1, :etc]
      #   end
      # @see #sections
      def init
      end

      # Runs a template on +sects+ using extra options. This method should
      # not be called directly. Instead, call the class method {ClassMethods#run}
      #
      # @param [Hash, nil] opts any extra options to apply to sections
      # @param [Section, Array] sects a section list of sections to render
      # @param [Fixnum] start_at the index in the section list to start from
      # @param [Boolean] break_first if true, renders only the first section
      # @yield [opts] calls for the subsections to be rendered
      # @yieldparam [Hash] opts any extra options to yield
      # @return [String] the rendered sections joined together
      def run(opts = nil, sects = sections, start_at = 0, break_first = false, &block)
        out = String.new("")
        return out if sects.nil?
        sects = sects[start_at..-1] if start_at > 0
        sects = Section.new(nil, sects) unless sects.is_a?(Section)
        add_options(opts) do
          sects.each do |s|
            self.section = s
            subsection_index = 0
            value = render_section(section) do |*args|
              value = with_section do
                run(args.first, section, subsection_index, true, &block)
              end
              subsection_index += 1
              value
            end
            out << (value || "")
            break if break_first
          end
        end
        out
      end

      # Yields all subsections with any extra options
      #
      # @param [Hash] opts extra options to be applied to subsections
      def yieldall(opts = nil, &block)
        with_section { run(opts, section, &block) }
      end

      # @param [String, Symbol] section the section name
      # @yield calls subsections to be rendered
      # @return [String] the contents of the ERB rendered section
      def erb(section, &block)
        method_name = ErbCache.method_for(cache_filename(section)) do
          erb_with(cache(section), cache_filename(section))
        end
        send(method_name, &block)
      end

      # Returns the contents of a file. If +allow_inherited+ is set to +true+,
      # use +{{{__super__}}}+ inside the file contents to insert the contents
      # of the file from an inherited template. For instance, if +templates/b+
      # inherits from +templates/a+ and file "test.css" exists in both directories,
      # both file contents can be retrieved by having +templates/b/test.css+ look
      # like:
      #
      #   {{{__super__}}}
      #   ...
      #   body { css styles here }
      #   p.class { other styles }
      #
      # @param [String] basename the name of the file
      # @param [Boolean] allow_inherited whether inherited templates can
      #   be inserted with +{{{__super__}}}+
      # @return [String] the contents of a file identified by +basename+. All
      #   template paths (including any mixed in templates) are searched for
      #   the file
      # @see ClassMethods#find_file
      # @see ClassMethods#find_nth_file
      def file(basename, allow_inherited = false)
        file = self.class.find_file(basename)
        raise ArgumentError, "no file for '#{basename}' in #{self.class.path}" unless file

        data = IO.read(file)
        if allow_inherited
          superfile = self.class.find_nth_file(basename, 2)
          data.gsub!('{{{__super__}}}', superfile ? IO.read(superfile) : "")
        end

        data
      end

      # Calls the ERB file from the last inherited template with {#section}.erb
      #
      # @param [Symbol, String] sect if provided, uses a specific section name
      # @return [String] the rendered ERB file in any of the inherited template
      #   paths.
      def superb(sect = section, &block)
        filename = self.class.find_nth_file(erb_file_for(sect), 2)
        return "" unless filename
        method_name = ErbCache.method_for(filename) { erb_with(IO.read(filename), filename) }
        send(method_name, &block)
      end

      def options=(value)
        @options = value
        set_ivars
      end

      def inspect
        "Template(#{self.class.path}) [section=#{section.name}]"
      end

      protected

      def erb_file_for(section)
        "#{section}.erb"
      end

      def erb_with(content, filename = nil)
        erb = if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
                ERB.new(content, :trim_mode => options.format == :text ? '<>' : nil)
              else
                ERB.new(content, nil, options.format == :text ? '<>' : nil)
              end
        erb.filename = filename if filename
        erb
      end

      private

      def render_section(section, &block)
        section = section.name if section.is_a?(Section)
        case section
        when Section, String, Symbol
          if respond_to?(section)
            send(section, &block)
          else
            erb(section, &block)
          end
        when Module, Template
          section.run(options, &block) if section.is_a?(Template)
        end || ""
      end

      def cache(section)
        content = @cache[section.to_sym]
        return content if content

        file = cache_filename(section)
        @cache_filename[section.to_sym] = file
        raise ArgumentError, "no template for section '#{section}' in #{self.class.path}" unless file
        @cache[section.to_sym] = IO.read(file)
      end

      def cache_filename(section)
        @cache_filename[section.to_sym] ||=
          self.class.find_file(erb_file_for(section))
      end

      def set_ivars
        options.each do |k, v|
          instance_variable_set("@#{k}", v)
        end
      end

      def add_options(opts = nil)
        return(yield) if opts.nil? && block_given?
        cur_opts = options if block_given?

        self.options = options.merge(opts)

        if block_given?
          value = yield
          self.options = cur_opts
          value
        end
      end

      def with_section
        sect = section
        value = yield
        self.section = sect
        value
      end
    end
  end
end

1	# frozen_string_literal: true
2	require 'erb'	4✔
3
4	module YARD	4✔
5	module Templates	4✔
6	module Template	4✔
7	attr_accessor :class, :section	4✔
8	attr_reader :options	4✔
9
10	class << self	4✔
11	# Extra includes are mixins that are included after a template is created. These
12	# mixins can be registered by plugins to operate on templates and override behaviour.
13	#
14	# Note that this array can be filled with modules or proc objects. If a proc object
15	# is given, the proc will be called with the {Template#options} hash containing
16	# relevant template information like the object, format, and more. The proc should
17	# return a module or nil if there is none.
18	#
19	# @example Adding in extra mixins to include on a template
20	# Template.extra_includes << MyHelper
21	# @example Conditionally including a mixin if the format is html
22	# Template.extra_includes << proc {\|opts\| MyHelper if opts.format == :html }
23	# @return [Array<Module, Proc>] a list of modules to be automatically included
24	# into any new template module
25	attr_accessor :extra_includes	4✔
26
27	# @!parse extend ClassMethods
28	# @private
29	def included(klass)	4✔
30	klass.extend(ClassMethods)	268✔
31	end
32
33	# Includes the {extra_includes} modules into the template object.
34	#
35	# @param [Template] template the template object to mixin the extra includes.
36	# @param [SymbolHash] options the options hash containing all template information
37	# @return [void]
38	def include_extra(template, options)	4✔
39	extra_includes.each do \|mod\|	1,076✔
40	mod = mod.call(options) if mod.is_a?(Proc)	1,340✔
41	next unless mod.is_a?(Module)	1,340✔
42	template.extend(mod)	1,088✔
43	end
44	end
45	end
46
47	self.extra_includes = [	4✔
48	proc do \|options\|
49	{:html => Helpers::HtmlHelper,	269 only 2.5.0, CI=1 ✔
50	:text => Helpers::TextHelper,
51	:dot => Helpers::UMLHelper}[options.format]	807 all except 2.5.0, CI=1 ✔
52	end
53	]
54
55	include ErbCache	4✔
56	include Helpers::BaseHelper	4✔
57	include Helpers::MethodHelper	4✔
58
59	module ClassMethods	4✔
60	attr_accessor :path, :full_path	4✔
61
62	# @return [Array<String>] a list of full paths
63	# @note This method caches path results. Paths should not be modified
64	# after this method is called; call {#reset_full_paths} to reset cache.
65	def full_paths	4✔
66	reset_full_paths unless defined? @cached_included_modules	3,960✔
67	return @full_paths if included_modules == @cached_included_modules	3,960✔
68
69	@cached_included_modules = included_modules	192✔
70	@full_paths = included_modules.inject([full_path]) do \|paths, mod\|	192✔
71	paths \|= mod.full_paths if mod.respond_to?(:full_paths)	1,208✔
72	paths	1,208✔
73	end
74	end
75
76	# Resets cache for {#full_paths}
77	def reset_full_paths	4✔
78	@cached_included_modules = nil	184✔
79	end
80
81	def initialize(path, full_paths)	4✔
82	full_path = full_paths.shift	268✔
83	self.path = path	268✔
84	self.full_path = full_path	268✔
85	include_inherited(full_paths)	268✔
86	include_parent	268✔
87	load_setup_rb	268✔
88	end
89
90	# Searches for a file identified by +basename+ in the template's
91	# path as well as any mixed in template paths. Equivalent to calling
92	# {ClassMethods#find_nth_file} with index of 1.
93	#
94	# @param [String] basename the filename to search for
95	# @return [String] the full path of a file on disk with filename
96	# +basename+ in one of the template's paths.
97	# @see find_nth_file
98	def find_file(basename)	4✔
99	find_nth_file(basename)	3,508✔
100	end
101
102	# Searches for the nth file (where n = +index+) identified
103	# by basename in the template's path and any mixed in template paths.
104	#
105	# @param [String] basename the filename to search for
106	# @param [Fixnum] index the nth existing file to return
107	# @return [String] the full path of the nth file on disk with
108	# filename +basename+ in one of the template paths
109	def find_nth_file(basename, index = 1)	4✔
110	n = 1	3,560✔
111	full_paths.each do \|path\|	3,560✔
112	file = File.join(path, basename)	4,476✔
113	if File.file?(file)	4,476✔
114	return file if index == n	3,536✔
115	n += 1	24✔
116	end
117	end
118
119	nil
120	end
121
122	def is_a?(klass)	4✔
123	return true if klass == Template	1,304✔
124	super(klass)	544✔
125	end
126
127	# Creates a new template object to be rendered with {Template#run}
128	def new(*args)	4✔
129	obj = Object.new.extend(self)	1,076✔
130	obj.class = self	1,076✔
131	obj.send(:initialize, *args)	1,076✔
132	obj	1,076✔
133	end
134
135	def run(*args)	4✔
136	new(*args).run	940✔
137	end
138
139	# rubocop:disable Style/MethodName
140
141	# Alias for creating {Engine.template}.
142	def T(*path)	4✔
143	Engine.template(*path)	1,228✔
144	end
145
146	# Alias for creating a {Section} with arguments
147	# @see Section#initialize
148	# @since 0.6.0
149	def S(*args)	4✔
150	Section.new(*args)	×
151	end
152
153	# rubocop:enable Style/MethodName
154
155	private	4✔
156
157	def include_parent	4✔
158	pc = path.to_s.split('/')	268✔
159	if pc.size > 1	268✔
160	pc.pop	184✔
161	pc = pc.join('/')	184✔
162	begin	184✔
163	include Engine.template(pc)	184✔
164	rescue ArgumentError	28✔
165	include Engine.template!(pc, full_path.gsub(%r{/[^/]+$}, ''))	28✔
166	end
167	end
168	end
169
170	def include_inherited(full_paths)	4✔
171	full_paths.reverse.each do \|full_path\|	268✔
172	include Engine.template!(path, full_path)	28✔
173	end
174	end
175
176	def load_setup_rb	4✔
177	setup_file = File.join(full_path, 'setup.rb')	268✔
178	if File.file? setup_file	268✔
179	module_eval(File.read(setup_file).taint, setup_file, 1)	88✔
180	end
181	end
182	end
183
184	def initialize(opts = TemplateOptions.new)	4✔
185	opts_class = opts.class	1,076✔
186	opts_class = TemplateOptions if opts_class == Hash	1,076✔
187	@cache = {}	1,076✔
188	@cache_filename = {}	1,076✔
189	@sections = []	1,076✔
190	@options = opts_class.new	1,076✔
191	add_options(opts)	1,076✔
192	Template.include_extra(self, options)	1,076✔
193	init	1,076✔
194	end
195
196	# Loads a template specified by path. If +:template+ or +:format+ is
197	# specified in the {#options} hash, they are prepended and appended
198	# to the path respectively.
199	#
200	# @param [Array<String, Symbol>] path the path of the template
201	# @return [Template] the loaded template module
202	def T(*path) # rubocop:disable Style/MethodName	4✔
203	path.unshift(options.template) if options.template	1,196✔
204	path.push(options.format) if options.format	1,196✔
205	self.class.T(*path)	1,196✔
206	end
207
208	# Sets the sections (and subsections) to be rendered for the template
209	#
210	# @example Sets a set of erb sections
211	# sections :a, :b, :c # searches for a.erb, b.erb, c.erb
212	# @example Sets a set of method and erb sections
213	# sections :a, :b, :c # a is a method, the rest are erb files
214	# @example Sections with subsections
215	# sections :header, [:name, :children]
216	# # the above will call header.erb and only renders the subsections
217	# # if they are yielded by the template (see #yieldall)
218	# @param [Array<Symbol, String, Template, Array>] args the sections
219	# to use to render the template. For symbols and strings, the
220	# section will be executed as a method (if one exists), or rendered
221	# from the file "name.erb" where name is the section name. For
222	# templates, they will have {Template::ClassMethods#run} called on them.
223	# Any subsections can be yielded to using yield or {#yieldall}
224	def sections(*args)	4✔
225	@sections = Section.new(nil, *args) unless args.empty?	2,380✔
226	@sections	2,380✔
227	end
228
229	# Initialization called on the template. Override this in a 'setup.rb'
230	# file in the template's path to implement a template
231	#
232	# @example A default set of sections
233	# def init
234	# sections :section1, :section2, [:subsection1, :etc]
235	# end
236	# @see #sections
237	def init	4✔
238	end
239
240	# Runs a template on +sects+ using extra options. This method should
241	# not be called directly. Instead, call the class method {ClassMethods#run}
242	#
243	# @param [Hash, nil] opts any extra options to apply to sections
244	# @param [Section, Array] sects a section list of sections to render
245	# @param [Fixnum] start_at the index in the section list to start from
246	# @param [Boolean] break_first if true, renders only the first section
247	# @yield [opts] calls for the subsections to be rendered
248	# @yieldparam [Hash] opts any extra options to yield
249	# @return [String] the rendered sections joined together
250	def run(opts = nil, sects = sections, start_at = 0, break_first = false, &block)	4✔
251	out = String.new("")	2,176✔
252	return out if sects.nil?	2,176✔
253	sects = sects[start_at..-1] if start_at > 0	2,176✔
254	sects = Section.new(nil, sects) unless sects.is_a?(Section)	2,176✔
255	add_options(opts) do	2,176✔
256	sects.each do \|s\|	2,176✔
257	self.section = s	8,320✔
258	subsection_index = 0	8,320✔
259	value = render_section(section) do \|*args\|	8,320✔
260	value = with_section do	48✔
261	run(args.first, section, subsection_index, true, &block)	48✔
262	end
263	subsection_index += 1	48✔
264	value	48✔
265	end
266	out << (value \|\| "")	8,320✔
267	break if break_first	8,320✔
268	end
269	end
270	out	2,176✔
271	end
272
273	# Yields all subsections with any extra options
274	#
275	# @param [Hash] opts extra options to be applied to subsections
276	def yieldall(opts = nil, &block)	4✔
277	with_section { run(opts, section, &block) }	2,232✔
278	end
279
280	# @param [String, Symbol] section the section name
281	# @yield calls subsections to be rendered
282	# @return [String] the contents of the ERB rendered section
283	def erb(section, &block)	4✔
284	method_name = ErbCache.method_for(cache_filename(section)) do	3,580✔
285	erb_with(cache(section), cache_filename(section))	304✔
286	end
287	send(method_name, &block)	3,580✔
288	end
289
290	# Returns the contents of a file. If +allow_inherited+ is set to +true+,
291	# use +{{{__super__}}}+ inside the file contents to insert the contents
292	# of the file from an inherited template. For instance, if +templates/b+
293	# inherits from +templates/a+ and file "test.css" exists in both directories,
294	# both file contents can be retrieved by having +templates/b/test.css+ look
295	# like:
296	#
297	# {{{__super__}}}
298	# ...
299	# body { css styles here }
300	# p.class { other styles }
301	#
302	# @param [String] basename the name of the file
303	# @param [Boolean] allow_inherited whether inherited templates can
304	# be inserted with +{{{__super__}}}+
305	# @return [String] the contents of a file identified by +basename+. All
306	# template paths (including any mixed in templates) are searched for
307	# the file
308	# @see ClassMethods#find_file
309	# @see ClassMethods#find_nth_file
310	def file(basename, allow_inherited = false)	4✔
311	file = self.class.find_file(basename)	16✔
312	raise ArgumentError, "no file for '#{basename}' in #{self.class.path}" unless file	16✔
313
314	data = IO.read(file)	12✔
315	if allow_inherited	12✔
316	superfile = self.class.find_nth_file(basename, 2)	4✔
317	data.gsub!('{{{__super__}}}', superfile ? IO.read(superfile) : "")	4✔
318	end
319
320	data	12✔
321	end
322
323	# Calls the ERB file from the last inherited template with {#section}.erb
324	#
325	# @param [Symbol, String] sect if provided, uses a specific section name
326	# @return [String] the rendered ERB file in any of the inherited template
327	# paths.
328	def superb(sect = section, &block)	4✔
329	filename = self.class.find_nth_file(erb_file_for(sect), 2)	8✔
330	return "" unless filename	8✔
331	method_name = ErbCache.method_for(filename) { erb_with(IO.read(filename), filename) }	16✔
332	send(method_name, &block)	8✔
333	end
334
335	def options=(value)	4✔
336	@options = value	1,800✔
337	set_ivars	1,800✔
338	end
339
340	def inspect	4✔
341	"Template(#{self.class.path}) [section=#{section.name}]"	×
342	end
343
344	protected	4✔
345
346	def erb_file_for(section)	4✔
347	"#{section}.erb"	3,448✔
348	end
349
350	def erb_with(content, filename = nil)	4✔
351	erb = if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+	312✔
352	ERB.new(content, :trim_mode => options.format == :text ? '<>' : nil)	×
353	else
354	ERB.new(content, nil, options.format == :text ? '<>' : nil)	312✔
355	end
356	erb.filename = filename if filename	312✔
357	erb	312✔
358	end
359
360	private	4✔
361
362	def render_section(section, &block)	4✔
363	section = section.name if section.is_a?(Section)	8,292✔
364	case section
365	when Section, String, Symbol
366	if respond_to?(section)	7,532✔
367	send(section, &block)	4,464✔
368	else
369	erb(section, &block)	3,068✔
370	end
371	when Module, Template
372	section.run(options, &block) if section.is_a?(Template)	760✔
373	end \|\| ""	8,292✔
374	end
375
376	def cache(section)	4✔
377	content = @cache[section.to_sym]	304✔
378	return content if content	304✔
379
380	file = cache_filename(section)	304✔
381	@cache_filename[section.to_sym] = file	304✔
382	raise ArgumentError, "no template for section '#{section}' in #{self.class.path}" unless file	304✔
383	@cache[section.to_sym] = IO.read(file)	304✔
384	end
385
386	def cache_filename(section)	4✔
387	@cache_filename[section.to_sym] \|\|=	4,188✔
388	self.class.find_file(erb_file_for(section))
389	end
390
391	def set_ivars	4✔
392	options.each do \|k, v\|	1,800✔
393	instance_variable_set("@#{k}", v)	20,268✔
394	end
395	end
396
397	def add_options(opts = nil)	4✔
398	return(yield) if opts.nil? && block_given?	3,256✔
399	cur_opts = options if block_given?	1,440✔
400
401	self.options = options.merge(opts)	1,440✔
402
403	if block_given?	1,440✔
404	value = yield	360✔
405	self.options = cur_opts	360✔
406	value	360✔
407	end
408	end
409
410	def with_section	4✔
411	sect = section	1,164✔
412	value = yield	1,164✔
413	self.section = sect	1,164✔
414	value	1,164✔
415	end
416	end
417	end
418	end

lsegal / yard / 947

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous