Class: RuneBlog

Inherits:
Object
  • Object
show all
Extended by:
Helpers
Includes:
Helpers
Defined in:
lib/global.rb,
lib/runeblog.rb,
lib/runeblog_version.rb

Overview

skeleton

Defined Under Namespace

Modules: Helpers, REPL Classes: Default, Post, Publishing, View, ViewPost

Constant Summary collapse

DotDir = 
".blogs"
ConfigFile = 
"config"
Themes = 
RuneBlog::Path/"../themes"
VERSION = 
"0.2.28"
Path = 
File.dirname(path)

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Helpers

copy, copy!, create_dirs, dump, error, find_draft_slugs, get_views, interpolate, new_dotfile, new_sequence, read_config, subdirs, try_read_config, write_config

Constructor Details

#initialize(root_dir = ".blogs") ⇒ RuneBlog

always assumes existing blog



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/runeblog.rb', line 84

def initialize(root_dir = ".blogs")   # always assumes existing blog
  log!(enter: "initialize", args: [root_dir])
  # Crude - FIXME later -  # What views are there? Publishing, etc.
  self.class.blog = self   # Weird. Like a singleton - dumbass circular dependency?

  @root = root_dir
  file = @root/ConfigFile
  errmsg = "No config file! file = #{file.inspect}  dir = #{Dir.pwd}" 
  raise errmsg unless File.exist?(file)

  @root, @view_name, @editor = read_config(file, :root, :current_view, :editor)
  md = Dir.pwd.match(%r[.*/views/(.*?)/])
  @view_name = md[1] if md
  @views = get_views
  @view = str2view(@view_name)
  @sequence = get_sequence
  @post_views = []
  @post_tags = []
end

Class Attribute Details

.blog ⇒ Object

Returns the value of attribute blog.



34
35
36
 
# File 'lib/runeblog.rb', line 34

def blog
  @blog
end

Instance Attribute Details

#dirty_views ⇒ Object

Returns the value of attribute dirty_views.



41
42
43
 
# File 'lib/runeblog.rb', line 41

def dirty_views
  @dirty_views
end

#editor ⇒ Object (readonly)

Returns the value of attribute editor.



38
39
40
 
# File 'lib/runeblog.rb', line 38

def editor
  @editor
end

#post_tags ⇒ Object

Returns the value of attribute post_tags.



41
42
43
 
# File 'lib/runeblog.rb', line 41

def post_tags
  @post_tags
end

#post_views ⇒ Object

Returns the value of attribute post_views.



41
42
43
 
# File 'lib/runeblog.rb', line 41

def post_views
  @post_views
end

#root ⇒ Object (readonly)

Returns the value of attribute root.



38
39
40
 
# File 'lib/runeblog.rb', line 38

def root
  @root
end

#sequence ⇒ Object (readonly)

Returns the value of attribute sequence.



38
39
40
 
# File 'lib/runeblog.rb', line 38

def sequence
  @sequence
end

#view(name = nil) ⇒ Object

overridden

Raises:

  • (ArgumentError) 


39
40
41
 
# File 'lib/runeblog.rb', line 39

def view
  @view
end

#views ⇒ Object (readonly)

Returns the value of attribute views.



38
39
40
 
# File 'lib/runeblog.rb', line 38

def views
  @views
end

Class Method Details

.create(root = ".blogs") ⇒ Object

Raises:

  • (BlogRepoAlreadyExists) 


55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/runeblog.rb', line 55

def self.create(root = ".blogs")
  log!(enter: __method__, args: [root])
  # Crude - FIXME later -  # What views are there? Publishing, etc.
  self.blog = self   # Weird. Like a singleton - dumbass circular dependency?
  root = Dir.pwd/root
  raise BlogRepoAlreadyExists if Dir.exist?(root)
  create_dirs(root)
  Dir.chdir(root) do
    system!("cp #{RuneBlog::Path}/../empty_view.tgz .")
    create_dirs(:drafts, :views, :posts)
    new_sequence
  end
#   put_config(root: root)
  x = OpenStruct.new
  x.root, x.current_view, x.editor = root, "test_view", "/usr/bin/vim "   # dumb - FIXME later
  write_config(x, root/ConfigFile)
  @blog = self.new(root)
  @blog.create_view("test_view")
  @blog
end

.create_new_blog_repo(dir = ".blogs") ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'lib/runeblog.rb', line 45

def self.create_new_blog_repo(dir = ".blogs")
  log!(enter: __method__, args: [dir])
  raise ArgumentError unless dir.is_a?(String) && ! dir.empty?
  root_dir = Dir.pwd/dir
  self.create(dir)
rescue => err
  puts "Can't create blog repo: '#{dir}' - #{err}"
  puts err.backtrace.join("\n")
end

.exist? ⇒ Boolean

Returns:

  • (Boolean) 


214
215
216
217
 
# File 'lib/runeblog.rb', line 214

def self.exist?
  log!(enter: __method__)
  Dir.exist?(DotDir) && File.exist?(DotDir/ConfigFile)
end

.open(root = ".blogs") ⇒ Object 



76
77
78
79
80
81
82
 
# File 'lib/runeblog.rb', line 76

def self.open(root = ".blogs")
  log!(enter: __method__, args: [root])
  # Crude - FIXME later -  # What views are there? Publishing, etc.
  self.blog = self   # Weird. Like a singleton - dumbass circular dependency?
  root = Dir.pwd/root
  blog = self.new(root)
end

.post_template(num: 0, title: "No title", date: nil, view: "test_view", teaser: "No teaser", body: "No body", tags: ["untagged"], views: [], back: "javascript:history.go(-1)", home: "no url") ⇒ Object

This will all become much more generic later.



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/default.rb', line 5

def RuneBlog.post_template(num: 0, title: "No title", date: nil, view: "test_view", 
                       teaser: "No teaser", body: "No body", tags: ["untagged"], 
                       views: [], back: "javascript:history.go(-1)", home: "no url")
  log!(enter: __method__, args: [num, title, date, view, teaser, body, tags, views, back, home])
  viewlist = (views + [view.to_s]).join(" ")
  taglist = ".tags " + tags.join(" ")
<<-TEXT
.mixin liveblog
. ^ get rid of this later

.post #{num}
 
.title #{title}
.pubdate #{date}
.views #{viewlist}
#{taglist}
 
.teaser
#{teaser}
.end
#{body}
TEXT

end

Instance Method Details

#_copy_get_dirs(draft, view) ⇒ Object 



416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/runeblog.rb', line 416

def _copy_get_dirs(draft, view)
  log!(enter: __method__, args: [draft, view])
  fname = File.basename(draft)
  noext = fname.sub(/.lt3$/, "")
  vdir = @root/:views/view
  dir = vdir/:posts/noext
  Dir.mkdir(dir) unless Dir.exist?(dir)
  system!("cp #{draft} #{dir}")
  viewdir, slugdir, aslug = vdir, dir, noext[5..-1]
  theme = viewdir/:themes/:standard
  [noext, viewdir, slugdir, aslug, theme]
end

#_deploy_local(dir) ⇒ Object 



104
105
106
107
108
109
110
 
# File 'lib/runeblog.rb', line 104

def _deploy_local(dir)
  log!(enter: __method__, args: [dir])
  Dir.chdir(dir) do
    views = _retrieve_metadata(:views)
    views.each {|v| system!("cp *html #@root/views/#{v}/remote") }
  end
end

#_get_views(draft) ⇒ Object 



405
406
407
408
409
410
411
412
413
414
 
# File 'lib/runeblog.rb', line 405

def _get_views(draft)
  log!(enter: __method__, args: [draft])
  # FIXME dumb code
  view_line = File.readlines(draft).grep(/^.views /)
  raise "More than one .views call!" if view_line.size > 1
  raise "No .views call!" if view_line.size < 1
  view_line = view_line.first
  views = view_line[7..-1].split
  views 
end

#_handle_post(draft, view) ⇒ Object 



456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
 
# File 'lib/runeblog.rb', line 456

def _handle_post(draft, view)
  log!(enter: __method__, args: [draft, view])
  # break into separate methods?

  fname = File.basename(draft)       # 0001-this-is-a-post.lt3
  nslug = fname.sub(/.lt3$/, "")     # 0001-this-is-a-post
  aslug = nslug.sub(/\d\d\d\d-/, "") # this-is-a-post
  ahtml = aslug + ".html"            # this-is-a-post.html
  pdraft = @root/:posts/nslug
  remote = @root/:views/view/:remote
  @theme = @root/:views/view/:themes/:standard
  # Step 1...
  create_dirs(pdraft)
  xlate cwd: pdraft, src: draft, dst: "guts.html"
  _post_metadata(draft, pdraft)
  # Step 2...
  vposts = @root/:views/view/:posts
  copy!(pdraft, vposts)    # ??
  # Step 3..
  copy(pdraft/"guts.html", @theme/:post) 
  copy(pdraft/"vars.lt3",  @theme/:post) 
  # Step 4...
  xlate cwd: @theme/:post, src: "generate.lt3", 
        dst: remote/ahtml, copy: @theme/:post  # , debug: true
  xlate cwd: @theme/:post, src: "permalink.lt3", 
        dst: remote/:permalink/ahtml  # , debug: true
  copy_widget_html(view)
end

#_post_metadata(draft, pdraft) ⇒ Object 



429
430
431
432
433
434
435
436
437
438
 
# File 'lib/runeblog.rb', line 429

def _post_metadata(draft, pdraft)
  log!(enter: __method__, args: [draft, pdraft])
  Dir.chdir(pdraft) do 
    excerpt = File.read("teaser.txt")
    title = _retrieve_metadata(:title)
    vars = %[.heredoc title\n#{title.chomp}\n.end\n] + 
           %[.heredoc teaser\n#{excerpt.chomp}\n.end\n]
    File.open(pdraft/"vars.lt3", "w") {|f| f.puts vars }
  end
end

#_retrieve_metadata(key) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/runeblog.rb', line 112

def _retrieve_metadata(key)
  key = key.to_s
  lines = File.readlines("metadata.txt")
  lines = lines.grep(/^#{key}: /)
  case lines.size
    when 0
      result = nil  # not found
    when 1
      front = "#{key}: "
      n = front.size
      str = lines.first.chomp[n..-1]
      case key
        when "views", "tags"   # plurals
          result = str.split
      else
        result = str
      end
  else 
    raise "Too many #{key} instances in metadata.txt!"
  end
  return result
end

#_set_publisher ⇒ Object 



173
174
175
176
 
# File 'lib/runeblog.rb', line 173

def _set_publisher
  log!(enter: __method__)
  @view.publisher = RuneBlog::Publishing.new(@view.to_s)  # FIXME refactor
end

#add_view(view_name) ⇒ Object 



224
225
226
227
228
229
230
 
# File 'lib/runeblog.rb', line 224

def add_view(view_name)
  log!(enter: __method__, args: [view_name])
  view = RuneBlog::View.new(view_name)
  @view = view    # current view
  @views << view  # all views
  view
end

#change_view(view) ⇒ Object

Raises:

  • (ArgumentError) 


379
380
381
382
383
384
385
386
 
# File 'lib/runeblog.rb', line 379

def change_view(view)
  log!(enter: __method__, args: [view])
  raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
  x = OpenStruct.new
  x.root, x.current_view, x.editor = @root, view.to_s, @editor   # dumb - FIXME later
  write_config(x, @root/ConfigFile)
  self.view = view   # error checking?
end

#check_valid_new_view(view_name) ⇒ Object

Raises:

  • (ArgumentError) 


242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/runeblog.rb', line 242

def check_valid_new_view(view_name)
  log!(enter: __method__, args: [view_name])
  raise ArgumentError unless view_name.is_a?(String)
  raise ArgumentError if view_name.empty?
  names = self.views.map(&:to_s)
  bad = names.include?(view_name)
  raise ViewAlreadyExists(view_name) if bad
  vdir = @root/:views/view_name
  raise DirAlreadyExists(view_name) if Dir.exist?(vdir)
  return true   # hm?
end

#collect_recent_posts(file) ⇒ Object 



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/runeblog.rb', line 313

def collect_recent_posts(file)
  log!(enter: __method__, args: [file])
  posts = nil
  dir_posts = @vdir/:posts
  entries = Dir.entries(dir_posts)
  posts = entries.grep(/^\d\d\d\d/).map {|x| dir_posts/x }
  posts.select! {|x| File.directory?(x) }
  # directories that start with four digits
  posts = posts.sort {|a, b| b.to_i <=> a.to_i }  # sort descending
  posts = posts[0..19]  # return 20 at most
  text = <<-HTML
    <html>
    <head><link rel="stylesheet" href="etc/blog.css"></head>
    <body>
  HTML
  wanted = [5, posts.size].min  # estimate how many we want?
  enum = posts.each
  wanted.times do
    postid = File.basename(enum.next)
    postid = postid.to_i
    text << teaser(postid)    # side effect! calls _out
  end
  text << "</body></html>"
  File.write(@vdir/:remote/file, text)
end

#copy_widget_html(view) ⇒ Object 



440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/runeblog.rb', line 440

def copy_widget_html(view)
  log!(enter: __method__)
  vdir = @root/:views/view
  remote = vdir/:remote
  wdir = vdir/:themes/:standard/:widgets
  widgets = Dir[wdir/"*"].select {|w| File.directory?(w) }
  widgets.each do |w|
    dir = File.basename(w)
    rem = w.sub(/themes.standard/, "remote")
    create_dirs(rem)
    files = Dir[w/"*"]
    next unless files.any? {|x| x =~ /html$/ }
    system!("cp #{w}/*html #{rem}")
  end
end

#create_new_post(title, testing = false, teaser: nil, body: nil, other_views: []) ⇒ Object 



339
340
341
342
343
344
345
346
347
348
349
350
351
352
 
# File 'lib/runeblog.rb', line 339

def create_new_post(title, testing = false, teaser: nil, body: nil, other_views: [])
  log!(enter: __method__, args: [title, testing, teaser, body, other_views])
  meta = nil
  Dir.chdir(@root/:posts) do
    post = Post.create(title: title, teaser: teaser, body: body, other_views: other_views)
    post.edit unless testing
    post.build
    meta = post.meta
  end
  return meta.num
rescue => err
  puts err
  puts err.backtrace.join("\n")
end

#create_view(view_name) ⇒ Object 



254
255
256
257
258
259
260
 
# File 'lib/runeblog.rb', line 254

def create_view(view_name)
  log!(enter: __method__, args: [view_name])
  check_valid_new_view(view_name)
  make_empty_view_tree(view_name)
  mark_last_published("Initial creation")
  add_view(view_name)
end

#delete_draft(num) ⇒ Object

Raises:

  • (ArgumentError) 


567
568
569
570
571
572
 
# File 'lib/runeblog.rb', line 567

def delete_draft(num)
  log!(enter: __method__, args: [num])
  raise ArgumentError unless num.is_a?(Integer)
  tag = prefix(num)
  system!("rm -rf #@root/drafts/#{tag}-*")
end

#delete_view(name, force = false) ⇒ Object

Raises:

  • (ArgumentError) 


262
263
264
265
266
267
268
269
270
 
# File 'lib/runeblog.rb', line 262

def delete_view(name, force = false)
  log!(enter: __method__, args: [name, force])
  raise ArgumentError unless name.is_a?(String) && ! name.empty?
  if force
    vname = @root/:views/name
    system!("rm -rf #{vname}")
    @views -= [str2view(name)]
  end
end

#drafts ⇒ Object 



373
374
375
376
377
 
# File 'lib/runeblog.rb', line 373

def drafts
  log!(enter: __method__)
  dir = @root/:drafts
  drafts = Dir.entries(dir).grep(/^\d{4}.*/)
end

#edit_initial_post(file, testing = false) ⇒ Object 



354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/runeblog.rb', line 354

def edit_initial_post(file, testing = false)
  log!(enter: __method__, args: [file, testing])
  debug "=== edit_initial_post #{file.inspect}  => #{sourcefile}"
  sourcefile = @root/:drafts/file
  result = system!("#@editor #{sourcefile} +8") unless testing
  raise EditorProblem(sourcefile) unless result
  process_post(sourcefile)
  nil
rescue => err
  error(err)
end

#generate_index(view) ⇒ Object

Raises:

  • (ArgumentError) 


388
389
390
391
392
393
 
# File 'lib/runeblog.rb', line 388

def generate_index(view)
  log!(enter: __method__, args: [view], pwd: true, dir: true)
  raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
  @vdir = @root/:views/view
  collect_recent_posts("recent.html")
end

#generate_post(draft) ⇒ Object 



485
486
487
488
489
490
491
492
 
# File 'lib/runeblog.rb', line 485

def generate_post(draft)
  log!(enter: __method__, args: [draft])
  views = _get_views(draft)
  views.each do |view| 
    _handle_post(draft, view)
    generate_view(view)  # FIXME leads to inefficiency?
  end
end

#generate_view(view) ⇒ Object

huh?



395
396
397
398
399
400
401
402
403
 
# File 'lib/runeblog.rb', line 395

def generate_view(view)  # huh?
  log!(enter: __method__, args: [view])
  generate_index(view)   # recent posts (recent.html)
  vdir = @root/:views/view
  xlate cwd: vdir/"themes/standard/etc",
        src: "blog.css.lt3", copy: vdir/"remote/etc/blog.css" # , debug: true
  xlate cwd: vdir/"themes/standard",
        src: "blog/generate.lt3", dst: vdir/:remote/"index.html"
end

#get_sequence ⇒ Object 



194
195
196
197
 
# File 'lib/runeblog.rb', line 194

def get_sequence
  log!(enter: __method__)
  File.read(@root/:sequence).to_i
end

#index_entry(view, meta) ⇒ Object

Raises:

  • (ArgumentError) 


499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
 
# File 'lib/runeblog.rb', line 499

def index_entry(view, meta)
  log!(enter: __method__, args: [view, meta])
  debug "=== index_entry #{view.to_s.inspect}  #{meta.num} #{meta.title.inspect}"
  check_meta(meta, "index_entry1")
  raise ArgumentError unless view.is_a?(String) || view.is_a?(RuneBlog::View)
  check_meta(meta, "index_entry2")
  self.make_slug(meta)
  check_meta(meta, "index_entry3")
  # FIXME clean up and generalize
  ref = view/meta.slug/"index.html"
  <<-HTML
    <font size=-1>#{meta.date}&nbsp;&nbsp;</font> <br>
    <font size=+2 color=blue><a href=../#{ref} style="text-decoration: none">#{meta.title}</font></a>
    <br>
    <font size=+1>#{meta.teaser}&nbsp;&nbsp;</font>
    <a href=../#{ref} style="text-decoration: none">Read more...</a>
    <br>
    <hr>
  HTML
end

#inspect ⇒ Object 



144
145
146
147
148
149
150
151
152
153
 
# File 'lib/runeblog.rb', line 144

def inspect
  log!(enter: __method__)
  str = "blog: "
  ivars = ["@root", "@sequence"]   # self.instance_variables
  ivars.each do |iv| 
    val = self.instance_variable_get(iv)
    str << "#{iv}: #{val}  "
  end
  str
end

#make_empty_view_tree(view_name) ⇒ Object 



232
233
234
235
236
237
238
239
240
 
# File 'lib/runeblog.rb', line 232

def make_empty_view_tree(view_name)
  log!(enter: __method__, args: [view_name])
  Dir.chdir(@root) do
    cmd1 = "tar zxvf empty_view.tgz >/dev/null 2>&1"
    cmd2 = "cp -r empty_view views/#{view_name}"
    system!(cmd1)
    system!(cmd2)
  end
end

#make_slug(meta) ⇒ Object

Raises:

  • (ArgumentError) 


574
575
576
577
578
579
580
581
582
 
# File 'lib/runeblog.rb', line 574

def make_slug(meta)
  log!(enter: __method__, args: [meta])
  raise ArgumentError unless meta.title.is_a?(String)
  label = '%04d' % meta.num   # FIXME can do better
  slug0 = meta.title.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
  str = "#{label}-#{slug0}"
  meta.slug = str
  str
end

#mark_last_published(str) ⇒ Object 



219
220
221
222
 
# File 'lib/runeblog.rb', line 219

def mark_last_published(str)
  log!(enter: __method__, args: [str])
  dump(str, "last_published")
end

#next_sequence ⇒ Object 



199
200
201
202
203
204
 
# File 'lib/runeblog.rb', line 199

def next_sequence
  log!(enter: __method__)
  @sequence += 1
  dump(@sequence, @root/:sequence)
  @sequence
end

#post_lookup(postid) ⇒ Object

side-effect?



280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/runeblog.rb', line 280

def post_lookup(postid)    # side-effect?
  log!(enter: __method__, args: [postid])
  slug = title = date = teaser_text = nil

  dir_posts = @vdir/:posts
  posts = Dir.entries(dir_posts).grep(/^\d\d\d\d/).map {|x| dir_posts/x }
  posts.select! {|x| File.directory?(x) }

  post = posts.select {|x| File.basename(x).to_i == postid }
  raise "Error: More than one post #{postid}" if post.size > 1
  postdir = post.first
  vp = RuneBlog::ViewPost.new(self.view, postdir)
  vp
end

#posts ⇒ Object 



366
367
368
369
370
371
 
# File 'lib/runeblog.rb', line 366

def posts
  log!(enter: __method__)
  dir = self.view.dir/:posts
  posts = Dir.entries(dir).grep(/^\d{4}/)
  posts
end

#process_post(sourcefile) ⇒ Object 



135
136
137
138
139
140
141
142
 
# File 'lib/runeblog.rb', line 135

def process_post(sourcefile)
  log!(enter: __method__, args: [dir])
  nslug = sourcefile.sub(/.lt3/, "")
  dir = @root/:posts/nslug
  create_dir(dir)
  xlate cwd: dir, src: sourcefile  # , debug: true
  _deploy_local(dir)
end

#rebuild_post(file) ⇒ Object 



520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# File 'lib/runeblog.rb', line 520

def rebuild_post(file)
  log!(enter: __method__, args: [file])
  raise "Doesn't currently work"
  debug "Called rebuild_post(#{file.inspect})"
  raise ArgumentError unless file.is_a?(String)
  meta = process_post(file)
  @views_dirty ||= []
  @views_dirty << meta.views
  @views_dirty.flatten!
  @views_dirty.uniq!
rescue => err
  error(err)
  getch
end

#relink ⇒ Object

FIXME no longer used?



494
495
496
497
 
# File 'lib/runeblog.rb', line 494

def relink   # FIXME no longer used?
  log!(enter: __method__)
  self.views.each {|view| generate_index(view) }
end

#remove_post(num) ⇒ Object

Raises:

  • (ArgumentError) 


535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
 
# File 'lib/runeblog.rb', line 535

def remove_post(num)
  log!(enter: __method__, args: [num])
  raise ArgumentError unless num.is_a?(Integer)
  tag = prefix(num)
  files = Find.find(self.view.dir).to_a
  list = files.select {|x| File.directory?(x) and x =~ /#{tag}/ }
  return nil if list.empty?
  dest = list.map {|f| f.sub(/(?<num>\d{4}-)/, "_\\k<num>") }
  list.each.with_index do |src, i| 
    cmd = "mv #{src} #{dest[i]} 2>/dev/null"
    system!(cmd)
  end
  # FIXME - update index/etc
  true
end

#str2view(str) ⇒ Object

Raises:

  • (ArgumentError) 


167
168
169
170
171
 
# File 'lib/runeblog.rb', line 167

def str2view(str)
  log!(enter: __method__, args: [str])
  raise ArgumentError unless str.is_a?(String) && ! str.empty?
  @views.find {|x| x.name == str }
end

#teaser(slug) ⇒ Object 



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/runeblog.rb', line 295

def teaser(slug)
  log!(enter: __method__, args: [slug])
  id = slug.to_i
  text = nil
  post_entry_name = @theme/"blog/post_entry.lt3"
  xlate src: post_entry_name, dst: "/tmp/post_entry.html" # , debug: true
  @_post_entry ||= File.read("/tmp/post_entry.html")
  vp = post_lookup(id)
  nslug, aslug, title, date, teaser_text = 
    vp.nslug, vp.aslug, vp.title, vp.date, vp.teaser_text
  path = vp.path
  url = aslug + ".html"
  date = ::Date.parse(date)
  date = date.strftime("%B %e<br>%Y")
  text = interpolate(@_post_entry, binding)
  text
end

#undelete_post(num) ⇒ Object

Raises:

  • (ArgumentError) 


551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
 
# File 'lib/runeblog.rb', line 551

def undelete_post(num)
  log!(enter: __method__, args: [num])
  raise ArgumentError unless num.is_a?(Integer)
  files = Find.find(@root/:views).to_a
  tag = prefix(num)
  list = files.select {|x| File.directory?(x) and x =~ /_#{tag}/ }
  return nil if list.empty?
  dest = list.map {|f| f.sub(/_(?<num>\d{4}-)/, "\\k<num>") }
  list.each.with_index do |src, i| 
    cmd = "mv #{src} #{dest[i]} 2>/dev/null"
    system!(cmd)
  end
  # FIXME - update index/etc
  true
end

#view?(name) ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (ArgumentError) 


155
156
157
158
159
 
# File 'lib/runeblog.rb', line 155

def view?(name)
  log!(enter: __method__, args: [name])
  raise ArgumentError unless name.is_a?(String) && ! name.empty?
  views.any? {|x| x.name == name }
end

#view_files ⇒ Object 



272
273
274
275
276
277
278
 
# File 'lib/runeblog.rb', line 272

def view_files
  log!(enter: __method__)
  vdir = self.view.dir
  files = [vdir/"index.html"]
  files += posts.map {|x| vdir/x }
  files.reject! {|f| File.mtime(f) < File.mtime(vdir/:last_published) }
end

#viewdir(v = nil) ⇒ Object

delete?

Raises:

  • (ArgumentError) 


206
207
208
209
210
211
212
 
# File 'lib/runeblog.rb', line 206

def viewdir(v = nil)   # delete?
  log!(enter: __method__, args: [v])
  v = str2view(v) if v.is_a?(String)
  raise ArgumentError unless v.nil? || v.is_a?(RuneBlog::View)
  v ||= @view
  return @root/:views/v
end