bindgen/template/*, fix #no_op?, do_block doc

Author: HertzDevil

spec/bindgen/template_spec.cr

@@ -23,6 +23,11 @@ describe "Template" do
       Bindgen::Template::None.new.no_op?.should be_true
     end
 
+    it "returns true for string templates with only `%`" do
+      Bindgen::Template::Basic.new("%").no_op?.should be_true
+      Bindgen::Template::Basic.new("%", simple: true).no_op?.should be_true
+    end
+
     it "returns false for any other templates" do
       conversion1 = Bindgen::Template::Basic.new("%x")
       conversion2 = Bindgen::Template::Basic.new("%x", simple: true)

src/bindgen/call_builder/crystal_from_cpp.cr

@@ -6,6 +6,11 @@ module Bindgen
       end
 
       # Calls the *method*, using the *proc_name* to call-through to Crystal.
+      #
+      # If `do_block` is true, the generated `Proc` expression will use
+      # `do ... end` instead of `{ ... }`.  This allows embedding the code body
+      # inside a string conversion template, without the code block being
+      # interpreted as an environment variable (see also `Template::Basic`).
       def build(method : Parser::Method, receiver = "self", do_block = false) : Call
         pass = Crystal::Pass.new(@db)
         argument = Crystal::Argument.new(@db)

src/bindgen/template.cr

@@ -1,3 +1,5 @@
+require "./template/*"
+
 module Bindgen
   # Conversion templates for `Call::Result`.  They govern how a call result's
   # code should be transformed to become usable under a certain platform.
@@ -12,116 +14,5 @@ module Bindgen
         Basic.new(pattern, simple: simple)
       end
     end
-
-    # Base class of the templates.
-    abstract class Base
-      # Performs a template substitution.
-      abstract def template(code : String) : String
-
-      # Is this a no-operation template?
-      def no_op?
-        {{ @type == Bindgen::Template::None }}
-      end
-
-      # Combines two templates into one.  The *other* template is run after the
-      # current template.
-      def followed_by(other : Base) : Base
-        return other if no_op?
-        return self if other.no_op?
-        Sequence.new(self, other)
-      end
-    end
-
-    # The no-op template that returns *code* unmodified.
-    class None < Base
-      def template(code) : String
-        code
-      end
-
-      def ==(_other : self)
-        true
-      end
-    end
-
-    # The default template.  Uses `Util.template` to substitute *code* into the
-    # given *pattern*.
-    #
-    # If *simple* is given, the template will only use a subset of the features;
-    # `%` performs substitution, whereas the escape sequence `%%` outputs a
-    # literal percent sign.
-    class Basic < Base
-      def initialize(@pattern : String, @simple = false)
-      end
-
-      def template(code) : String
-        if @simple
-          @pattern.gsub(/%+/) do |m|
-            literals = "%" * (m.size // 2)
-            out_code = code if m.size % 2 == 1
-            "#{literals}#{out_code}"
-          end
-        else
-          Util.template(@pattern, code)
-        end
-      end
-
-      def_equals @pattern, @simple
-    end
-
-    # Compound template which runs *code* through multiple child templater, in
-    # the order they are given in the constructor.
-    class Sequence < Base
-      getter children = Array(Base).new
-
-      def initialize(*conversions : Base)
-        conversions.each do |conversion|
-          # Flatten `Sequence` templates automatically.
-          if conversion.is_a?(Sequence)
-            @children.concat(conversion.children)
-          else
-            @children << conversion
-          end
-        end
-      end
-
-      def template(code) : String
-        @children.each do |conversion|
-          code = conversion.template(code)
-        end
-
-        code
-      end
-
-      def_equals @children
-    end
-
-    # Template to transform `Proc`s for Crystal wrapper types into `Proc`
-    # expressions for binding types.
-    class ProcFromWrapper < Base
-      def initialize(@proc_type : Parser::Type, @db : TypeDatabase)
-      end
-
-      def template(code) : String
-        args = @proc_type.template.not_nil!.arguments
-        func_args = args[1..-1].map_with_index do |type, i|
-          Parser::Argument.new("arg#{i}", type)
-        end
-        proc_call = Parser::Method.build(
-          name: "call",
-          return_type: args.first,
-          arguments: func_args,
-          class_name: "Proc",
-        )
-
-        # The templated code shouldn't contain braces, since an outer template
-        # that comes from a config file might treat the code block as an
-        # environment variable.
-        builder = CallBuilder::CrystalFromCpp.new(@db)
-        call = builder.build(proc_call, receiver: "_proc_", do_block: true)
-        call.body.to_code(call, Graph::Platform::Crystal)
-      end
-
-      def_equals @proc_type, @db
-    end
   end
 end

src/bindgen/template/base.cr

@@ -0,0 +1,20 @@
+module Bindgen
+  module Template
+    # Base class of the templates.
+    abstract class Base
+      # Performs a template substitution.
+      abstract def template(code : String) : String
+
+      # Is this a no-operation template?
+      abstract def no_op? : Bool
+
+      # Combines two templates into one.  The *other* template is run after the
+      # current template.
+      def followed_by(other : Base) : Base
+        return other if no_op?
+        return self if other.no_op?
+        Sequence.new(self, other)
+      end
+    end
+  end
+end

src/bindgen/template/basic.cr

@@ -0,0 +1,32 @@
+module Bindgen
+  module Template
+    # The default template.  Uses `Util.template` to substitute *code* into the
+    # given *pattern*.
+    #
+    # If *simple* is given, the template will only use a subset of the features;
+    # `%` performs substitution, whereas the escape sequence `%%` outputs a
+    # literal percent sign.
+    class Basic < Base
+      def initialize(@pattern : String, @simple = false)
+      end
+
+      def no_op? : Bool
+        @pattern == "%"
+      end
+
+      def template(code) : String
+        if @simple
+          @pattern.gsub(/%+/) do |m|
+            literals = "%" * (m.size // 2)
+            out_code = code if m.size % 2 == 1
+            "#{literals}#{out_code}"
+          end
+        else
+          Util.template(@pattern, code)
+        end
+      end
+
+      def_equals @pattern, @simple
+    end
+  end
+end

src/bindgen/template/none.cr

@@ -0,0 +1,18 @@
+module Bindgen
+  module Template
+    # The no-op template that returns *code* unmodified.
+    class None < Base
+      def no_op? : Bool
+        true
+      end
+
+      def template(code) : String
+        code
+      end
+
+      def ==(_other : self)
+        true
+      end
+    end
+  end
+end

src/bindgen/template/proc_from_wrapper.cr

@@ -0,0 +1,33 @@
+module Bindgen
+  module Template
+    # Custom template to transform `Proc`s for Crystal wrapper types into `Proc`
+    # expressions for binding types.
+    class ProcFromWrapper < Base
+      def initialize(@proc_type : Parser::Type, @db : TypeDatabase)
+      end
+
+      def no_op? : Bool
+        false
+      end
+
+      def template(code) : String
+        args = @proc_type.template.not_nil!.arguments
+        func_args = args[1..-1].map_with_index do |type, i|
+          Parser::Argument.new("arg#{i}", type)
+        end
+        proc_call = Parser::Method.build(
+          name: "call",
+          return_type: args.first,
+          arguments: func_args,
+          class_name: "Proc",
+        )
+
+        builder = CallBuilder::CrystalFromCpp.new(@db)
+        call = builder.build(proc_call, receiver: "_proc_", do_block: true)
+        call.body.to_code(call, Graph::Platform::Crystal)
+      end
+
+      def_equals @proc_type, @db
+    end
+  end
+end

src/bindgen/template/sequence.cr

@@ -0,0 +1,36 @@
+module Bindgen
+  module Template
+    # Compound template which runs *code* through multiple child templates, in
+    # the order they are given in the constructor.
+    class Sequence < Base
+      getter children = Array(Base).new
+      getter? no_op : Bool = true
+
+      def initialize(*conversions : Base)
+        conversions.each do |conversion|
+          # Flatten `Sequence` templates automatically.
+          if conversion.is_a?(Sequence)
+            @children.concat(conversion.children)
+          else
+            @children << conversion
+          end
+
+          # `Sequence` templates returned by `#followed_by` are by construction
+          # never no-op, but we'll compute this in case `Sequence` is manually
+          # created.
+          @no_op &&= conversion.no_op?
+        end
+      end
+
+      def template(code) : String
+        @children.each do |conversion|
+          code = conversion.template(code)
+        end
+
+        code
+      end
+
+      def_equals @children
+    end
+  end
+end