i3ipc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e40ae80557aa74e152aa616ae813744d8b755586
+  data.tar.gz: a5f833254c367b6d9bc4b4bdecd8303020388194
+SHA512:
+  metadata.gz: 4af0b717ee2d06d19d858694305c21eef45c2ef0b1e74427acafd18c32c9db0835694c9c84fadc5456d1a55bb51a7b1e5664d58f50f564ba4aed75095a1769de
+  data.tar.gz: 38fef1144589bacb4c4b7edcae7427f435aeaa95fca85a0b45789f4805f2e9b21deade91c6f396096bf4e201a8cd0603b0207e21dc25787f0a50f10113403208

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+
+script:
+  - bundle exec rspec

data/.yardopts

@@ -0,0 +1,2 @@
+--markup markdown
+--hide-void-return

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in i3ipc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 veelenga
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# I3ipc [![Gem Version](https://badge.fury.io/rb/i3ipc.svg)](https://rubygems.org/gems/i3ipc) [![Build Status](https://api.travis-ci.org/veelenga/i3ipc-ruby.svg?branch=master)](https://travis-ci.org/veelenga/i3ipc-ruby)
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Command](#command)
+  - [Workspaces](#workspaces)
+  - [Subscribe](#subscribe)
+  - [Outputs](#outputs)
+  - [Tree](#tree)
+  - [Marks](#marks)
+  - [Bar config](#bar-config)
+  - [Version](#version)
+- [Contributing](#contributing)
+
+
+An improved Ruby library to control [i3wm](http://i3wm.org/).
+
+i3's interprocess communication (or [ipc](http://i3wm.org/docs/ipc.html)) is the interface i3 wm uses to receive commands from the clients. It also features a publish/subscribe mechanism for notifying interested parties of window manager events.
+
+This gem will be useful for example for controlling i3 windows manager or to get various information like the current workspaces or to implemennt external workspace bar in `Ruby` language.
+
+Inspired by [i3ipc-python](https://github.com/acrisci/i3ipc-python), [i3ipc-gjs](https://github.com/acrisci/i3ipc-gjs), [i3ipc-lua](https://github.com/acrisci/i3ipc-lua) and reworked mainly from [i3-ipc](https://github.com/badboy/i3-ipc) (thanks to [@badboy](https://github.com/badboy) for this gem).
+
+## Installation
+
+Nothing special here:
+```sh
+$ gem install i3ipc
+```
+## Usage
+
+Usage is very simple and straightforward:
+
+```ruby
+require 'i3ipc'
+
+i3 = I3Ipc::Connection.new
+# communicate with i3 server...
+# ...
+i3.close
+
+```
+
+Below you can find examples of usage some replies from local i3 wm. Output depend on my config and will be different in other env. A list of messages to send and replies you can find in [Receiving replies from i3](https://i3wm.org/docs/ipc.html#_receiving_replies_from_i3).
+
+Each reply from i3 wm will be parsed and packed in a special object. That object responds to any method with a name of an original name of i3 wm attribute in the reply. So you can access attributes in a very useful way. Find examples below.
+
+### Command
+
+Executes one or more command at a time. Reply contains the property `success (bool)` for each command:
+
+```ruby
+>> command = i3.command('workspace 0; focus left')
+>> puts command[0]
+{
+  "success": true
+}
+>> puts command[0].success
+true
+```
+
+or a human readable error message in the property `error (string)`
+
+```ruby
+>> command = i3.command('this a bad command')
+>> puts command[0].success
+false
+>> puts command[0].error
+Expected one of these tokens: <end>, '[', 'move', 'exec', 'exit', 'restart', 'reload', 'shmlog', 'debuglog', 'border', 'layout', 'append_layout', 'workspace', 'focus', 'kill', 'open', 'fullscreen', 'split', 'floating', 'mark', 'unmark', 'resize', 'rename', 'nop', 'scratchpad', 'mode', 'bar'
+```
+
+### Workspaces
+
+Reply consists of a list of workspaces. Each workspace has some properties:
+
+```ruby
+>> workspaces = i3.workspaces
+>> puts workspaces[0]
+{
+  "num": 1,
+  "name": "1 Browse",
+  "visible": true,
+  "focused": false,
+  "rect": {
+    "x": 1366,
+    "y": 20,
+    "width": 1920,
+    "height": 1060
+  },
+  "output": "VGA1",
+  "urgent": false
+}
+>> puts workspaces[0].name
+1 Browse
+>> puts workspaces[0].rect.width
+1920
+```
+
+### Subscribe
+
+To be done (not implemented yet)
+
+### Outputs
+
+Reply consists of a list of outputs:
+
+```ruby
+>> outputs = i3.outputs
+>> puts oututs[0].name
+LVDS1
+```
+
+### Tree
+
+The reply consists information about i3 tree. Each node in the tree (representing one container) has some properties:
+
+```ruby
+>> tree = i3.tree
+>> puts tree.id
+8214416
+>> puts tree.nodes[0].name
+VGA1
+```
+
+### Marks
+
+Reply consists of a single array of string for each container that has a mark.
+
+First we need to create some marks:
+
+```ruby
+>> i3.command('mark terminal; focus right; mark vim')
+```
+
+Then can get a list of available marks:
+
+```ruby
+>> puts i3.marks
+terminal
+vim
+```
+
+And use those marks:
+
+```ruby
+>> i3.command("focus right; [con_mark=\"terminal\"] focus")
+```
+
+### Bar config
+
+```ruby
+>> puts i3.bar_config
+bar-0
+```
+
+### Version
+
+Reply describes a current version of i3 windows manager:
+
+```ruby
+>> puts i3.version
+{
+  "major": 4,
+  "minor": 10,
+  "patch": 2,
+  "human_readable": "4.10.2 (2015-04-16, branch \"4.10.2\")"
+}
+```
+
+## Contributing
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Run tests (`bundle exec rspec`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:spec]
+

data/i3ipc.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'i3ipc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'i3ipc'
+  spec.version       = I3ipc::VERSION
+  spec.authors       = ['Vitalii Elengaupt']
+  spec.email         = ['velenhaupt@gmail.com']
+  spec.summary       = 'Interprocess communication with i3 wm'
+  spec.description   = <<-DESC
+    Implementation of interface for i3 tiling window manager.
+    Useful for example to remote-control i3 or to get various
+    information like the current workspace to implement an
+    external workspace bar etc. in Ruby language.
+  DESC
+  spec.homepage      = 'https://github.com/veelenga/i3ipc-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^spec\//)
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/i3ipc.rb

@@ -0,0 +1,4 @@
+require 'i3ipc/version'
+require 'i3ipc/protocol'
+require 'i3ipc/reply'
+require 'i3ipc/connection'

data/lib/i3ipc/connection.rb

@@ -0,0 +1,66 @@
+require 'i3ipc/protocol'
+require 'i3ipc/reply'
+
+module I3Ipc
+  # Entry point for communication with i3-ipc.
+  # Able to send/receive messages and convert
+  # responses.
+  #
+  # Usage example:
+  #   con = Connection.new
+  #   p con.version.human_readable         # => 4.10.2 (2015-0...
+  #   p con.command('focus left').success? # => true
+  #   p con.workspaces[0].name             # => 0 Term
+  #   # ...
+  #   con.close
+  class Connection
+
+    def initialize(connect = true)
+      @protocol = Protocol.new
+      connect && @protocol.connect
+    end
+
+    def connect
+      @protocol.connect
+    end
+
+    def disconnect
+      @protocol.disconnect
+    end
+
+    def command(cmds)
+      reply_for(0, cmds)
+    end
+
+    def workspaces
+      reply_for(1)
+    end
+
+    def outputs
+      reply_for(3)
+    end
+
+    def tree
+      reply_for(4)
+    end
+
+    def marks
+      reply_for(5)
+    end
+
+    def bar_config
+      reply_for(6)
+    end
+
+    def version
+      reply_for(7)
+    end
+
+    private
+
+    def reply_for(type, message = nil)
+      @protocol.send(type, message)
+      Reply.parse(@protocol.receive type)
+    end
+  end
+end

data/lib/i3ipc/protocol.rb

@@ -0,0 +1,136 @@
+require 'socket'
+
+module I3Ipc
+  # Communication interface with i3-ipc.
+  #
+  # Can connect to i3-ipc socket, disconnect, send and receive messages.
+  #
+  # Usage example:
+  #   protocol = Protocol.new
+  #   protocol.send(7)
+  #   puts protocol.receive
+  #   protocol.disconnect
+  #
+  # For i3-ipc interface details refer to https://i3wm.org/docs/ipc.html.
+  class Protocol
+    # Magic string for i3-ipc protocol to ensure the integrity of messages.
+    MAGIC_STRING = 'i3-ipc'
+
+    # Throws when received data with not expected magic string.
+    # Usually this means that protocol is not compatible with
+    # current i3-ipc version.
+    class WrongMagicString < RuntimeError
+      def initialize(magic_string)
+        @magic_string = magic_string
+      end
+
+      def message
+        %Q{Magic code expected '#{MAGIC_STRING}', but was '#{@magic_string}'}
+      end
+    end
+
+    # Throws when received data with not expected type.
+    class WrongType < RuntimeError
+      def initialize(expected, actual)
+        @expected = expected
+        @actual = actual
+      end
+
+      def message
+        %Q{Message type expected '#{@expected}', but was '#{@actual}'}
+      end
+    end
+
+    # Throws when protocol trying to do some action
+    # on non-connected channel.
+    class NotConnected < RuntimeError; end
+
+    def initialize(socketpath = nil)
+      @socketpath = socketpath ? socketpath : get_socketpath
+    end
+
+    # Connects to i3-ipc server socket using Socket::UNIXSocket.
+    # Does nothing if already connected.
+    def connect
+      @socket = UNIXSocket.new(@socketpath) unless @socket
+    end
+
+    # Disconnects from i3-ipc server socket.
+    # Does nothing if not connected.
+    def disconnect
+      @socket && @socket.close
+      @socket = nil
+    end
+
+    # Sends packed message to i3-ipc server socket.
+    #
+    # Throws:
+    # * NotConnected if protocol is not connected.
+    #
+    # +type+: type of the message.
+    # +payload+: payload of the message
+    def send(type, payload = nil)
+      check_connected
+      @socket.write(pack(type, payload))
+    end
+
+    # Receives message from i3-ipc server socket.
+    #
+    # Throws:
+    # * NotConnected if protocol is not connected.
+    # * WrongMagicString if got message with not expected magic string.
+    # * WrongType if got message with not expected magic type.
+    #
+    # +type+: expected type of the message.
+    def receive(type = nil)
+      check_connected
+      # length of "i3-ipc" + 4 bytes length + 4 bytes type
+      data = @socket.read 14
+      magic, len, recv_type = unpack_header(data)
+
+      raise WrongMagicString.new(magic) unless MAGIC_STRING.eql? magic
+      type && (raise WrongType.new(type, recv_type) unless type == recv_type)
+
+      @socket.read(len)
+    end
+
+    private
+
+    # Packs the message.
+    # A typical message looks like:
+    #   <header><payload>
+    # where a header is:
+    #   <magic string><message length><message type>
+    #
+    # +type+: type of the message
+    # +payload+: patload of the message
+    def pack(type, payload=nil)
+      size = payload ? payload.to_s.bytes.count : 0
+      msg = MAGIC_STRING + [size, type].pack("LL")
+      msg << payload.to_s if payload
+      msg
+    end
+
+    # Unpacks the header.
+    # A typical header looks like:
+    #   <magic_string><message length><message type>
+    #
+    # +data+: data to be unpacked.
+    def unpack_header(data)
+      struct_header_len = MAGIC_STRING.size
+      magic_message = data[0, struct_header_len]
+      len, type = data[struct_header_len..-1].unpack("LL")
+      [magic_message, len, type]
+    end
+
+    def get_socketpath
+      path = `i3 --get-socketpath`.chomp!
+      raise 'Unable to get i3 socketpath' unless path
+      path
+    end
+
+    def check_connected
+      raise NotConnected unless @socket
+    end
+  end
+end

data/lib/i3ipc/reply.rb

@@ -0,0 +1,116 @@
+require 'json'
+
+module I3Ipc
+  # Wrapper for reply from i3-ipc.
+  #
+  # Represents response from i3 as object tree.
+  #
+  # Able to parse Numeric, String, TrueClass, FalseClass,
+  # Array, Hash from passed JSON string.
+  #
+  # For example:
+  #  response = Reply.parse(
+  #   %Q{
+  #      {
+  #       "name": "LVDS1",
+  #       "active": true,
+  #       "current_workspace": "4",
+  #       "rect": {
+  #        "x": 0,
+  #        "y": 0,
+  #        "width": 1280,
+  #        "height": 800
+  #       }
+  #      }
+  #    }
+  #  )
+  #
+  #  p response.name        # => "LVDS1"
+  #  p response.active      # => true
+  #  p response.rect.width  # => 1280
+  #  # ...
+  #
+  #  response = Reply.parse(%Q{ {"data": [{"key1": true}, {"key2": false}]} })
+  #  p response.data[0].key1 # => true
+  #  p response.data[0].key2 # => false
+  class Reply
+    def initialize(data)
+      @data = data.dup
+    end
+
+    # Parses response from I3-ipc protocol.
+    #
+    # Returns Reply object with dynamically accessed values.
+    #
+    # +response+: string, that represents response from i3 in json format.
+    def self.parse(response)
+      parse_data JSON.parse(response)
+    end
+
+    # Returns false if this reply represents and error
+    # from i3-ipc protocol. Otherwise returns true, which
+    # meens that request is successful and reply has some
+    # data.
+    def success?
+      not self.respond_to? :error
+    end
+
+    def method_missing(name, *args, &block)
+      if @data.include?(name)
+        raise ArgumentError.new('wrong number of arguments (%d for 0)' % args.length) if args.length > 0
+        return @data[name]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if @data.include?(method_sym)
+        true
+      else
+        super
+      end
+    end
+
+    def to_s
+      JSON.pretty_generate(to_h)
+    end
+
+    def to_h
+      data = @data.dup
+      data.each do |k, v|
+        data[k] = Reply.unparse_data v
+      end
+    end
+
+    private
+
+    def self.parse_data(data)
+      case data
+      when Numeric, String, TrueClass, FalseClass, NilClass
+        return data
+      when Array
+        return data.map {|v| parse_data(v)}
+      when Hash
+        data.each do |k, v|
+          data[k] = parse_data v
+        end
+        return Reply.new(Hash[data.map {|k, v| [k.to_sym, v]}])
+      else
+        raise "Unable to parse data of type #{data.class}"
+      end
+    end
+
+    def self.unparse_data(data)
+      case data
+      when Numeric, String, TrueClass, FalseClass, NilClass
+        data
+      when Reply
+        data.to_h
+      when Array
+        data.map! {|x| self.unparse_data(x)}
+        data
+      end
+    end
+  end
+end

data/lib/i3ipc/version.rb

@@ -0,0 +1,3 @@
+module I3ipc
+  VERSION = "0.1.0"
+end

data/spec/i3_mock_server.rb

@@ -0,0 +1,57 @@
+require 'socket'
+require 'fileutils'
+
+module I3Ipc
+  # Simple socket server that communicates with
+  # client simulating i3-ipc messages.
+  class I3MockServer
+    SOCKET_PATH = '/tmp/i3-mock-server.sock'
+
+    def initialize
+      remove_sock
+      @server = UNIXServer.new(SOCKET_PATH)
+    end
+
+    def accept_client
+      @client = @server.accept_nonblock
+      self
+    rescue IO::WaitReadable, Errno::EINTR
+      nil
+    end
+
+    def client_alive?
+      return false unless @client
+      @client.write 'hi'
+      true
+    rescue Errno::EPIPE
+      false
+    end
+
+    def receive(len)
+      raise 'Client not accepted yet' unless @client
+      @client.read(len)
+    end
+
+    def send(data)
+      raise 'Client not accepted yet' unless @client
+      @client.write(data)
+    end
+
+    def close_client
+      @client.close if @client
+      @client = nil
+    end
+
+    def close
+      close_client
+      @server.close unless @server.closed?
+      remove_sock
+    end
+
+    private
+
+    def remove_sock
+      FileUtils.rm(SOCKET_PATH) if File.exist?(SOCKET_PATH)
+    end
+  end
+end

data/spec/i3ipc/connection_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module I3Ipc
+  describe Connection do
+
+    describe '#command' do
+
+      before(:all) do
+        class Connection
+          def initialize
+            @protocol = Protocol.new ''
+          end
+        end
+      end
+
+      it 'returns Reply object' do
+        allow_any_instance_of(Protocol).to receive(:send)
+        allow_any_instance_of(Protocol).to receive(:receive)
+          .and_return("{}")
+
+        expect(Connection.new.command('cmd')).to be_a Reply
+      end
+
+      it 'sends correct command and receives success response' do
+        allow_any_instance_of(Protocol).to receive(:send)
+        allow_any_instance_of(Protocol).to receive(:receive)
+          .and_return(%Q[{"success": true}])
+
+        connection = Connection.new
+        reply = connection.command('focus left')
+        expect(reply.success).to be true
+      end
+
+      it 'sends incorrect command and receives error response' do
+        allow_any_instance_of(Protocol).to receive(:send)
+        allow_any_instance_of(Protocol).to receive(:receive)
+          .and_return(%Q[{"success": false, "error": "wrong command"}])
+
+        connection = Connection.new
+        reply = connection.command('my command')
+        expect(reply.success).to be false
+        expect(reply.error).to eql 'wrong command'
+      end
+    end
+  end
+end

data/spec/i3ipc/protocol_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module I3Ipc
+  describe Protocol do
+
+    before(:all) do
+      # open internal methods for verification needs
+      class Protocol
+        public :pack, :unpack_header
+      end
+    end
+
+    before(:each, :i3 => :simulate) do
+      @i3_srv = I3MockServer.new
+      subject.connect
+      @i3_srv.accept_client
+    end
+
+    after(:each, :i3 => :simulate) do
+      @i3_srv.close
+      subject.disconnect
+    end
+
+    subject { Protocol.new(I3MockServer::SOCKET_PATH) }
+
+    it 'has MAGIC_STRING string constant' do
+      expect(Protocol::MAGIC_STRING).to be_a String
+    end
+
+    describe '#connect' do
+      it 'fails to connect if server not running' do
+        expect { subject.connect }.to raise_error Errno::ENOENT
+      end
+
+      it 'connects if server running', :i3 => :simulate do
+        expect(@i3_srv.client_alive?).to be true
+      end
+
+      it 'reconnects if disconnected', :i3 => :simulate do
+        subject.disconnect
+        subject.connect
+        expect(@i3_srv.accept_client.client_alive?).to be true
+      end
+
+      it 'does nothing if already connected', :i3 => :simulate do
+        subject.connect
+        expect(@i3_srv.accept_client).to be nil
+        expect(@i3_srv.client_alive?).to be true
+      end
+    end
+
+    describe '#disconnect', :i3 => :simulate do
+      it 'disconnects if connected' do
+        subject.disconnect
+        expect(@i3_srv.client_alive?).to be false
+      end
+
+      it 'does nothing if aready disconnected' do
+        subject.disconnect
+        subject.disconnect
+        expect(@i3_srv.client_alive?).to be false
+      end
+    end
+
+    describe '#send', :i3 => :simulate do
+      let(:type) { 42 }
+      let(:message) { 'test_send' }
+
+      it 'is able to send packed type' do
+        subject.send(type)
+
+        data = @i3_srv.receive(14)
+        header = subject.unpack_header data
+        expect(header).to match_array [Protocol::MAGIC_STRING, 0, type]
+      end
+
+      it 'is able to send packed type and payload' do
+        subject.send(type, message)
+
+        data = @i3_srv.receive(14)
+        header = subject.unpack_header data
+        expect(header).to match_array [Protocol::MAGIC_STRING, message.size, type]
+
+        data = @i3_srv.receive(header[1])
+        expect(data).to eq message
+      end
+
+      it 'throws error if not connected' do
+        subject.disconnect
+        expect { subject.send(type) }.to raise_error
+      end
+    end
+
+    describe '#receive', :i3 => :simulate do
+      let(:type) { 40 }
+      let(:message) { 'test_receive' }
+
+      context 'if server send packed message' do
+        before (:each) do
+          data = subject.pack(type, message)
+          @i3_srv.send(data)
+        end
+
+        it 'returns unpacked message' do
+          recv_message = subject.receive
+          expect(recv_message).to eq(message)
+        end
+
+        it 'throws WrongType if received type does not match expected one' do
+          expect { subject.receive(type + 1) }.to raise_error Protocol::WrongType
+        end
+      end
+
+      context 'if server send wrong message' do
+        before (:each) do
+          data = 'i4-ipc' + [message.size, type].pack("LL") + message
+          @i3_srv.send(data)
+        end
+
+        it 'throws WrongMagicString' do
+          expect { subject.receive(type) }.to raise_error Protocol::WrongMagicString
+        end
+      end
+
+      it 'throws error if not connected' do
+        subject.disconnect
+        expect { subject.receive }.to raise_error Protocol::NotConnected
+      end
+    end
+  end
+end
+

data/spec/i3ipc/reply_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module I3Ipc
+  describe Reply do
+
+    describe '.parse' do
+      context 'when valid JSON string passed' do
+
+        it 'properly parses boolean attributes' do
+          expect(Reply.parse('{"success": true}').success).to be true
+          expect(Reply.parse('{"success": false}').success).to be false
+        end
+
+        it 'properly parses numeric attributes' do
+          reply = Reply.parse(%Q[{ "int": 2, "float": 4.2 }])
+          expect(reply.int).to eql 2
+          expect(reply.float).to eql 4.2
+        end
+
+        it 'properly parses string attributes' do
+          expect(Reply.parse('{"output": "LVDS1"}').output).to eql "LVDS1"
+        end
+
+        it 'properly parses array of hashes' do
+          reply = Reply.parse( %Q[{ "arr": [{"key1": true}, {"key2": false}] }])
+          expect(reply.arr[0].key1).to be true
+          expect(reply.arr[1].key2).to be false
+        end
+
+        it 'properly parses sub-hashes' do
+          reply = Reply.parse(%Q[{ "ha":{ "key1": "val1", "key2": "val2"} }])
+          expect(reply.ha.key1).to eql 'val1'
+          expect(reply.ha.key2).to eql 'val2'
+        end
+
+        it 'properly parses sub-arrays' do
+          reply = Reply.parse(%Q[{ "arr": [[ 1, 2 ]] }])
+          expect(reply.arr[0]).to match_array [1, 2]
+        end
+
+        it 'properly parses empty array' do
+          reply = Reply.parse(%Q[{"ar" : []}])
+          expect(reply.ar).to be_a Array
+          expect(reply.ar).to be_empty
+        end
+
+        it 'property parses empty hash' do
+          reply = Reply.parse(%Q[{"ha": {}}]);
+          expect(reply.ha).to be_a Reply
+          expect(reply.ha.to_s).to eq "{\n}"
+        end
+
+        it 'returns new Reply object' do
+          expect(Reply.parse('{}')).to be_a Reply
+        end
+      end
+
+      context 'when NOT valid JSON string passed' do
+        it 'raise JSON::ParserError' do
+          expect{Reply.parse(%Q[{"data": }])}.to raise_error JSON::ParserError
+        end
+      end
+    end
+
+    describe '#success?' do
+      it 'returns true if response without error' do
+        reply = Reply.parse(%Q[{}])
+        expect(reply.success?).to be true
+      end
+
+      it 'returns false if response with error' do
+        reply = Reply.parse(%Q[{"error": "Wrong command"}])
+        expect(reply.success?).to be false
+        expect(reply.error).to eql 'Wrong command'
+      end
+    end
+
+    describe '#to_h' do
+      it 'converts it back to hash' do
+        hash = {:f => 1, :a => 2, :inner => {:ar => [true, false, "v"]}}
+        reply = Reply.parse(hash.to_json)
+        expect(reply.to_h). to eql hash
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns property formatter structure with hash, arrays and primitives' do
+        reply = Reply.parse(%Q[{"d":{"1":[{"k":"v"}]} }])
+        expect(reply.to_s).to eql "{\n  \"d\": {\n    \"1\": [\n      {\n        \"k\": \"v\"\n      }\n    ]\n  }\n}"
+      end
+    end
+
+    describe '#method_missing' do
+      it 'returns value with dynamic method based on input data' do
+        expect(Reply.new({:meth => 'val'}).meth).to eql 'val'
+      end
+
+      it 'throws ArgumentError if one or more parameters passed to dynamic method' do
+        expect{ Reply.new({:meth => 'val'}).meth(0) }.to raise_error ArgumentError
+      end
+
+      it 'still throws NoMethodError if not existed method called' do
+        expect{ Reply.new({:meth => 'val'}).no_such_method }.to raise_error NoMethodError
+      end
+    end
+
+    describe '#respond_to' do
+      it 'responds to method from input data' do
+        expect(Reply.new({:meth => 'val'})).to respond_to :meth
+      end
+
+      it 'still does not respond to not existed methods' do
+        expect(Reply.new({:meth => 'val'})).not_to respond_to :no_such_method
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'i3ipc'
+
+require 'i3ipc/protocol'
+require 'i3ipc/reply'
+require 'i3ipc/connection'
+
+require 'i3_mock_server'
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: i3ipc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vitalii Elengaupt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+      Implementation of interface for i3 tiling window manager.
+      Useful for example to remote-control i3 or to get various
+      information like the current workspace to implement an
+      external workspace bar etc. in Ruby language.
+email:
+- velenhaupt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- i3ipc.gemspec
+- lib/i3ipc.rb
+- lib/i3ipc/connection.rb
+- lib/i3ipc/protocol.rb
+- lib/i3ipc/reply.rb
+- lib/i3ipc/version.rb
+- spec/i3_mock_server.rb
+- spec/i3ipc/connection_spec.rb
+- spec/i3ipc/protocol_spec.rb
+- spec/i3ipc/reply_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/veelenga/i3ipc-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Interprocess communication with i3 wm
+test_files:
+- spec/i3_mock_server.rb
+- spec/i3ipc/connection_spec.rb
+- spec/i3ipc/protocol_spec.rb
+- spec/i3ipc/reply_spec.rb
+- spec/spec_helper.rb
+has_rdoc: