Class: Middleman::Spellcheck::SpellcheckExtension

Inherits:
Extension
  • Object
show all
Defined in:
lib/middleman-spellcheck/extension.rb

Constant Summary collapse

REJECTED_EXTS = 
%w(.css .js .coffee)
ALLOWED_WORDS = 
[]

Instance Method Summary collapse

Instance Method Details

#after_build(builder) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/middleman-spellcheck/extension.rb', line 22

def after_build(builder)
  return if !options.run_after_build
  Spellchecker.cmdargs=(options.cmdargs)
  Spellchecker.debug_enabled=(options.debug)
  filtered = filter_resources(app, options.page)
  total_misspelled = []

  filtered.each do |resource|
    builder.say_status :spellcheck, "Running spell checker for #{resource.url}", :blue
    current_misspelled = spellcheck_resource(resource)
    current_misspelled.each do |misspell|
      builder.say_status :misspell, error_message(misspell), :red
    end
    total_misspelled += current_misspelled
  end

  builder.say_status :spellcheck, "Spellchecks done. #{total_misspelled.length} misspelling(s) found.", :blue

  unless total_misspelled.empty? 
    if options.dontfail
      builder.say_status :spellcheck, "dontfail is set! Builder will ignore misspellings.", :yellow
    else
      desc = "Build failed. There are spelling errors."
      raise Thor::Error, desc
    end
  end
end

#allowed_words(resource) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/middleman-spellcheck/extension.rb', line 119

def allowed_words(resource)
  words_ok = if options.allow.is_a? Array
              options.allow
            else
              [options.allow]
            end
  words_ok += allowed_words_frontmatter(resource)
  words_ok += allowed_words_file
  words_ok.map(&:downcase)
end

#allowed_words_file ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/middleman-spellcheck/extension.rb', line 143

def allowed_words_file
  allow_file = nil
  if app.config.defines_setting?(:spellcheck_allow_file)
    allow_file = app.config[:spellcheck_allow_file]
  end
  if ALLOWED_WORDS.empty? && allow_file != nil
    lines = File.read(allow_file)
    lines.split("\n").each do |line|
      next if line =~ /^#/ or line =~ /^$/
      ALLOWED_WORDS << line.partition('#').first.strip
    end
  end
  ALLOWED_WORDS
end

#allowed_words_frontmatter(resource) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/middleman-spellcheck/extension.rb', line 130

def allowed_words_frontmatter(resource)
  words_ok = []
  if resource.data.include?("spellcheck-allow") then
    allowed_tmp = resource.data["spellcheck-allow"]
    words_ok += if allowed_tmp.is_a? Array
                 allowed_tmp
               else
                 [allowed_tmp]
               end
  end
  words_ok
end

#error_message(misspell) ⇒ Object 



167
168
169
 
# File 'lib/middleman-spellcheck/extension.rb', line 167

def error_message(misspell)
  "The word '#{misspell[:word]}' is misspelled"
end

#exclude_allowed(resource, results) ⇒ Object 



115
116
117
 
# File 'lib/middleman-spellcheck/extension.rb', line 115

def exclude_allowed(resource, results)
  results.reject { |entry| allowed_words(resource).include? entry[:word].downcase }
end

#filter_resources(app, pattern) ⇒ Object 



90
91
92
93
 
# File 'lib/middleman-spellcheck/extension.rb', line 90

def filter_resources(app, pattern)
  app.sitemap.resources.select { |resource| resource.url.match(pattern) }
    .reject { |resource| option_ignored_exts.include? resource.ext }
end

#option_ignored_exts ⇒ Object 



158
159
160
161
162
163
164
165
 
# File 'lib/middleman-spellcheck/extension.rb', line 158

def option_ignored_exts
  ignored_exts = if options.ignored_exts.is_a? Array
                   options.ignored_exts
                 else
                   [options.ignored_exts]
                 end
  REJECTED_EXTS + ignored_exts
end

#option_tags ⇒ Object 



74
75
76
77
78
79
80
 
# File 'lib/middleman-spellcheck/extension.rb', line 74

def option_tags
  if options.tags.is_a? Array
    options.tags
  else
    [options.tags]
  end
end

#regex_filter_content(text) ⇒ Object 



66
67
68
69
70
71
72
 
# File 'lib/middleman-spellcheck/extension.rb', line 66

def regex_filter_content(text)
  if options.ignore_regex
    text.to_s.gsub options.ignore_regex , ' '
  else
    text
  end
end

#run_check(resource, lang) ⇒ Object 



107
108
109
110
111
112
113
 
# File 'lib/middleman-spellcheck/extension.rb', line 107

def run_check(resource, lang)
  text = select_content(resource)
  text = regex_filter_content(text)
  results = Spellchecker.check(text, lang)
  results = exclude_allowed(resource, results)
  results.reject { |entry| entry[:correct] }
end

#select_content(resource) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/middleman-spellcheck/extension.rb', line 50

def select_content(resource)
  rendered_resource = resource.render(layout: false)
  doc = Nokogiri::HTML.fragment(rendered_resource)
  doc.search('code,style,script').each(&:remove)

  if options.ignore_selector
    doc.css(options.ignore_selector).each(&:remove)
  end

  if options.tags.empty?
    doc.text
  else
    select_tagged_content(doc, option_tags)
  end
end

#select_tagged_content(doc, tags) ⇒ Object 



82
83
84
 
# File 'lib/middleman-spellcheck/extension.rb', line 82

def select_tagged_content(doc, tags)
  tags.map { |tag| texts_for_tag(doc, tag.to_s) }.flatten.join(' ')
end

#spellcheck_resource(resource) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/middleman-spellcheck/extension.rb', line 95

def spellcheck_resource(resource)
  lang =
    if options.lang.respond_to?(:call)
      options.lang.call(resource)
    elsif resource.respond_to?(:lang) and resource.lang
      resource.lang.to_s
    else
      options.lang
    end
  run_check(resource, lang)
end

#texts_for_tag(doc, tag) ⇒ Object 



86
87
88
 
# File 'lib/middleman-spellcheck/extension.rb', line 86

def texts_for_tag(doc, tag)
  doc.css(tag).map(&:text)
end