h8 0.2.2 → 0.2.3

data/ext/h8/ruby_gate.cpp

@@ -14,7 +14,6 @@ static void* unblock_caller(void *param) {
 }
 
 static void with_gvl(RubyGate *gate, const std::function<void(void)> &block) {
-//	v8::Unlocker unlock(gate->isolate());
 	H8 *h8 = gate->getH8();
 	if (h8->isGvlReleased()) {
 		h8->setGvlReleased(false);

data/ext/h8/ruby_gate.h

@@ -41,9 +41,7 @@ public:
 	}
 
 	virtual void free() {
-		AllocatedResource::free();
-		persistent().ClearWeak();
-		persistent().Reset();
+//		printf("RG::FREE(%p)\n", this);
 		delete this;
 	}
 
@@ -52,6 +50,10 @@ public:
 	}
 
 	virtual ~RubyGate() {
+//		puts("~RG()");
+		persistent().ClearWeak();
+		persistent().Reset();
+		// The rest is done by the base classes
 	}
 
 	Isolate* isolate() const noexcept {

data/lib/h8/coffee.rb

@@ -36,13 +36,15 @@ module H8
     # Create compiler instance.
     def initialize
       @context = H8::Context.new
-      @context.eval open(File.join(File.dirname(File.expand_path(__FILE__)),'/coffee-script.js'), 'r').read
+      @context.eval read_script 'coffee-script.js'
+      eval read_script('globals.coffee')
     end
 
     # compile coffeescript source and return compiled javascript
-    def compile src, **kwargs
+    def compile src, file_name: nil, **kwargs
       @context[:cs] = src
-      res = @context.eval('CoffeeScript.compile(cs)')
+      @context[:filename] = file_name
+      res = @context.eval('CoffeeScript.compile(cs,{filename: filename})')
       @context[:cs] = nil # Sources can be big...
       res
     end
@@ -52,6 +54,20 @@ module H8
     def eval src, **kwargs
       @context.eval compile(src), **kwargs
     end
+
+    # Provide context with CoffeeScrip compiler loaded
+    def context
+      @context
+    end
+
+    private
+
+    @@base = File.expand_path File.join(File.dirname(__FILE__), '../scripts')
+    @@cache = {}
+
+    def read_script name
+      @@cache[name] ||= open(File.join(@@base, name), 'r').read
+    end
   end
 
 

data/lib/h8/command.rb

@@ -0,0 +1,128 @@
+$:.unshift File.dirname(__FILE__)
+require 'pargser'
+require 'ostruct'
+require 'h8'
+
+module H8
+
+  class Command
+
+    def initialize *args, out: STDOUT, err: STDERR
+      @out = out
+      @err = err
+
+      run *args if args.length > 0
+    end
+
+    def run *args
+      count = 0
+
+      @parser = Pargser.new(args)
+
+      @parser.key('-e', default: false, doc: 'inline coffee code to execute') { |script|
+        if script
+          @file = '-e'
+          context.coffee (@script=script)
+          count += 1
+        end
+      }
+          .key('-x', default: nil, doc: 'inline js code to execute') { |script|
+        if script
+          @file = '-e'
+          context.eval (@script=script)
+          count += 1
+        end
+      }
+
+      @parser.parse { |file|
+        count   += 1
+        @script = open(file, 'r').read
+        file.downcase.end_with?('.coffee') and @script = H8::Coffee.compile(@script)
+        @file = file
+        context.eval @script
+      }
+
+      count > 0 or raise 'Must provide at least one file'
+    end
+
+    def context
+      @context ||= begin
+        cxt             = H8::Context.new
+        console         = Console.new out: @out, err: @err
+        cxt[:console]   = console
+        print           = -> (*args) { console.debug *args }
+        cxt[:print]     = print
+        cxt[:puts]      = print
+        cxt[:open]      = -> (name, mode='r', block=nil) { Stream.new(name, mode, block) }
+        cxt['__FILE__'] = @file ? @file.to_s : '<inline>'
+        cxt[:File] = FileProxy.new
+        cxt
+      end
+    end
+
+    def usage
+      "\nh8 #{H8::VERSION} CLI inteface\n\n" +
+          "Usage: h8 <file.js/file.coffe>\n\n" +
+          @parser.keys_doc
+    end
+
+    class FileProxy
+      def dirname str
+        File.dirname str
+      end
+
+      def extname str
+        File.extname str
+      end
+
+      def basename str
+        File.basename str
+      end
+
+      def expand_path str
+        File.expand_path str
+      end
+
+    end
+
+    class Stream
+      def initialize name, mode, block=nil
+        @file = open(name, mode)
+        if block
+          block.call self
+          @file.close
+        end
+      end
+
+      def read(count=nil)
+        if count
+          @file.read(count)
+        else
+          @file.read
+        end
+      end
+
+    end
+
+    class Console
+      def initialize out: STDOUT, err: STDERR
+        @out, @err = out, err
+      end
+
+      def debug *args
+        @out.puts args.join(' ')
+      end
+
+      def log *args
+        debug *args
+      end
+
+      def error *args
+        @err.puts args.join(' ')
+      end
+    end
+
+
+  end
+
+end

data/lib/h8/context.rb

@@ -25,7 +25,7 @@ module H8
     #  * ruby Class - creating a javascript constructor function that creates ruby
     #    class instance (any arguments) and gates it to use with js.
     def []= name, value
-      set_all name => value
+      set_all name.to_sym => value
     end
 
     # Execute a given script on the current context with optionally limited execution time.
@@ -37,16 +37,25 @@ module H8
     #
     # @return [Value] wrapped object returned by the script
     # @raise [H8::TimeoutError] if the timeout was set and expired
-    def eval script, max_time: 0, timeout: 0
+    def eval script, max_time: 0, timeout: 0, file_name: nil
       timeout = max_time * 1000 if max_time > 0
       yield(self) if block_given?
-      _eval script, timeout.to_i
+      _eval script, timeout.to_i, file_name
     end
 
+    # Compile and execute coffeescript, taking same arguments as #eval.
+    #
+    # If you need to execute same script more than once consider first H8::Coffee.compile
+    # and cache compiled script.
+    def coffee script, ** kwargs
+      eval Coffee.compile script, **kwargs
+    end
+
+
     # Execute script in a new context with optionally set vars. @see H8#set_all
     # @return [Value] wrapped object returned by the script
-    def self.eval script, **kwargs
-      Context.new(** kwargs).eval script
+    def self.eval script, file_name: nil, **kwargs
+      Context.new(** kwargs).eval script, file_name: file_name
     end
 
     # Secure gate for JS to securely access ruby class properties (methods with no args)
@@ -111,20 +120,4 @@ module H8
     end
   end
 
-  # class RacerContext < Context
-  #   protected
-  #   def set_var name, value
-  #     if value.is_a?(Proc)
-  #       n1 = "___compat_#{name}"
-  #       _eval "function #{name}() { return #{n1}( this, arguments); }", 0
-  #       super n1, -> (this, arguments) {
-  #         args = [this] + H8::arguments_to_a(arguments)
-  #         value.call *args
-  #       }
-  #     else
-  #       super name, value
-  #     end
-  #   end
-  # end
-
 end

data/lib/h8/errors.rb

@@ -8,26 +8,27 @@ module H8
   # The general error caused by the script execution, e.g. uncaught javascript exceptinos and like.
   # Check #message to see the cause.
   class JsError < Error
-    # Error message
-    attr :message
 
     # Javascript Error object. May be nil
     attr :javascript_error
 
-    def to_s
-      message
-    end
-
     # Error name
     def name
-      @javascript_error.name ? @javascript_error.name : message
+      @javascript_error.name ? @javascript_error.name : @message
     end
 
     # String that represents stack trace if any as multiline string (\n separated)
     def javascript_backtrace
-      @javascript_error ? @javascript_error.stack : message
+      @javascript_error ? @javascript_error.stack : @message
     end
 
+    def to_s
+      javascript_backtrace
+    end
+
+    def message
+      to_s
+    end
   end
 
   # Script execution is timed out (see H8::Context#eval timeout parameter)

data/lib/h8/pargser.rb

@@ -0,0 +1,133 @@
+require 'set'
+
+module H8
+  class Pargser
+
+    class Error < ArgumentError; end
+
+    # Create parser instance with a list of arguments. Otherwise, arguments can
+    # be passed to #parse call.
+    #
+    # @param [Array] args arguments
+    def initialize args=[]
+      @args     = args
+      @keys     = {}
+      @required = Set.new
+      @docs     = []
+    end
+
+    # Register key handler.
+    # When #parse handler blocks will be called in order of appearance in
+    # arguments array
+    #
+    #
+    # @param [String] name key name
+    #
+    # @param [Array(String)] aliases for the key
+    #
+    # @param [Boolean] :needs_value if set then the parser wants a value argument after the
+    #   key which will be passed to block as an argument. if default param is not set and
+    #   the key will not be detected, Pargser::Error will be raised
+    #
+    # @param [String] :default value. if set, needs_value parameter can be omitted - the handler
+    #   block will be passed either with this value or with one specified in args.
+    #
+    # @param [String] :doc optional documentation string that will be used in #keys_doc
+    #
+    # @yield block if the key is found with optional value argument
+    #
+    def key name, *aliases, needs_value: false, doc: nil, **kwargs, &block
+      k = name.to_s
+
+      default_set = false
+      default = nil
+      if kwargs.include?(:default)
+        default = kwargs[:default]
+        needs_value = true
+        default_set = true
+      end
+
+      @keys.include?(k) and raise Error, "Duplicate key registration #{k}"
+      data = @keys[k] = OpenStruct.new required:    false,
+                                       needs_value: needs_value,
+                                       block:       block,
+                                       doc:         doc,
+                                       key:         k,
+                                       aliases:     aliases,
+                                       default:     default,
+                                       default_set: default_set
+      @docs << data
+      aliases.each { |a| @keys[a.to_s] = data }
+      @required.add(data) if needs_value
+      self
+    end
+
+    # Process command line and call key handlers in the order of
+    # appearance. Then call handlers that keys which need values
+    # and were not called and have defaults, or raise error.
+    #
+    # The rest of arguments (non-keys) are either yielded or returned
+    # as an array.
+    #
+    # You can optionally set other arguments than specified in constructor
+    #
+    # @param [Array] args to parse. If specified, arguments passed to constructor
+    #                will be ignored and lost
+    # @return [Array] non-keys arguments (keys afer '--' or other arguments)
+    # @yield [String] non keys argumenrs (same as returned)
+    def parse args=nil
+      @args = args if args
+      no_more_keys = false
+      rest         = []
+      while !@args.empty?
+        a = @args.shift
+        case
+          when no_more_keys
+            rest << a
+          when (data = @keys[a])
+            @required.delete data
+            if data.needs_value
+              value = @args.shift or raise "Value needed for key #{a}"
+              data.block.call value
+            else
+              data.block.call
+            end
+          when a == '--'
+            no_more_keys = true
+          when a[0] == '-'
+            raise Error, "Unknown key #{a}"
+          else
+            rest << a
+        end
+      end
+      @required.each { |data|
+        raise Error, "Required key is missing: #{data.key}" if !data.default_set
+        data.block.call data.default
+      }
+      block_given? and rest.each { |a| yield a }
+      rest
+    end
+
+    # Generate keys documentation multiline text
+    def keys_doc
+      res = []
+      @docs.each { |d|
+        keys = [d.key] + d.aliases
+        str = "\t#{keys.join(',')}"
+        if d.needs_value
+          str += " value"
+          if d.default
+            str += " (default: #{d.default})" if d.default
+          else
+            str += ' (optional)'
+          end
+        end
+        res << str
+        d.doc and d.doc.split("\n").each{ |l| res << "\t\t#{l}" }
+      }
+      res.join("\n")
+    end
+
+  end
+
+end

data/lib/h8/version.rb

@@ -1,3 +1,3 @@
 module H8
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/scripts/globals.coffee

@@ -0,0 +1,4 @@
+@.puts ?= ->
+  # Do nothing if not set
+
+@.globalsIncluded = true

data/spec/coffee/cli_tests.coffee

@@ -0,0 +1,50 @@
+errorsCount = 0
+
+class TestFailed extends Error
+
+fail = (msg) ->
+  msg = "Failed: #{msg}\n"
+  errorsCount++
+  try
+    throw Error()
+  catch e
+    msg += e.stack.split("\n")[3]+' '+__FILE__
+    console.error msg
+
+ok = (condition, message='') ->
+  condition or fail "condition is not true"
+
+gt = (a, b, message = '') ->
+  unless a > b
+    fail "#{a} > #{b} #{message}"
+
+ge = (a, b, message = '') ->
+  unless a >= b
+    fail "#{a} >= #{b} #{message}"
+
+lt = (a, b, message = '') ->
+  unless a < b
+    fail "#{a} < #{b} #{message}"
+
+le = (a, b, message = '') ->
+  unless a <= b
+    fail "#{a} <= #{b} #{message}"
+
+eq = (a, b, message = '') ->
+  unless a == b
+    fail "#{a} == #{b} #{message}"
+
+ne = (a, b, message = '') ->
+  unless a != b
+    fail "#{a} != #{b} #{message}"
+
+
+ok File.dirname(__FILE__).match(/spec\/coffee$/)
+eq File.extname(__FILE__), '.coffee'
+
+eq File.basename(__FILE__), 'cli_tests.coffee'
+
+if errorsCount > 0
+  print "#{errorsCount} tests failed"
+else
+  print "All tests passed"