1056078349

Build Type

push

github

Committed by Robert Haines

Commit Message

Raise `cff-version` to that which can be validated.

Run Details

144 of 164 branches covered (87.8%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

346 of 355 relevant lines covered (97.46%)

117.74 hits per line

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

97.53

/lib/cff/file.rb

# frozen_string_literal: true

# Copyright (c) 2018-2021 The Ruby Citation File Format Developers.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

##
module CFF

  # File provides direct access to a CFF Model, with the addition of some
  # filesystem utilities.
  class File

    # A comment to be inserted at the top of the resultant CFF file.
    attr_reader :comment

    # The filename of this CFF file.
    attr_reader :filename

    YAML_HEADER = "---\n" # :nodoc:
    CFF_COMMENT = [
      "This CITATION.cff file was created by ruby-cff (v #{CFF::VERSION}).",
      'Gem: https://rubygems.org/gems/cff',
      'CFF: https://citation-file-format.github.io/'
    ].freeze # :nodoc:

    # :call-seq:
    #   new(filename, title) -> File
    #   new(filename, model) -> File
    #
    # Create a new File. Either a pre-existing Model can be passed in or, as
    # with Model itself, a title can be supplied to initalize a new File.
    #
    # All methods provided by Model are also available directly on File
    # objects.
    def initialize(filename, param, comment = CFF_COMMENT, create: false)
      param = Model.new(param) unless param.is_a?(Model)

      @filename = filename
      @model = param
      @comment = comment
      @dirty = create
    end

    # :call-seq:
    #   read(file) -> File
    #
    # Read a file and parse it for subsequent manipulation.
    def self.read(file)
      content = ::File.read(file)
      comment = File.parse_comment(content)

      new(
        file, YAML.safe_load(content, permitted_classes: [Date, Time]), comment
      )
    end

    # :call-seq:
    #   open(file) -> File
    #   open(file) {|cff| block }
    #
    # With no associated block, File.open is a synonym for ::read. If the
    # optional code block is given, it will be passed the opened file as an
    # argument and the File object will automatically be written (if edited)
    # and closed when the block terminates.
    #
    # File.open will create a new file if one does not already exist with the
    # provided file name.
    def self.open(file)
      if ::File.exist?(file)
        content = ::File.read(file)
        comment = File.parse_comment(content)
        yaml = YAML.safe_load(content, permitted_classes: [Date, Time])
      else
        comment = CFF_COMMENT
        yaml = ''
      end

      cff = new(file, yaml, comment, create: (yaml == ''))
      return cff unless block_given?

      begin
        yield cff
      ensure
        cff.write
      end
    end

    # :call-seq:
    #   validate(file) -> Array
    #
    # Read a file and return an array with the result. The result array is a
    # two-element array, with `true`/`false` at index 0 to indicate pass/fail,
    # and an array of errors at index 1 (if any).
    def self.validate(file)
      File.read(file).validate
    end

    # :call-seq:
    #   validate!(file)
    #
    # Read a file and raise a ValidationError upon failure. If an error is
    # raised it will contain the detected validation failures for further
    # inspection.
    def self.validate!(file)
      File.read(file).validate!
    end

    # :call-seq:
    #   write(file, model)
    #   write(file, yaml)
    #
    # Write the supplied model or yaml string to `file`.
    def self.write(file, cff, comment = '')
      cff = cff.to_yaml unless cff.is_a?(String)
      content = File.format_comment(comment) + cff[YAML_HEADER.length...-1]

      ::File.write(file, content)
    end

    # :call-seq:
    #   write
    #
    # Write this CFF File.
    def write
      File.write(@filename, @model, @comment) if @dirty
      @dirty = false
    end

    # :call-seq:
    #   comment = string or array
    #
    # A comment to be inserted at the top of the resultant CFF file. This can
    # be supplied as a simple string or an array of strings. When the file is
    # saved this comment is formatted as follows:
    #
    # * a simple string is split into 75 character lines and `'# '` is prepended
    # to each line;
    # * an array of strings is joined into a single string with `'\n'` and
    # `'# '` is prepended to each line;
    #
    # If you care about formatting, use an array of strings for your comment,
    # if not, use a single string.
    def comment=(comment)
      @dirty = true
      @comment = comment
    end

    def method_missing(name, *args) # :nodoc:
      if @model.respond_to?(name)
        @dirty = true if name.to_s.end_with?('=') # Remove to_s when Ruby >2.6.
        @model.send(name, *args)
      else
        super
      end
    end

    def respond_to_missing?(name, *all) # :nodoc:
      @model.respond_to?(name, *all)
    end

    def self.format_comment(comment) # :nodoc:
      return '' if comment.empty?

      comment = comment.scan(/.{1,75}/) if comment.is_a?(String)
      c = comment.map do |l|
        l.empty? ? '#' : "# #{l}"
      end.join("\n")

      "#{c}\n\n"
    end

    def self.parse_comment(content) # :nodoc:
      content = content.split("\n")

      content.reduce([]) do |acc, line|
        break acc unless line.start_with?('#')

        acc << line.sub(/^#+/, '').strip
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	# Copyright (c) 2018-2021 The Ruby Citation File Format Developers.
4	#
5	# Licensed under the Apache License, Version 2.0 (the "License");
6	# you may not use this file except in compliance with the License.
7	# You may obtain a copy of the License at
8	#
9	# http://www.apache.org/licenses/LICENSE-2.0
10	#
11	# Unless required by applicable law or agreed to in writing, software
12	# distributed under the License is distributed on an "AS IS" BASIS,
13	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	# See the License for the specific language governing permissions and
15	# limitations under the License.
16
17	##
18	module CFF	3✔
19
20	# File provides direct access to a CFF Model, with the addition of some
21	# filesystem utilities.
22	class File	3✔
23
24	# A comment to be inserted at the top of the resultant CFF file.
25	attr_reader :comment	3✔
26
27	# The filename of this CFF file.
28	attr_reader :filename	3✔
29
30	YAML_HEADER = "---\n" # :nodoc:	3✔
31	CFF_COMMENT = [
32	"This CITATION.cff file was created by ruby-cff (v #{CFF::VERSION}).",	3✔
33	'Gem: https://rubygems.org/gems/cff',
34	'CFF: https://citation-file-format.github.io/'
35	].freeze # :nodoc:
36
37	# :call-seq:
38	# new(filename, title) -> File
39	# new(filename, model) -> File
40	#
41	# Create a new File. Either a pre-existing Model can be passed in or, as
42	# with Model itself, a title can be supplied to initalize a new File.
43	#
44	# All methods provided by Model are also available directly on File
45	# objects.
46	def initialize(filename, param, comment = CFF_COMMENT, create: false)	3✔
47	param = Model.new(param) unless param.is_a?(Model)	135✔
48
49	@filename = filename	135✔
50	@model = param	135✔
51	@comment = comment	135✔
52	@dirty = create	135✔
53	end
54
55	# :call-seq:
56	# read(file) -> File
57	#
58	# Read a file and parse it for subsequent manipulation.
59	def self.read(file)	3✔
60	content = ::File.read(file)	111✔
61	comment = File.parse_comment(content)	111✔
62
63	new(	111✔
64	file, YAML.safe_load(content, permitted_classes: [Date, Time]), comment
65	)
66	end
67
68	# :call-seq:
69	# open(file) -> File
70	# open(file) {\|cff\| block }
71	#
72	# With no associated block, File.open is a synonym for ::read. If the
73	# optional code block is given, it will be passed the opened file as an
74	# argument and the File object will automatically be written (if edited)
75	# and closed when the block terminates.
76	#
77	# File.open will create a new file if one does not already exist with the
78	# provided file name.
79	def self.open(file)	3✔
80	if ::File.exist?(file)	12✔
81	content = ::File.read(file)	6✔
82	comment = File.parse_comment(content)	6✔
83	yaml = YAML.safe_load(content, permitted_classes: [Date, Time])	6✔
84	else	6✔
85	comment = CFF_COMMENT	6✔
86	yaml = ''	6✔
87	end
88
89	cff = new(file, yaml, comment, create: (yaml == ''))	12✔
90	return cff unless block_given?	12✔
91
92	begin
93	yield cff	6✔
94	ensure
95	cff.write	6✔
96	end
97	end
98
99	# :call-seq:
100	# validate(file) -> Array
101	#
102	# Read a file and return an array with the result. The result array is a
103	# two-element array, with `true`/`false` at index 0 to indicate pass/fail,
104	# and an array of errors at index 1 (if any).
105	def self.validate(file)	3✔
106	File.read(file).validate	6✔
107	end
108
109	# :call-seq:
110	# validate!(file)
111	#
112	# Read a file and raise a ValidationError upon failure. If an error is
113	# raised it will contain the detected validation failures for further
114	# inspection.
115	def self.validate!(file)	3✔
116	File.read(file).validate!	6✔
117	end
118
119	# :call-seq:
120	# write(file, model)
121	# write(file, yaml)
122	#
123	# Write the supplied model or yaml string to `file`.
124	def self.write(file, cff, comment = '')	3✔
125	cff = cff.to_yaml unless cff.is_a?(String)	15✔
126	content = File.format_comment(comment) + cff[YAML_HEADER.length...-1]	15✔
127
128	::File.write(file, content)	15✔
129	end
130
131	# :call-seq:
132	# write
133	#
134	# Write this CFF File.
135	def write	3✔
136	File.write(@filename, @model, @comment) if @dirty	12✔
137	@dirty = false	12✔
138	end
139
140	# :call-seq:
141	# comment = string or array
142	#
143	# A comment to be inserted at the top of the resultant CFF file. This can
144	# be supplied as a simple string or an array of strings. When the file is
145	# saved this comment is formatted as follows:
146	#
147	# * a simple string is split into 75 character lines and `'# '` is prepended
148	# to each line;
149	# * an array of strings is joined into a single string with `'\n'` and
150	# `'# '` is prepended to each line;
151	#
152	# If you care about formatting, use an array of strings for your comment,
153	# if not, use a single string.
154	def comment=(comment)	3✔
UNCOV 155	@dirty = true	×
UNCOV 156	@comment = comment	×
157	end
158
159	def method_missing(name, *args) # :nodoc:	3✔
160	if @model.respond_to?(name)	429✔
161	@dirty = true if name.to_s.end_with?('=') # Remove to_s when Ruby >2.6.	423✔
162	@model.send(name, *args)	423✔
163	else	6✔
164	super	6✔
165	end
166	end
167
168	def respond_to_missing?(name, *all) # :nodoc:	3✔
169	@model.respond_to?(name, *all)	6✔
170	end
171
172	def self.format_comment(comment) # :nodoc:	3✔
173	return '' if comment.empty?	27✔
174
175	comment = comment.scan(/.{1,75}/) if comment.is_a?(String)	15✔
176	c = comment.map do \|l\|	15✔
177	l.empty? ? '#' : "# #{l}"	36✔
178	end.join("\n")
179
180	"#{c}\n\n"	15✔
181	end
182
183	def self.parse_comment(content) # :nodoc:	3✔
184	content = content.split("\n")	135✔
185
186	content.reduce([]) do \|acc, line\|	135✔
187	break acc unless line.start_with?('#')	276✔
188
189	acc << line.sub(/^#+/, '').strip	147✔
190	end
191	end
192	end
193	end

citation-file-format / ruby-cff / 1056078349

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