notepadqq_api 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e092a63573088f2db1e41de45d9ec066bd1121c5
-  data.tar.gz: b3fb8067ef1b9c5a9dccd9bdba4bf4c91ddcbf7e
+  metadata.gz: 1529b331a85e339351d5002099908bdcb33d528c
+  data.tar.gz: 5222b4cef0fa9bd0b50d8db409cf7571588fbb54
 SHA512:
-  metadata.gz: 8fb3048fecd2eff830a0fff6bc7f842d2d0d098a22f7cfccb805646dd1fe5f7f10b07fa3a59b27837ec53f47bad655ab1a202cf21b7f153d395d234f085a7821
-  data.tar.gz: 1cd22f92840a3a695063f6ad74247722e419693eb380e1b3af2e560386918434a2c5733c413606d1e982f01f626e8c4c8af0fe709ac9db84d4b1c5328efbc569
+  metadata.gz: 727a0d4bb12fd1bf7e588d0e4853b2ce646eab9fa65198f9d90318b579405a3cffc67ff0d0f35f28ce67bc763c003210aa75e58c405e6d0b37ccfd80ada05832
+  data.tar.gz: c8c91d50253b9344a377a6bb5e42d84507f5e7116f6ba877d5dd90a63ea8180d178cf95a09f85419ab5a5aea6e421664952f8ad6eaf2e4004e3220241eb4ae84

data/lib/notepadqq_api/message_channel.rb

@@ -4,24 +4,24 @@ require 'json'
 class NotepadqqApi
   class MessageChannel
 
-    def initialize(socketPath)
+    def initialize(socket_path)
       # Connect to Notepadqq socket
-      @client = UNIXSocket.open(socketPath)
+      @client = UNIXSocket.open(socket_path)
 
-      @incomingBuffer = "" # Incomplete json messages (as strings)
-      @parsedBuffer = [] # Unprocessed object messages
+      @incoming_buffer = "" # Incomplete json messages (as strings)
+      @parsed_buffer = [] # Unprocessed object messages
     end
 
     # Sends a JSON message to Notepadqq
-    def sendMessage(msg)
-      sendRawMessage(JSON.generate(msg))
+    def send_message(msg)
+      send_raw_message(JSON.generate(msg))
     end
 
     # Read incoming messages
-    def getMessages(block=true)
+    def get_messages(block=true)
 
       begin
-        if block and @incomingBuffer.empty? and @parsedBuffer.empty?
+        if block and @incoming_buffer.empty? and @parsed_buffer.empty?
           read = @client.recv(1048576)
         else
           read = @client.recv_nonblock(1048576)
@@ -30,15 +30,15 @@ class NotepadqqApi
         read = ""
       end
 
-      @incomingBuffer += read
-      messages = @incomingBuffer.split("\n")
+      @incoming_buffer += read
+      messages = @incoming_buffer.split("\n")
 
-      if @incomingBuffer.end_with? "\n"
+      if @incoming_buffer.end_with? "\n"
         # We only got complete messages: clear the buffer
-        @incomingBuffer.clear
+        @incoming_buffer.clear
       else
         # We need to store the incomplete message in the buffer
-        @incomingBuffer = messages.pop || ""
+        @incoming_buffer = messages.pop || ""
       end
 
       converted = []
@@ -51,29 +51,29 @@ class NotepadqqApi
         end
       end
 
-      retval = @parsedBuffer + converted
-      @parsedBuffer = []
+      retval = @parsed_buffer + converted
+      @parsed_buffer = []
 
       # Make sure that, when block=true, at least one message is received
       if block and retval.empty?
-        retval += getMessages(true)
+        retval += get_messages(true)
       end
 
       return retval
     end
 
     # Get the next message of type "result".
-    # The other messages will still be returned by getMessages 
-    def getNextResultMessage
+    # The other messages will still be returned by get_messages 
+    def get_next_result_message
       discarded = []
 
       while true do
-        chunk = self.getMessages
+        chunk = self.get_messages
         for i in 0...chunk.length
           if chunk[i].has_key?("result")
             discarded += chunk[0...i]
             discarded += chunk[i+1..-1]
-            @parsedBuffer = discarded
+            @parsed_buffer = discarded
             return chunk[i]
           end
         end
@@ -86,7 +86,7 @@ class NotepadqqApi
     private
 
     # Sends a raw string message to Notepadqq
-    def sendRawMessage(msg)
+    def send_raw_message(msg)
       @client.send(msg, 0)
     end
 

data/lib/notepadqq_api/message_interpreter.rb

@@ -1,8 +1,8 @@
 class NotepadqqApi
   class MessageInterpreter
 
-    def initialize(messageChannel)
-      @messageChannel = messageChannel
+    def initialize(message_channel)
+      @message_channel = message_channel
 
       # Hash of event handlers, for example
       # {
@@ -11,43 +11,46 @@ class NotepadqqApi
       #   },
       #   ...
       # }
-      # Where 1 is an objectId and "newWindow" is an event of that object
-      @eventHandlers = {}
+      # Where 1 is an object_id and "newWindow" is an event of that object
+      @event_handlers = {}
     end
 
-    # Assign an event of a particular objectId to a callback
-    def registerEventHandler(objectId, event, callback)
+    # Assign an event of a particular object_id to a callback
+    def register_event_handler(object_id, event, callback)
       event = event.to_sym
 
-      @eventHandlers[objectId] ||= {}
-      @eventHandlers[objectId][event] ||= []
+      @event_handlers[object_id] ||= {}
+      @event_handlers[object_id][event] ||= []
 
-      @eventHandlers[objectId][event].push(callback)
+      @event_handlers[object_id][event].push(callback)
     end
 
-    # Calls a method on the remote object objectId
-    def invokeApi(objectId, method, args)
+    # Calls a method on the remote object object_id
+    def invoke_api(object_id, method, args)
       message = {
-        :objectId => objectId,
+        :objectId => object_id,
         :method => method,
         :args => args
       }
 
-      @messageChannel.sendMessage(message)
-      reply = @messageChannel.getNextResultMessage
+      @message_channel.send_message(message)
+      reply = @message_channel.get_next_result_message
 
       result = [reply["result"]]
-      convertStubs!(result)
+      convert_stubs!(result)
       result = result[0]
 
-      # Fixme check for errors in reply["err"]
+      if reply["err"] != MessageInterpreterError::ErrorCode::NONE
+        error = MessageInterpreterError.new(reply["err"])
+        raise error, error.description
+      end
 
       return result
     end
 
-    def processMessage(message)
+    def process_message(message)
       if message.has_key?("event")
-        processEventMessage(message)
+        process_event_message(message)
       elsif message.has_key?("result")
         # We shouldn't have received it here... ignore it
       end
@@ -56,15 +59,15 @@ class NotepadqqApi
     private
 
     # Call the handlers connected to this event
-    def processEventMessage(message)
+    def process_event_message(message)
       event = message["event"].to_sym
-      objectId = message["objectId"]
+      object_id = message["objectId"]
 
-      if @eventHandlers[objectId] and @eventHandlers[objectId][event]
-        handlers = @eventHandlers[objectId][event]
+      if @event_handlers[object_id] and @event_handlers[object_id][event]
+        handlers = @event_handlers[object_id][event]
 
         args = message["args"]
-        convertStubs!(args)
+        convert_stubs!(args)
 
         (handlers.length-1).downto(0).each { |i| 
           handlers[i].call(*args)
@@ -72,32 +75,32 @@ class NotepadqqApi
       end
     end
 
-    def convertStubs!(dataArray)
+    def convert_stubs!(data_array)
       # FIXME Use a stack
 
-      dataArray.map! { |value|
+      data_array.map! { |value|
         unless value.nil?
           if value.kind_of?(Array)
-            convertStubs!(value)
+            convert_stubs!(value)
 
           elsif value.kind_of?(Hash) and
                 value["$__nqq__stub_type"].kind_of?(String) and
                 value["id"].kind_of?(Fixnum)
 
-            stubType = value["$__nqq__stub_type"]
+            stub_type = value["$__nqq__stub_type"]
             begin
-              stub = Object::const_get(Stubs.name + "::" + stubType)
+              stub = Object::const_get(Stubs.name + "::" + stub_type)
               stub.new(self, value["id"])
             rescue
-              puts "Unknown stub: " + stubType
+              puts "Unknown stub: " + stub_type
               value
             end
 
           elsif value.kind_of?(Hash)
             value.each do |key, data|
-              tmpArray = [data]
-              convertStubs!(tmpArray)
-              value[key] = tmpArray[0]
+              tmp_array = [data]
+              convert_stubs!(tmp_array)
+              value[key] = tmp_array[0]
             end
 
             value
@@ -110,4 +113,38 @@ class NotepadqqApi
     end
 
   end
+
+  class MessageInterpreterError < RuntimeError
+
+    module ErrorCode
+        NONE = 0
+        INVALID_REQUEST = 1
+        INVALID_ARGUMENT_NUMBER = 2
+        INVALID_ARGUMENT_TYPE = 3
+        OBJECT_DEALLOCATED = 4
+        OBJECT_NOT_FOUND = 5
+        METHOD_NOT_FOUND = 6
+    end
+
+    attr_reader :error_code
+
+    def initialize(error_code)
+      @error_code = error_code
+    end
+
+    def description
+      case @error_code
+        when ErrorCode::NONE then "None"
+        when ErrorCode::INVALID_REQUEST then "Invalid request"
+        when ErrorCode::INVALID_ARGUMENT_NUMBER then "Invalid argument number"
+        when ErrorCode::INVALID_ARGUMENT_TYPE then "Invalid argument type"
+        when ErrorCode::OBJECT_DEALLOCATED then "Object deallocated"
+        when ErrorCode::OBJECT_NOT_FOUND then "Object not found"
+        when ErrorCode::METHOD_NOT_FOUND then "Method not found"
+        else "Unknown error"
+      end
+    end
+
+  end
+
 end

data/lib/notepadqq_api/stubs.rb

@@ -3,28 +3,28 @@ class NotepadqqApi
 
     class Stub
       
-      def initialize(messageInterpreter, id)
-        @messageInterpreter = messageInterpreter
+      def initialize(message_interpreter, id)
+        @message_interpreter = message_interpreter
         @id = id
       end
 
       def on(event, &callback)
-        @messageInterpreter.registerEventHandler(@id, event, callback)
+        @message_interpreter.register_event_handler(@id, event, callback)
       end
 
       def method_missing(method, *args, &block)  
-        return @messageInterpreter.invokeApi(@id, method, args)
+        return @message_interpreter.invoke_api(@id, method, args)
       end 
 
       def ==(other)
         other.class <= Stub &&
         id == other.id &&
-        messageInterpreter == other.messageInterpreter
+        message_interpreter == other.message_interpreter
       end
 
       protected
       
-      attr_reader :id, :messageInterpreter
+      attr_reader :id, :message_interpreter
 
     end
 

data/lib/notepadqq_api.rb

@@ -5,43 +5,46 @@ require 'notepadqq_api/stubs'
 class NotepadqqApi
   
   NQQ_STUB_ID = 1
+  private_constant :NQQ_STUB_ID
   
-  attr_reader :extensionId
+  attr_reader :extension_id
   
-  def initialize(socketPath = ARGV[0], extensionId = ARGV[1])
-    @socketPath = socketPath
-    @extensionId = extensionId
+  def initialize(socket_path = ARGV[0], extension_id = ARGV[1])
+    @socket_path = socket_path
+    @extension_id = extension_id
     
-    @messageChannel = MessageChannel.new(@socketPath)
-    @messageInterpreter = MessageInterpreter.new(@messageChannel)
+    @message_channel = MessageChannel.new(@socket_path)
+    @message_interpreter = MessageInterpreter.new(@message_channel)
   end
   
   # Start reading messages and calling event handlers
-  def runEventLoop
+  def run_event_loop
     yield
     
     while true do
-      messages = @messageChannel.getMessages
+      messages = @message_channel.get_messages
       messages.each do |msg|
-        @messageInterpreter.processMessage(msg)
+        @message_interpreter.process_message(msg)
       end
     end
-    
   end
   
+  # For compatibility
+  alias_method :runEventLoop, :run_event_loop
+  
   # Execute a block for every new window.
   # This is preferable to the "newWindow" event of Notepadqq, because it could
   # happen that the extension isn't ready soon enough to receive the
   # "newWindow" event for the first Window. This method, instead, ensures that
   # the passed block will be called once and only once for each current or
   # future window.
-  def onWindowCreated(&callback)
-    capturedWindows = []
+  def on_window_created(&callback)
+    captured_windows = []
     
     # Invoke the callback for every currently open window
     notepadqq.windows.each do |window|
-      unless capturedWindows.include? window
-        capturedWindows.push window
+      unless captured_windows.include? window
+        captured_windows.push window
         callback.call(window)
       end
     end
@@ -51,16 +54,19 @@ class NotepadqqApi
     # we might not be fast enough to receive this event: this is why
     # we manually invoked the callback for every currently open window.
     notepadqq.on(:newWindow) do |window|
-      unless capturedWindows.include? window
-        capturedWindows.push window
+      unless captured_windows.include? window
+        captured_windows.push window
         callback.call(window)
       end
     end
   end
   
+  # For compatibility
+  alias_method :onWindowCreated, :on_window_created
+  
   # Returns an instance of Notepadqq
   def notepadqq
-    @nqq ||= Stubs::Notepadqq.new(@messageInterpreter, NQQ_STUB_ID);
+    @nqq ||= Stubs::Notepadqq.new(@message_interpreter, NQQ_STUB_ID);
     return @nqq
   end
   

data/test/test_message_interpreter.rb

@@ -1,20 +1,21 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'notepadqq_api/message_channel'
 require 'notepadqq_api/message_interpreter'
 require 'notepadqq_api/stubs'
 
-class ChannelStub
-  def initialize(socketPath) end
-  def sendMessage(msg) end
-  def getMessages(block=true) end
-  def getNextResultMessage() end
+class MessageChannelStub
+  def initialize(*) end
+  
+  NotepadqqApi::MessageChannel.instance_methods(false).each do |m|
+    define_method(m) { |*| }
+  end
 end
 
-class MessageInterpreterTest < Test::Unit::TestCase
+class MessageInterpreterTest < Minitest::Test
   
-  def test_invokeApi_simple_return
-    channel = ChannelStub.new nil
-    def channel.getNextResultMessage
+  def test_invoke_api_simple_return
+    channel = MessageChannelStub.new nil
+    def channel.get_next_result_message
       {
         'err' => 0,
         'result' => {"$__nqq__stub_type" => 'Notepadqq', "id" => 7}
@@ -23,13 +24,13 @@ class MessageInterpreterTest < Test::Unit::TestCase
     
     interpreter = NotepadqqApi::MessageInterpreter.new channel
     
-    retval = interpreter.invokeApi(1, 'example', [])
+    retval = interpreter.invoke_api(1, 'example', [])
     assert_equal NotepadqqApi::Stubs::Notepadqq.new(interpreter, 7), retval
   end
   
-  def test_invokeApi_array_return
-    channel = ChannelStub.new nil
-    def channel.getNextResultMessage
+  def test_invoke_api_array_return
+    channel = MessageChannelStub.new nil
+    def channel.get_next_result_message
       {
         'err' => 0,
         'result' => [{"$__nqq__stub_type" => 'Notepadqq', "id" => 7},
@@ -41,7 +42,7 @@ class MessageInterpreterTest < Test::Unit::TestCase
     
     interpreter = NotepadqqApi::MessageInterpreter.new channel
     
-    retval = interpreter.invokeApi(1, 'example', [])
+    retval = interpreter.invoke_api(1, 'example', [])
     assert_equal [NotepadqqApi::Stubs::Notepadqq.new(interpreter, 7),
                   42,
                   NotepadqqApi::Stubs::Editor.new(interpreter, 10)

data/test/test_stubs.rb

@@ -1,7 +1,7 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'notepadqq_api/stubs'
 
-class StubsTest < Test::Unit::TestCase
+class StubsTest < Minitest::Test
   
   def test_comparison
     
@@ -21,30 +21,30 @@ class StubsTest < Test::Unit::TestCase
     
     # Different id
     
-    assert_not_equal NotepadqqApi::Stubs::Notepadqq.new(nil, 1),
+    refute_equal NotepadqqApi::Stubs::Notepadqq.new(nil, 1),
              NotepadqqApi::Stubs::Stub.new(nil, 2)
     
-    assert_not_equal NotepadqqApi::Stubs::Stub.new(nil, 1),
+    refute_equal NotepadqqApi::Stubs::Stub.new(nil, 1),
              NotepadqqApi::Stubs::Notepadqq.new(nil, 2)
     
-    assert_not_equal NotepadqqApi::Stubs::Stub.new(nil, 1),
+    refute_equal NotepadqqApi::Stubs::Stub.new(nil, 1),
              NotepadqqApi::Stubs::Stub.new(nil, 2)
     
-    assert_not_equal NotepadqqApi::Stubs::Notepadqq.new(nil, 1),
+    refute_equal NotepadqqApi::Stubs::Notepadqq.new(nil, 1),
              NotepadqqApi::Stubs::Notepadqq.new(nil, 2)
     
     # Different channel
     
-    assert_not_equal NotepadqqApi::Stubs::Notepadqq.new("test", 7),
+    refute_equal NotepadqqApi::Stubs::Notepadqq.new("test", 7),
              NotepadqqApi::Stubs::Stub.new(nil, 7)
     
-    assert_not_equal NotepadqqApi::Stubs::Stub.new("test", 7),
+    refute_equal NotepadqqApi::Stubs::Stub.new("test", 7),
              NotepadqqApi::Stubs::Notepadqq.new(nil, 7)
     
-    assert_not_equal NotepadqqApi::Stubs::Stub.new("test", 7),
+    refute_equal NotepadqqApi::Stubs::Stub.new("test", 7),
              NotepadqqApi::Stubs::Stub.new(nil, 7)
     
-    assert_not_equal NotepadqqApi::Stubs::Notepadqq.new("test", 7),
+    refute_equal NotepadqqApi::Stubs::Notepadqq.new("test", 7),
              NotepadqqApi::Stubs::Notepadqq.new(nil, 7)
     
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: notepadqq_api
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Daniele Di Sarli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-30 00:00:00.000000000 Z
+date: 2015-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
 description: Notepadqq API Layer for extensions
 email: danieleds0@gmail.com
 executables: []
@@ -62,7 +76,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="