carray-jit 0.1.2 → 0.1.3

data/lib/carray/jit/block_reader.rb

@@ -25,14 +25,16 @@ class CArray
           unless defined?(RubyVM::InstructionSequence)
             raise Unsupported,
                   "this Ruby has no RubyVM::InstructionSequence; " \
-                  "pass the kernel as `source:` instead"
+                  "compile the kernel from text with " \
+                  "`CArray::JIT.compile` instead"
           end
 
           sequence = RubyVM::InstructionSequence.of(block)
           unless sequence
             raise Unsupported,
                   "the block has no instruction sequence (defined in C?); " \
-                  "pass the kernel as `source:` instead"
+                  "compile the kernel from text with " \
+                  "`CArray::JIT.compile` instead"
           end
 
           location = code_location(sequence)
@@ -57,7 +59,8 @@ class CArray
           unless location
             raise Unsupported,
                   "this Ruby does not report a code location for blocks; " \
-                  "pass the kernel as `source:` instead"
+                  "compile the kernel from text with " \
+                  "`CArray::JIT.compile` instead"
           end
           location
         end
@@ -75,14 +78,42 @@ class CArray
 
           path = sequence.absolute_path
           if path && File.file?(path)
-            return File.read(path)
+            return read_script(path)
           end
 
           raise Unsupported,
                 "the block's source is not available " \
                 "(defined in eval or in a console?); " \
-                "pass the kernel as `source:`, or set " \
-                "RubyVM.keep_script_lines = true before defining it"
+                "set RubyVM.keep_script_lines = true before defining it, " \
+                "or compile it from text with `CArray::JIT.compile`"
+        end
+
+        # Ruby reads a source file as UTF-8 unless a magic comment says
+        # otherwise, and `Encoding.default_external` has nothing to do with
+        # it.  Reading by that is what `File.read` does, and on a machine
+        # with no locale set it hands back the file's own bytes under a
+        # US-ASCII tag -- which every later `rstrip` on a line holding a
+        # non-ASCII comment raises on.  So the bytes are read as bytes and
+        # given the encoding the parser gave them.
+        def read_script (path)
+          source = File.binread(path)
+          source.force_encoding(script_encoding(source))
+        end
+
+        # The magic comment, on the first line or on the second where a
+        # shebang takes the first -- the two places Ruby looks for it.  The
+        # word is `coding`, with no boundary before it: `# encoding: euc-jp`
+        # and `# -*- coding: utf-8 -*-` are both spellings Ruby takes.
+        def script_encoding (source)
+          head = source.byteslice(0, 1024).lines.first(2)
+          head.shift if head.first&.start_with?("#!")
+          name = head.first&.slice(/coding\s*[:=]\s*([\w.\-]+)/, 1)
+          return Encoding::UTF_8 unless name
+          begin
+            Encoding.find(name)
+          rescue ArgumentError
+            Encoding::UTF_8
+          end
         end
 
         def locate (source, location)