org.asciidoctor.extension.BlockMacroProcessor Java Examples

public static RubyClass register(final JRubyAsciidoctor asciidoctor, final Class<? extends BlockMacroProcessor> blockMacroProcessor) {
    RubyClass rubyClass = ProcessorProxyUtil.defineProcessorClass(asciidoctor.getRubyRuntime(), "BlockMacroProcessor", new JRubyAsciidoctorObjectAllocator(asciidoctor) {
        @Override
        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
            return new BlockMacroProcessorProxy(asciidoctor, klazz, blockMacroProcessor);
        }
    });

    applyAnnotations(blockMacroProcessor, rubyClass);

    ProcessorProxyUtil.defineAnnotatedMethods(rubyClass, BlockMacroProcessorProxy.class);
    return rubyClass;
}
 

public static RubyClass register(final JRubyAsciidoctor asciidoctor, final BlockMacroProcessor blockMacroProcessor) {
    RubyClass rubyClass = ProcessorProxyUtil.defineProcessorClass(asciidoctor.getRubyRuntime(), "BlockMacroProcessor", new JRubyAsciidoctorObjectAllocator(asciidoctor) {
        @Override
        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
            return new BlockMacroProcessorProxy(asciidoctor, klazz, blockMacroProcessor);
        }
    });

    applyAnnotations(blockMacroProcessor.getClass(), rubyClass);

    ProcessorProxyUtil.defineAnnotatedMethods(rubyClass, BlockMacroProcessorProxy.class);
    return rubyClass;
}
 

@Override
public ExtensionGroup blockMacro(final String blockName, final Class<? extends BlockMacroProcessor> blockMacroProcessor) {
  final RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
  registrators.add(new Registrator() {
    @Override
    public void register(IRubyObject registry) {
      registry.callMethod(rubyRuntime.getCurrentContext(), "block_macro", new IRubyObject[]{rubyClass, rubyRuntime.newSymbol(blockName)});
    }
  });
  return this;
}
 

@Override
public ExtensionGroup blockMacro(final Class<? extends BlockMacroProcessor> blockMacroProcessor) {
  final RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
  registrators.add(new Registrator() {
    @Override
    public void register(IRubyObject registry) {
      registry.callMethod(rubyRuntime.getCurrentContext(), "block_macro", new IRubyObject[]{rubyClass, rubyRuntime.newSymbol(AbstractProcessorProxy.getName(blockMacroProcessor))});
    }
  });
  return this;
}
 

@Override
public ExtensionGroup blockMacro(final String blockName, final String blockMacroProcessor) {
  try {
    Class<? extends BlockMacroProcessor>  blockMacroProcessorClass = (Class<? extends BlockMacroProcessor>) Class.forName(blockMacroProcessor);
    return blockMacro(blockName, blockMacroProcessorClass);
  } catch (ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}
 

@Override
public ExtensionGroup blockMacro(final String blockMacroProcessor) {
  try {
    Class<? extends BlockMacroProcessor>  blockMacroProcessorClass = (Class<? extends BlockMacroProcessor>) Class.forName(blockMacroProcessor);
    return blockMacro(blockMacroProcessorClass);
  } catch (ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}
 

@Override
public ExtensionGroup blockMacro(final BlockMacroProcessor blockMacroProcessor) {
  final RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
  registrators.add(new Registrator() {
    @Override
    public void register(IRubyObject registry) {
      registry.callMethod(rubyRuntime.getCurrentContext(), "block_macro", new IRubyObject[]{rubyClass, rubyRuntime.newSymbol(blockMacroProcessor.getName())});
    }
  });
  return this;
}
 

@Override
public JavaExtensionRegistry blockMacro(String blockName,
                                        Class<? extends BlockMacroProcessor> blockMacroProcessor) {
    RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
    getAsciidoctorModule().callMethod("block_macro", rubyClass, rubyRuntime.newString(blockName));
    return this;
}
 

@Override
public JavaExtensionRegistry blockMacro(Class<? extends BlockMacroProcessor> blockMacroProcessor) {
    String name = getName(blockMacroProcessor);
    RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
    getAsciidoctorModule().callMethod("block_macro", rubyClass, rubyRuntime.newString(name));
    return this;
}
 

@Override
public JavaExtensionRegistry blockMacro(String blockName,
                                        String blockMacroProcessor) {
    try {
        Class<? extends BlockMacroProcessor> blockMacroProcessorClass = (Class<? extends BlockMacroProcessor>) Class.forName(blockMacroProcessor);
        blockMacro(blockName, blockMacroProcessorClass);
        return this;
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public JavaExtensionRegistry blockMacro(String blockMacroProcessor) {
    try {
        Class<? extends BlockMacroProcessor> blockMacroProcessorClass = (Class<? extends BlockMacroProcessor>) Class.forName(blockMacroProcessor);
        blockMacro(blockMacroProcessorClass);
        return this;
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
}
 

public BlockMacroProcessorProxy(JRubyAsciidoctor asciidoctor, RubyClass metaClass, Class<? extends BlockMacroProcessor> blockMacroProcessorClass) {
    super(asciidoctor, metaClass, blockMacroProcessorClass);
}
 

public BlockMacroProcessorProxy(JRubyAsciidoctor asciidoctor, RubyClass metaClass, BlockMacroProcessor blockMacroProcessor) {
    super(asciidoctor, metaClass, blockMacroProcessor);
}
 

@Override
public JavaExtensionRegistry blockMacro(BlockMacroProcessor blockMacroProcessor) {
    RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
    getAsciidoctorModule().callMethod("block_macro", rubyClass);
    return this;
}
 

@Override
public JavaExtensionRegistry blockMacro(String macroName, BlockMacroProcessor blockMacroProcessor) {
    RubyClass rubyClass = BlockMacroProcessorProxy.register(asciidoctor, blockMacroProcessor);
    getAsciidoctorModule().callMethod("block_macro", rubyClass, rubyRuntime.newString(macroName));
    return this;
}
 

@Override
@SuppressWarnings("unchecked")
public void register(String extensionClassName, String blockName) throws MojoExecutionException {

    Class<? extends Processor> clazz;
    try {
        clazz = (Class<Processor>) Class.forName(extensionClassName);
    } catch (ClassCastException cce) {
        // Use RuntimeException to avoid catching, we only want the message in the Mojo
        throw new RuntimeException("'" + extensionClassName + "' is not a valid AsciidoctorJ processor class");
    } catch (ClassNotFoundException e) {
        throw new RuntimeException("'" + extensionClassName + "' not found in classpath");
    }

    // TODO: Replace with direct method calls again as soon as this project compiles against AsciidoctorJ 1.6.0
    if (DocinfoProcessor.class.isAssignableFrom(clazz)) {
        register(javaExtensionRegistry, "docinfoProcessor", clazz);
    } else if (Preprocessor.class.isAssignableFrom(clazz)) {
        register(javaExtensionRegistry, "preprocessor", clazz);
    } else if (Postprocessor.class.isAssignableFrom(clazz)) {
        register(javaExtensionRegistry, "postprocessor", clazz);
    } else if (Treeprocessor.class.isAssignableFrom(clazz)) {
        register(javaExtensionRegistry, "treeprocessor", clazz);
    } else if (BlockProcessor.class.isAssignableFrom(clazz)) {
        if (blockName == null) {
            register(javaExtensionRegistry, "block", clazz);
        } else {
            register(javaExtensionRegistry, "block", blockName, clazz);
        }
    } else if (IncludeProcessor.class.isAssignableFrom(clazz)) {
        register(javaExtensionRegistry, "includeProcessor", clazz);
    } else if (BlockMacroProcessor.class.isAssignableFrom(clazz)) {
        if (blockName == null) {
            register(javaExtensionRegistry, "blockMacro", clazz);
        } else {
            register(javaExtensionRegistry, "blockMacro", blockName, clazz);
        }
    } else if (InlineMacroProcessor.class.isAssignableFrom(clazz)) {
        if (blockName == null) {
            register(javaExtensionRegistry, "inlineMacro", clazz);
        } else {
            register(javaExtensionRegistry, "inlineMacro", blockName, clazz);
        }
    }
}