lib/Crater/Gallery.rakumod


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

class Crater::Gallery {
    has IO $.directory is required;
    has Str $!title;

    submethod TWEAK() {
        # Get title from file if exists.
        my $title-file = $!directory.add(".crater/title");
        $!title = $title-file.slurp.chomp if $title-file.f;
    }

    #| Accessor for $!title.
    method title() { $!title }

    method list(:@sub-dir) {
        # This will be considered an attempt to attack. There is no
        # reason to check '.' I belive.
        die "[!!!] @sub-dir contains '..'/'.'" if @sub-dir.grep('.'|'..');

        # Serve the subdirectory if passed.
        my @paths = @sub-dir
                     ?? $!directory.add(@sub-dir.join("/")).dir
                     !! $!directory.dir;

        # Gallery holds all the elements that will be shown.
        my @gallery;
        @gallery.push(%( :type<heading>, :text($_) )) with $!title;

        # Add directories on top.
        for @paths.grep(*.d).sort {
            next if .ends-with(".crater");
            push @gallery, %(:type<directory>, :text($_.relative($!directory)));
        }

        # Adding supported file types.
        for @paths.grep(*.f).sort(*.modified) -> $f {
            my $rel = $f.relative($!directory);

            given $f.extension.lc {
                when 'jpg'|'png' {
                    my $thumb = $!directory.add(".crater/thumbnails").add($rel);

                    # For images get the original if thumbnail doesn't
                    # exist, otherwise use the thumbnail.
                    push @gallery, %(
                        :type<img>,
                        :src($thumb.f ?? $rel !! "{$rel}?original"),
                        alt => $rel
                    );
                }
                when '0' {
                    push @gallery, %(:type<heading>, :text($f.slurp.chomp));
                }
                when 'txt' {
                    push @gallery, %(:type<text>, :text($f.slurp.chomp));
                }
                default {
                    note "Unhandled file: $f";
                }
            }
        }
        return @gallery;
    }
}
//: Phase 2: Filter loaded recipes through an extensible list of 'transforms'.
//:
//: The hope is that this framework of transform tools will provide a
//: deconstructed alternative to conventional compilers.

:(before "End recipe Fields")
long long int transformed_until;
  recipe() :transformed_until(-1) {}

:(before "End Types")
typedef void (*transform_fn)(recipe_ordinal);

:(before "End Globals")
vector<transform_fn> Transform;

:(code)
void transform_all() {
//?   cerr << "AAA transform_all\n"; //? 2
  for (long long int t = 0; t < SIZE(Transform); ++t) {
    for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
      recipe& r = p->second;
      if (r.steps.empty()) continue;
      if (r.transformed_until != t-1) continue;
      (*Transform.at(t))(/*recipe_ordinal*/p->first);
      r.transformed_until = t;
    }
  }
  parse_int_reagents();  // do this after all other transforms have run
}

void parse_int_reagents() {
//?   cout << "parse_int_reagents\n"; //? 1
  for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
    recipe& r = p->second;
    if (r.steps.empty()) continue;
    for (long long int index = 0; index < SIZE(r.steps); ++index) {
      instruction& inst = r.steps.at(index);
      for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
        populate_value(inst.ingredients.at(i));
      }
      for (long long int i = 0; i < SIZE(inst.products); ++i) {
        populate_value(inst.products.at(i));
      }
    }
  }
}

void populate_value(reagent& r) {
  if (r.initialized) return;
  // End Reagent-parsing Exceptions
  if (!is_integer(r.name)) return;
  r.set_value(to_integer(r.name));
}