nanoc-rust 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8db56be993dae34ec1512f2cd9af7467c7600529
+  data.tar.gz: a0514e0c847376638155b4f8e6e46038ad3902fa
+SHA512:
+  metadata.gz: cd68879cd68f971b3d6295288f782d0a3392c716797df889159ccc0187ef24efa41effa961cbff1a172969e082dd00d439213dbc24a9a7ac09174c16b6d5e727
+  data.tar.gz: 756b079f316ef77d1b8c4c0abf85ff510f0a649cf7a15feb4947c93b8ebffb08b13fa789456d92096a7867017099bb44517c01696980bf83846ca3c7f35a6d6a

data/.gitignore

@@ -0,0 +1,3 @@
+dist/
+target/
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+-r ./spec/spec_helper.rb
+--format Fuubar
+--color

data/.rubocop.yml

@@ -0,0 +1,174 @@
+# ----- CONFIGURED -----
+
+AllCops:
+  TargetRubyVersion: 2.3
+  DisplayCopNames: true
+
+# We use filenames such as “create-site.rb” that translate to method names.
+FileName:
+  Exclude:
+    - 'lib/nanoc/cli/commands/*.rb'
+    - 'Appraisals'
+
+# A common pattern in tests is to define anonymous classes in which methods are defined, which trips
+# up Rubocop’s nested method definition cop.
+Lint/NestedMethodDefinition:
+  Exclude:
+    - 'test/**/*.rb'
+    - 'spec/**/*.rb'
+
+# This is used in tests, to verify the effect of state-changing functions.
+Style/GlobalVars:
+  Exclude:
+    - 'test/**/*.rb'
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInLiteral:
+  EnforcedStyleForMultiline: comma
+
+# `rescue nil` is useful in specs where the exception is not important, but
+# the size effects are.
+Style/RescueModifier:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Lint/DuplicateMethods:
+  Exclude:
+    - 'test/data_sources/test_filesystem.rb'
+    - 'spec/spec_helper.rb'
+
+# This needs to be fixed in Ruby 2.4.
+Lint/UnifiedInteger:
+  Enabled: false
+
+Layout/IndentHeredoc:
+  EnforcedStyle: squiggly
+
+# This breaks RSpec on occasion, e.g. `expect { subject }.not_to change { foo }`,
+# and generally does not provide useful warnings
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+# ----- TO ENABLE LATER -----
+
+# Valid cops, but fixing the offenses they report is non-trivial.
+
+RegexpLiteral:
+  Enabled: false
+
+ClassAndModuleChildren:
+  Enabled: false
+
+Style/EmptyElse:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+
+
+# ----- DISABLED (hard) -----
+
+# Rubocop trips up on this.
+Layout/LeadingCommentSpace:
+  Enabled: false
+
+
+
+# ----- DISABLED (security) -----
+
+# Nanoc runs offline in a trusted environment, and these security checks are false positives.
+
+Security/YAMLLoad:
+  Enabled: false
+
+Security/MarshalLoad:
+  Enabled: false
+
+Security/Eval:
+  Exclude:
+    - 'test/**/*.rb'
+    - 'spec/**/*.rb'
+    - 'lib/nanoc/base/entities/code_snippet.rb'
+    - 'lib/nanoc/filters/erubi.rb'
+
+
+# ----- DISABLED (metrics) -----
+
+# Cops for metrics are disabled because they should not cause tests to fail.
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+
+
+# ----- DISABLED (opinionated) -----
+
+# We should embrace UTF-8, not avoid it. Since the Encoding cop is enabled,
+# there’s no point in enforcing ASCII comments.
+AsciiComments:
+  Enabled: false
+
+# It does not make sense to enforce everything to have documentation.
+Documentation:
+  Enabled: false
+
+# Nanoc suppresses exceptions for valid reasons in a few cases.
+HandleExceptions:
+  Enabled: false
+
+# if/unless at the end of the line makes it too easy to oversee.
+IfUnlessModifier:
+  Enabled: false
+
+# Personal preference is to have decent constructors for exceptions rather than
+# just a class and a message.
+RaiseArgs:
+  Enabled: false
+
+# Personal preference is to use `raise` to signal exceptions (normal control
+# flow should not use exceptions anyway).
+SignalException:
+  Enabled: false
+
+# Some methods that appear to be accessors (return a single value or set a
+# single value) should still not be considered to be accessors. This is a purely
+# semantic difference.
+TrivialAccessors:
+  Enabled: false
+
+# This does not always semantically make sense.
+GuardClause:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :devel do
+  gem 'fuubar'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec-its', '~> 1.2'
+  gem 'rspec-mocks'
+  gem 'rubocop', '~> 0.49'
+end

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    nanoc-rust (0.1)
+      ffi (~> 1.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    diff-lcs (1.3)
+    ffi (1.9.18)
+    fuubar (2.2.0)
+      rspec-core (~> 3.0)
+      ruby-progressbar (~> 1.4)
+    parallel (1.11.2)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-its (1.2.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rubocop (0.49.1)
+      parallel (~> 1.10)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.15)
+  fuubar
+  nanoc-rust!
+  rake
+  rspec
+  rspec-its (~> 1.2)
+  rspec-mocks
+  rubocop (~> 0.49)
+
+BUNDLED WITH
+   1.15.1

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+
+RuboCop::RakeTask.new(:rubocop)
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+task test: %i[spec rubocop]
+
+task default: :test

data/lib/nanoc-rust.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module NanocRust
+  module FFI
+    class Edge < ::FFI::Struct
+      layout  :from, :uint32,
+              :to,   :uint32,
+              :idx,  :uint32
+
+      def to_a(props)
+        [self[:from], self[:to], props[self[:idx]]]
+      end
+    end
+
+    extend ::FFI::Library
+
+    root = File.expand_path(File.dirname(__FILE__) + '/..')
+    ffi_lib root + '/rust/dist/libnanoc_rust.' + ::FFI::Platform::LIBSUFFIX
+
+    attach_function :drop_string, %i[pointer],        :void
+    attach_function :drop_array,  %i[pointer uint32], :void
+
+    attach_function :digraph_create, [], :pointer
+    attach_function :digraph_destroy, [:pointer], :void
+
+    attach_function :digraph_inspect, [:pointer], :pointer
+
+    attach_function :digraph_add_vertex,        %i[pointer string],               :void
+    attach_function :digraph_add_edge,          %i[pointer string string uint32], :void
+    attach_function :digraph_delete_edges_to,   %i[pointer string],               :void
+
+    attach_function :digraph_direct_predecessors_of, %i[pointer string pointer], :pointer
+    attach_function :digraph_predecessors_of,        %i[pointer string pointer], :pointer
+    attach_function :digraph_direct_successors_of,   %i[pointer string pointer], :pointer
+    attach_function :digraph_successors_of,          %i[pointer string pointer], :pointer
+    attach_function :digraph_edges,                  %i[pointer pointer],        :pointer
+    attach_function :digraph_vertices,               %i[pointer pointer],        :pointer
+    attach_function :digraph_props_for,              %i[pointer pointer pointer], :uint32
+  end
+
+  class DirectedGraph
+    def initialize(vertices)
+      raw = NanocRust::FFI.digraph_create
+      @wrapped = ::FFI::AutoPointer.new(raw, NanocRust::FFI.method(:digraph_destroy))
+
+      @_props = {}
+      @_next_prop_idx = 1
+
+      vertices.each { |v| add_vertex(v) }
+    end
+
+    def inspect
+      ptr = NanocRust::FFI.digraph_inspect(@wrapped)
+      s = ptr.read_string
+      ::NanocRust::FFI.drop_string(ptr)
+      s
+    end
+
+    # mutating
+
+    def add_vertex(v)
+      NanocRust::FFI.digraph_add_vertex(@wrapped, v)
+    end
+
+    def add_edge(v1, v2, props: nil)
+      @_props[@_next_prop_idx] = props
+      NanocRust::FFI.digraph_add_edge(@wrapped, v1, v2, @_next_prop_idx)
+      @_next_prop_idx += 1
+    end
+
+    def delete_edges_to(v)
+      NanocRust::FFI.digraph_delete_edges_to(@wrapped, v)
+    end
+
+    # querying
+
+    def direct_predecessors_of(v)
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_direct_predecessors_of(@wrapped, v, count_ptr)
+      ptr_to_array_of_strings(ptr, count_ptr)
+    end
+
+    def predecessors_of(v)
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_predecessors_of(@wrapped, v, count_ptr)
+      ptr_to_array_of_strings(ptr, count_ptr)
+    end
+
+    def direct_successors_of(v)
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_direct_successors_of(@wrapped, v, count_ptr)
+      ptr_to_array_of_strings(ptr, count_ptr)
+    end
+
+    def successors_of(v)
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_successors_of(@wrapped, v, count_ptr)
+      ptr_to_array_of_strings(ptr, count_ptr)
+    end
+
+    def vertices
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_vertices(@wrapped, count_ptr)
+      ptr_to_array_of_u32_tuples(ptr, count_ptr)
+    end
+
+    def edges
+      count_ptr = new_count_ptr
+      ptr = NanocRust::FFI.digraph_edges(@wrapped, count_ptr)
+      ptr_to_array_of_u32_tuples(ptr, count_ptr)
+    end
+
+    def props_for(v1, v2)
+      idx = NanocRust::FFI.digraph_props_for(@wrapped, v1, v2)
+      @_props[idx]
+    end
+
+    private
+
+    def new_count_ptr
+      ::FFI::MemoryPointer.new(:size_t, 1)
+    end
+
+    def ptr_to_array_of_strings(ptr, count_ptr)
+      # Read count
+      count = count_ptr.read_uint32
+
+      # Read strings
+      string_ptrs = ptr.read_array_of_pointer(count)
+      strings = string_ptrs.map(&:read_string)
+
+      # Deallocate
+      string_ptrs.each { |s| NanocRust::FFI.drop_string(s) }
+      NanocRust::FFI.drop_array(ptr, count)
+
+      strings
+    end
+
+    def ptr_to_array_of_u32_tuples(ptr, count_ptr)
+      # Read count
+      count = count_ptr.read_uint32
+
+      # Read edges
+      edges_ptr = ::FFI::Pointer.new(NanocRust::FFI::Edge, ptr)
+      edges = (0...count).map { |i| NanocRust::FFI::Edge.new(edges_ptr[i]).to_a(@_props) }
+
+      # Deallocate
+      NanocRust::FFI.drop_array(ptr, count)
+
+      edges
+    end
+  end
+
+  def self.activate!
+    Nanoc::Int.send(:remove_const, 'DirectedGraph') if Nanoc::Int.const_defined?('DirectedGraph')
+    Nanoc::Int.const_set('DirectedGraph', NanocRust::DirectedGraph)
+  end
+end

data/nanoc-rust.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name        = 'nanoc-rust'
+  s.version     = '0.1'
+  s.homepage    = 'http://nanoc.ws/'
+  s.summary     = 'Faster bits for Nanoc'
+  s.description = 'Contains parts of Nanoc rewritten in Rust for speed'
+
+  s.author  = 'Denis Defreyne'
+  s.email   = 'denis@stoneship.org'
+  s.license = 'MIT'
+
+  s.files              = `git ls-files -z`.split("\x0")
+  s.require_paths      = ['lib']
+
+  s.required_ruby_version = '>= 2.3.0'
+
+  s.extensions = Dir['rust/extconf.rb']
+
+  s.add_runtime_dependency('ffi', '~> 1.9')
+  s.add_development_dependency('bundler', '~> 1.15')
+end

data/rust/Cargo.lock

@@ -0,0 +1,4 @@
+[root]
+name = "nanoc_rust"
+version = "0.1.0"
+

data/rust/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "nanoc_rust"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]

data/rust/Makefile

@@ -0,0 +1,15 @@
+default: build
+
+test:
+	cargo test
+
+build:
+	cargo build --release
+	mkdir -p dist
+	[ -f target/release/libnanoc_rust.dylib ] && cp target/release/libnanoc_rust.dylib dist || true
+	[ -f target/release/libnanoc_rust.so ] && cp target/release/libnanoc_rust.so dist || true
+
+clean:
+	rm -rf target dist
+
+install:

data/rust/extconf.rb

@@ -0,0 +1,3 @@
+unless system('cargo --version') && system('rustc --version')
+  raise 'Cannot find rustc/cargo; please install Rust (https://www.rust-lang.org/)'
+end

data/rust/src/digraph.rs

@@ -0,0 +1,336 @@
+use std::collections::HashMap;
+use std::collections::hash_set;
+use std::collections::HashSet;
+use std::hash::Hash;
+use std::fmt::Debug;
+
+pub struct DirectedGraph<T: Eq + Hash> {
+    indices: HashMap<T, u32>,
+    next_index: u32,
+
+    vertices: HashSet<T>,
+
+    froms: HashMap<T, HashSet<T>>,
+    tos: HashMap<T, HashSet<T>>,
+
+    edge_props: HashMap<(T, T), u32>,
+
+    empty: HashSet<T>,
+}
+
+type VertexIter<'a, T> = hash_set::Iter<'a, T>;
+
+// TODO: Move to nanoc_rust.rs
+#[repr(C)]
+pub struct Edge {
+    from: u32,
+    to: u32,
+    props: u32,
+}
+
+impl<T: Eq + Hash + Clone + Debug> DirectedGraph<T> {
+    pub fn new() -> Self {
+        DirectedGraph {
+            indices: HashMap::new(),
+            next_index: 0,
+
+            froms: HashMap::new(),
+            tos: HashMap::new(),
+
+            edge_props: HashMap::new(),
+
+            vertices: HashSet::new(),
+
+            empty: HashSet::new(),
+        }
+    }
+
+    // Modifying
+
+    pub fn add_vertex(&mut self, v: T) {
+        self.vertices.insert(v.clone());
+        self.indices.entry(v).or_insert(self.next_index);
+        self.next_index += 1;
+    }
+
+    pub fn add_edge(&mut self, v1: T, v2: T, props: u32) {
+        self.add_vertex(v1.clone());
+        self.add_vertex(v2.clone());
+
+        self.edge_props.insert((v1.clone(), v2.clone()), props);
+
+        self.tos.entry(v2.clone()).or_insert(HashSet::new()).insert(v1.clone());
+        self.froms.entry(v1).or_insert(HashSet::new()).insert(v2);
+    }
+
+    pub fn delete_edges_to(&mut self, v: T) {
+        if let Some(mut tos) = self.tos.get_mut(&v) {
+            for to in tos.iter() {
+                self.edge_props.remove(&(to.clone(), v.clone()));
+            }
+
+            tos.clear();
+        }
+
+        for (_, mut froms) in &mut self.froms {
+            froms.remove(&v);
+        }
+    }
+
+    // Querying
+
+    pub fn props_for(&self, v1: T, v2: T) -> u32 {
+        let p: Option<&u32> = self.edge_props.get(&(v1, v2));
+        if let Some(v) = p.cloned() {
+            v
+        } else {
+            0
+        }
+    }
+
+    pub fn vertices_iter(&self) -> VertexIter<T> {
+        self.vertices.iter()
+    }
+
+    pub fn edges(&self) -> Vec<Edge> {
+        let mut res: Vec<Edge> = Vec::new();
+
+        let vertices = self.vertices_iter().collect::<Vec<_>>();
+        for from in vertices {
+            for to in self.direct_successors_of(from.clone()) {
+                res.push(Edge {
+                    from: *self.indices.get(&from).unwrap(),
+                    to: *self.indices.get(&to).unwrap(),
+                    props: self.props_for(from.clone(), to.clone()),
+                });
+            }
+        }
+
+        res
+    }
+
+    pub fn direct_successors_of(&self, v: T) -> VertexIter<T> {
+        let froms = self.froms.get(&v);
+        if let Some(froms) = froms {
+            froms.iter()
+        } else {
+            self.empty.iter()
+        }
+    }
+
+    pub fn direct_predecessors_of(&self, v: T) -> VertexIter<T> {
+        let tos = self.tos.get(&v);
+        if let Some(tos) = tos {
+            tos.iter()
+        } else {
+            self.empty.iter()
+        }
+    }
+
+    pub fn successors_of(&self, v: T) -> Vec<T> {
+        let mut all_vertices: HashSet<T> = HashSet::new();
+
+        let mut processed_vertices: HashSet<T> = HashSet::new();
+        let mut unprocessed_vertices: Vec<T> = vec![v];
+
+        while let Some(vertex) = unprocessed_vertices.pop() {
+            // Get next unprocessed vertex
+            if processed_vertices.contains(&vertex) {
+                continue;
+            }
+            processed_vertices.insert(vertex.clone());
+
+            // Add successors of this vertex
+            for v in self.direct_successors_of(vertex) {
+                all_vertices.insert(v.clone());
+                unprocessed_vertices.push(v.clone());
+            }
+        }
+
+        return all_vertices.iter().cloned().collect::<Vec<_>>();
+    }
+
+    pub fn predecessors_of(&self, v: T) -> Vec<T> {
+        let mut all_vertices: HashSet<T> = HashSet::new();
+
+        let mut processed_vertices: HashSet<T> = HashSet::new();
+        let mut unprocessed_vertices: Vec<T> = vec![v];
+
+        while let Some(vertex) = unprocessed_vertices.pop() {
+            // Get next unprocessed vertex
+            if processed_vertices.contains(&vertex) {
+                continue;
+            }
+            processed_vertices.insert(vertex.clone());
+
+            // Add predecessors of this vertex
+            for v in self.direct_predecessors_of(vertex) {
+                all_vertices.insert(v.clone());
+                unprocessed_vertices.push(v.clone());
+            }
+        }
+
+        return all_vertices.iter().cloned().collect::<Vec<_>>();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fmt::Debug;
+    use std::iter::IntoIterator;
+
+    macro_rules! assert_iters_eq {
+        ( $a:expr, $b:expr ) => {{
+            match ($a, $b) {
+                (a, b) => {
+                    let mut v1 = a.collect::<Vec<_>>();
+                    let mut v2 = b.collect::<Vec<_>>();
+
+                    v1.sort();
+                    v2.sort();
+
+                    assert_eq!(v1, v2);
+                }
+            }
+        }}
+    }
+
+    fn assert_empty<I, T: Debug + Ord>(c: I)
+    where
+        I: IntoIterator<Item = T>,
+    {
+        assert_eq!(0, c.into_iter().collect::<Vec<_>>().len());
+    }
+
+    #[test]
+    fn new_digraph_is_empty() {
+        let dg: DirectedGraph<i32> = DirectedGraph::new();
+
+        assert_empty(dg.vertices_iter());
+
+        assert_empty(dg.direct_successors_of(0));
+        assert_empty(dg.direct_successors_of(1));
+        assert_empty(dg.direct_successors_of(2));
+        assert_empty(dg.direct_successors_of(3));
+
+        assert_empty(dg.direct_predecessors_of(0));
+        assert_empty(dg.direct_predecessors_of(1));
+        assert_empty(dg.direct_predecessors_of(2));
+        assert_empty(dg.direct_predecessors_of(3));
+    }
+
+    #[test]
+    fn add_new_vertex() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_vertex(1);
+
+        assert_eq!(1, dg.vertices_iter().len());
+        assert_iters_eq!(vec![1].iter(), dg.vertices_iter());
+
+        assert_empty(dg.direct_successors_of(0));
+        assert_empty(dg.direct_successors_of(1));
+        assert_empty(dg.direct_successors_of(2));
+        assert_empty(dg.direct_successors_of(3));
+
+        assert_empty(dg.direct_predecessors_of(0));
+        assert_empty(dg.direct_predecessors_of(1));
+        assert_empty(dg.direct_predecessors_of(2));
+        assert_empty(dg.direct_predecessors_of(3));
+    }
+
+    #[test]
+    fn add_existing_vertex() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_vertex(1);
+        dg.add_vertex(1);
+
+        assert_eq!(1, dg.vertices_iter().len());
+        assert_iters_eq!(vec![1].iter(), dg.vertices_iter());
+
+        assert_empty(dg.direct_successors_of(0));
+        assert_empty(dg.direct_successors_of(1));
+        assert_empty(dg.direct_successors_of(2));
+        assert_empty(dg.direct_successors_of(3));
+
+        assert_empty(dg.direct_predecessors_of(0));
+        assert_empty(dg.direct_predecessors_of(1));
+        assert_empty(dg.direct_predecessors_of(2));
+        assert_empty(dg.direct_predecessors_of(3));
+    }
+
+    #[test]
+    fn add_multiple_vertices() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_vertex(1);
+        dg.add_vertex(3);
+
+        assert_eq!(2, dg.vertices_iter().len());
+        assert_iters_eq!(vec![1, 3].iter(), dg.vertices_iter());
+
+        assert_empty(dg.direct_successors_of(0));
+        assert_empty(dg.direct_successors_of(1));
+        assert_empty(dg.direct_successors_of(2));
+        assert_empty(dg.direct_successors_of(3));
+
+        assert_empty(dg.direct_predecessors_of(0));
+        assert_empty(dg.direct_predecessors_of(1));
+        assert_empty(dg.direct_predecessors_of(2));
+        assert_empty(dg.direct_predecessors_of(3));
+    }
+
+    #[test]
+    fn add_edges_has_vertices() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_edge(1, 2);
+        dg.add_edge(1, 3);
+
+        assert_eq!(3, dg.vertices_iter().len());
+        assert_iters_eq!(vec![1, 2, 3].iter(), dg.vertices_iter());
+    }
+
+    #[test]
+    fn add_edges_has_successors_and_predecessors() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_edge(1, 2);
+        dg.add_edge(1, 3);
+
+        // 0
+        assert_empty(dg.direct_successors_of(0));
+        assert_empty(dg.direct_predecessors_of(0));
+
+        // 1
+        assert_iters_eq!(vec![2, 3].iter(), dg.direct_successors_of(1));
+        assert_empty(dg.direct_predecessors_of(1));
+
+        // 2
+        assert_empty(dg.direct_successors_of(2));
+        assert_iters_eq!(vec![1].iter(), dg.direct_predecessors_of(2));
+
+        // 3
+        assert_empty(dg.direct_successors_of(3));
+        assert_iters_eq!(vec![1].iter(), dg.direct_predecessors_of(3));
+    }
+
+    #[test]
+    fn delete_edges_to() {
+        let mut dg: DirectedGraph<i32> = DirectedGraph::new();
+        dg.add_edge(0, 1);
+        dg.add_edge(0, 2);
+        dg.add_edge(0, 3);
+        dg.add_edge(1, 2);
+        dg.add_edge(1, 3);
+        dg.add_edge(2, 3);
+        dg.delete_edges_to(1);
+
+        assert_iters_eq!(vec![2, 3].iter(), dg.direct_successors_of(0));
+        assert_iters_eq!(vec![2, 3].iter(), dg.direct_successors_of(1));
+        assert_iters_eq!(vec![3].iter(), dg.direct_successors_of(2));
+        assert_empty(dg.direct_successors_of(3));
+
+        assert_empty(dg.direct_predecessors_of(0));
+        assert_empty(dg.direct_predecessors_of(1));
+        assert_iters_eq!(vec![0, 1].iter(), dg.direct_predecessors_of(2));
+        assert_iters_eq!(vec![0, 1, 2].iter(), dg.direct_predecessors_of(3));
+    }
+}

data/rust/src/nanoc_rust.rs

@@ -0,0 +1,191 @@
+#![feature(libc)]
+
+extern crate libc;
+
+mod digraph;
+
+pub mod ffi {
+    use digraph::{DirectedGraph, Edge};
+
+    use libc::c_char;
+    use std::ffi::{CStr, CString};
+    use std::fmt::{Debug, Error, Formatter};
+    use std::mem;
+    use std::ptr;
+
+    type R = *const c_char;
+    type T = Vec<u8>;
+    type D = DirectedGraph<T>;
+
+    impl Debug for D {
+        fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+            write!(f, "Nanoc::Int::DirectedGraph(")?;
+
+            let mut idx = 0;
+            let mut vertices = self.vertices_iter().collect::<Vec<_>>();
+            vertices.sort();
+            for from in vertices {
+                for to in self.direct_successors_of(from.clone()) {
+                    if idx > 0 {
+                        write!(f, ", ")?;
+                    }
+
+                    write!(
+                        f,
+                        "{:?} -> {:?} props=nil",
+                        String::from_utf8_lossy(&*from.clone()),
+                        String::from_utf8_lossy(&*to.clone()),
+                    )?;
+
+                    idx += 1;
+                }
+            }
+
+            write!(f, ")")?;
+            Ok(())
+        }
+    }
+
+    // Converting raw <-> actual
+
+    fn r2t(r: R) -> T {
+        unsafe {
+            if r.is_null() {
+                vec![]
+            } else {
+                CStr::from_ptr(r).to_bytes().to_vec()
+            }
+        }
+    }
+
+    fn t2r(t: T) -> R {
+        unsafe {
+            if t.is_empty() {
+                ptr::null()
+            } else {
+                let cs = CString::from_vec_unchecked(t);
+                let ptr = cs.as_ptr();
+                mem::forget(cs);
+                ptr
+            }
+        }
+    }
+
+    // drop
+
+    #[no_mangle]
+    pub extern "C" fn drop_string(ptr: *mut c_char) {
+        unsafe { CString::from_raw(ptr); }
+    }
+
+    #[no_mangle]
+    pub extern "C" fn drop_array(ptr: *mut *mut c_char, length: usize) {
+        unsafe { Vec::<*mut c_char>::from_raw_parts(ptr, length, length); };
+    }
+
+    // create+destroy
+
+    #[no_mangle]
+    pub extern "C" fn digraph_create() -> Box<D> {
+        Box::new(DirectedGraph::new())
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_destroy(dg: &mut D) {
+        mem::drop(dg);
+    }
+
+    // query
+
+    #[no_mangle]
+    pub extern "C" fn digraph_inspect(dg: &D) -> R {
+        let s = format!("{:?}", dg);
+        CString::new(s).unwrap().into_raw()
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_props_for(dg: &D, v1: R, v2: R) -> u32 {
+        dg.props_for(r2t(v1), r2t(v2))
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_edges(dg: &D, out_count: *mut usize) -> *const Edge {
+        let mut vec = dg.edges();
+        vec.shrink_to_fit();
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_vertices(dg: &D, out_count: *mut usize) -> *const R {
+        let mut vec: Vec<R> = dg.vertices_iter().cloned().map(|a| t2r(a)).collect();
+        vec.shrink_to_fit();
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_direct_predecessors_of(dg: &D, v: R, out_count: *mut usize) -> *const R {
+        let mut vec: Vec<R> = dg.direct_predecessors_of(r2t(v)).cloned().map(|a| t2r(a)).collect();
+        vec.shrink_to_fit();
+
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_predecessors_of(dg: &D, v: R, out_count: *mut usize) -> *const R {
+        let mut vec: Vec<R> = dg.predecessors_of(r2t(v)).iter().cloned().map(|a| t2r(a)).collect();
+        vec.shrink_to_fit();
+
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_direct_successors_of(dg: &D, v: R, out_count: *mut usize) -> *const R {
+        let mut vec: Vec<R> = dg.direct_successors_of(r2t(v)).cloned().map(|a| t2r(a)).collect();
+        vec.shrink_to_fit();
+
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_successors_of(dg: &D, v: R, out_count: *mut usize) -> *const R {
+        let mut vec: Vec<R> = dg.successors_of(r2t(v)).iter().cloned().map(|a| t2r(a)).collect();
+        vec.shrink_to_fit();
+
+        let ptr = vec.as_ptr();
+        unsafe { ptr::write(out_count, vec.len()); };
+        mem::forget(vec);
+        ptr
+    }
+
+    // mutate
+
+    #[no_mangle]
+    pub extern "C" fn digraph_add_vertex(dg: &mut D, v: R) {
+        dg.add_vertex(r2t(v))
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_add_edge(dg: &mut D, v1: R, v2: R, p: u32) {
+        dg.add_edge(r2t(v1), r2t(v2), p)
+    }
+
+    #[no_mangle]
+    pub extern "C" fn digraph_delete_edges_to(dg: &mut D, v: R) {
+        dg.delete_edges_to(r2t(v));
+    }
+}

data/spec/directed_graph_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+describe NanocRust::DirectedGraph do
+  subject(:graph) { described_class.new(%w[1 2 3]) }
+
+  describe '#edges' do
+    subject { graph.edges }
+
+    context 'empty graph' do
+      it { is_expected.to be_empty }
+    end
+
+    context 'graph with vertices, but no edges' do
+      before do
+        graph.add_vertex('1')
+        graph.add_vertex('2')
+      end
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'graph with edges from previously added vertices' do
+      before do
+        graph.add_vertex('1')
+        graph.add_vertex('2')
+        graph.add_vertex('3')
+
+        graph.add_edge('1', '2')
+        graph.add_edge('1', '3')
+      end
+
+      it { is_expected.to match_array([[0, 1, nil], [0, 2, nil]]) }
+    end
+
+    context 'graph with edges from new vertices' do
+      before do
+        graph.add_edge('1', '2')
+        graph.add_edge('1', '3')
+      end
+
+      it { is_expected.to match_array([[0, 1, nil], [0, 2, nil]]) }
+    end
+
+    context 'graph with edge props' do
+      before do
+        graph.add_edge('1', '2', props: { name: 'Mr. C' })
+        graph.add_edge('1', '3', props: { name: 'Cooper' })
+      end
+
+      it { is_expected.to match_array([[0, 1, { name: 'Mr. C' }], [0, 2, { name: 'Cooper' }]]) }
+    end
+  end
+
+  describe '#props_for' do
+    subject { graph.props_for('1', '2') }
+
+    context 'no edge' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'edge, but no props' do
+      before { graph.add_edge('1', '2') }
+      it { is_expected.to be_nil }
+    end
+
+    context 'edge with props' do
+      before { graph.add_edge('1', '2', props: { name: 'Mr. C' }) }
+      it { is_expected.to eq(name: 'Mr. C') }
+
+      context 'deleted edge (#delete_edges_to)' do
+        before { graph.delete_edges_to('2') }
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe '#direct_predecessors_of' do
+    subject { graph.direct_predecessors_of('2') }
+
+    context 'no edges' do
+      it { is_expected.to be_empty }
+    end
+
+    context 'one edge to' do
+      before { graph.add_edge('1', '2') }
+      it { is_expected.to eq(['1']) }
+    end
+
+    context 'two edges to' do
+      before do
+        graph.add_edge('1', '2')
+        graph.add_edge('3', '2')
+      end
+
+      it { is_expected.to match_array(%w[1 3]) }
+    end
+
+    context 'edge from' do
+      before { graph.add_edge('2', '3') }
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '#direct_successors_of' do
+    subject { graph.direct_successors_of('2') }
+
+    context 'no edges' do
+      it { is_expected.to be_empty }
+    end
+
+    context 'one edge to' do
+      before { graph.add_edge('1', '2') }
+      it { is_expected.to be_empty }
+    end
+
+    context 'one edge from' do
+      before { graph.add_edge('2', '3') }
+      it { is_expected.to eq(['3']) }
+    end
+
+    context 'two edges from' do
+      before do
+        graph.add_edge('2', '1')
+        graph.add_edge('2', '3')
+      end
+
+      it { is_expected.to match_array(%w[1 3]) }
+    end
+  end
+
+  describe '#predecessors_of' do
+    subject { graph.predecessors_of('2') }
+
+    context 'no predecessors' do
+      before do
+        graph.add_edge('2', '3')
+      end
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'direct predecessor' do
+      before do
+        graph.add_edge('2', '3')
+        graph.add_edge('1', '2')
+      end
+
+      context 'no indirect predecessors' do
+        it { is_expected.to match_array(['1']) }
+      end
+
+      context 'indirect predecessors' do
+        before { graph.add_edge('3', '1') }
+        it { is_expected.to match_array(%w[1 2 3]) }
+      end
+    end
+  end
+
+  describe '#successors_of' do
+    subject { graph.successors_of('2') }
+
+    context 'no successors' do
+      before do
+        graph.add_edge('1', '2')
+      end
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'direct predecessor' do
+      before do
+        graph.add_edge('1', '2')
+        graph.add_edge('2', '3')
+      end
+
+      context 'no indirect successors' do
+        it { is_expected.to match_array(['3']) }
+      end
+
+      context 'indirect successors' do
+        before { graph.add_edge('3', '1') }
+        it { is_expected.to match_array(%w[1 2 3]) }
+      end
+    end
+  end
+
+  describe '#inspect' do
+    subject { graph.inspect }
+
+    context 'empty graph' do
+      it { is_expected.to eq('Nanoc::Int::DirectedGraph()') }
+    end
+
+    context 'one edge, no props' do
+      before do
+        graph.add_edge('1', '2')
+      end
+
+      it { is_expected.to eq('Nanoc::Int::DirectedGraph("1" -> "2" props=nil)') }
+    end
+
+    context 'two edges, no props' do
+      before do
+        graph.add_edge('1', '2')
+        graph.add_edge('2', '3')
+      end
+
+      it { is_expected.to eq('Nanoc::Int::DirectedGraph("1" -> "2" props=nil, "2" -> "3" props=nil)') }
+    end
+
+    context 'one edge, props' do
+      before do
+        graph.add_edge('1', '2', props: 'giraffe')
+      end
+
+      it { is_expected.to eq('Nanoc::Int::DirectedGraph("1" -> "2" props="giraffe")') }
+    end
+
+    context 'two edges, props' do
+      before do
+        graph.add_edge('1', '2', props: 'donkey')
+        graph.add_edge('2', '3', props: 'zebra')
+      end
+
+      it { is_expected.to eq('Nanoc::Int::DirectedGraph("1" -> "2" props="donkey", "2" -> "3" props="zebra")') }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rspec/its'
+require 'fuubar'
+
+require 'nanoc-rust'
+
+RSpec.configure do |c|
+  c.fuubar_progress_bar_options = {
+    format: '%c/%C |<%b>%i| %p%%',
+  }
+end

data/test.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+make -C rust test
+gem build nanoc-rust.gemspec
+gem uninstall -x nanoc-rust
+gem install nanoc-rust-0.1.gem
+ruby bin/nanoc-rust

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: nanoc-rust
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Denis Defreyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Contains parts of Nanoc rewritten in Rust for speed
+email: denis@stoneship.org
+executables: []
+extensions:
+- rust/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/nanoc-rust.rb
+- nanoc-rust.gemspec
+- rust/Cargo.lock
+- rust/Cargo.toml
+- rust/Makefile
+- rust/extconf.rb
+- rust/src/digraph.rs
+- rust/src/nanoc_rust.rs
+- spec/directed_graph_spec.rb
+- spec/spec_helper.rb
+- test.sh
+homepage: http://nanoc.ws/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Faster bits for Nanoc
+test_files: []