ione 1.0.0.pre1 → 1.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5daae8dfb48089c7dbff04dfc53bb454b5153e5d
-  data.tar.gz: 770290ce9dd80b0633d21a5674ae6e497a6e5e9c
+  metadata.gz: 72e65e6b94938777a27d3baf72acda5bb56dc206
+  data.tar.gz: ecfaf4523b57f11061d0548be4c4649d54ab1e8d
 SHA512:
-  metadata.gz: 7dce6e221b06510f9551a00df5461bd179500f51c3332b55fb6530f7385ca87fe9f8db2fdaeea516b1534400aa1f5701435abc20aa34ca46287476beb9dbb8c9
-  data.tar.gz: e341558ccaf6cbafc59846793d542eb162726927f3499acd6ad950fbd4a40d3e99a69455d501cbae07997b18ed474913f7612dda6e70bdfdcb145244ecfc72bd
+  metadata.gz: 8576c5a7b533d37597d874bbca5dd92ff9385afbdfdb730328307d4dd8eac8be17efddf1445655367e422ada2215aeec5814f4c11505a5db5ea9d1deb061ff39
+  data.tar.gz: 8de121c515e8a25ec2208d47da67eeb5b7771036c8358f92c3e087e4862b5667408d5c1256f8777765ba0ec03d3eebf0cac868e62bc09e8cea92661cd3606104

data/README.md

@@ -1,12 +1,35 @@
 # Ione
 
 [![Build Status](https://travis-ci.org/iconara/ione.png?branch=master)](https://travis-ci.org/iconara/ione)
+[![Coverage Status](https://coveralls.io/repos/iconara/ione/badge.png)](https://coveralls.io/r/iconara/ione)
 [![Blog](http://b.repl.ca/v1/blog-ione-ff69b4.png)](http://architecturalatrocities.com/tagged/ione)
 
 _If you're reading this on GitHub, please note that this is the readme for the development version and that some features described here might not yet have been released. You can find the readme for a specific version either through [rubydoc.info](http://rubydoc.info/find/gems?q=ione) or via the release tags ([here is an example](https://github.com/iconara/ione/tree/v1.0.0.pre0))._
 
 Ione is a framework for reactive programming in Ruby. It is based on the reactive core of [cql-rb](http://github.com/iconara/cql-rb), the Ruby driver for Cassandra.
 
+# Features
+
+## Futures & promises
+
+At the core of Ione is a futures API. Futures make it easy to compose asynchronous operations.
+
+## Evented IO
+
+A key piece of the framework is an IO reactor with which you can easily build network clients and servers.
+
+### Byte buffer
+
+Networking usually means pushing lots of bytes around and in Ruby it's easy to make the mistake of using strings as buffers. Ione provides an efficient byte buffer implementation as an alternative.
+
+# Examples
+
+The [examples](https://github.com/iconara/ione/tree/master/examples) directory has some examples of what you can do with Ione, for example:
+
+* [redis_client](https://github.com/iconara/ione/tree/master/examples/redis_client) is a more or less full featured Redis client that uses most of Ione's features.
+* [http_client](https://github.com/iconara/ione/tree/master/examples/http_client) is a simplistic HTTP client that uses Ione and [http_parser.rb](http://rubygems.org/gems/http_parser.rb) to make HTTP GET request.
+* [cql-rb](https://github.com/iconara/cql-rb) is a high performance Cassandra driver and where Ione was originally developed.
+
 # How to contribute
 
 [See CONTRIBUTING.md](CONTRIBUTING.md)

data/lib/ione/byte_buffer.rb

@@ -15,12 +15,17 @@ module Ione
   # and reads read from the read buffer until it is empty, then a new write
   # buffer is created and the old write buffer becomes the new read buffer.
   class ByteBuffer
-    def initialize(initial_bytes='')
+    def initialize(initial_bytes=nil)
       @read_buffer = ''
-      @write_buffer = ''
       @offset = 0
       @length = 0
-      append(initial_bytes) unless initial_bytes.empty?
+      if initial_bytes && !initial_bytes.empty?
+        @write_buffer = initial_bytes.dup
+        @write_buffer.force_encoding(::Encoding::BINARY)
+        @length = @write_buffer.bytesize
+      else
+        @write_buffer = ''
+      end
     end
 
     # Returns the number of bytes in the buffer.
@@ -73,6 +78,7 @@ module Ione
     # @return [Ione::ByteBuffer] itself
     # @raise RangeError when there are not enough bytes in the buffer
     def discard(n)
+      raise RangeError, 'Cannot discard a negative number of bytes' if n < 0
       raise RangeError, "#{n} bytes to discard but only #{@length} available" if @length < n
       @offset += n
       @length -= n
@@ -86,6 +92,7 @@ module Ione
     #   with `Encoding::BINARY`.
     # @raise RangeError when there are not enough bytes in the buffer
     def read(n)
+      raise RangeError, 'Cannot read a negative number of bytes' if n < 0
       raise RangeError, "#{n} bytes required but only #{@length} available" if @length < n
       if @offset >= @read_buffer.bytesize
         swap_buffers
@@ -165,6 +172,20 @@ module Ione
       b
     end
 
+    def index(substring, start_index=0)
+      if @offset >= @read_buffer.bytesize
+        swap_buffers
+      end
+      read_buffer_length = @read_buffer.bytesize
+      if start_index < read_buffer_length - @offset && (index = @read_buffer.index(substring, @offset + start_index))
+        index - @offset
+      elsif (index = @write_buffer.index(substring, start_index - read_buffer_length + @offset))
+        index + read_buffer_length - @offset
+      else
+        nil
+      end
+    end
+
     # Overwrite a portion of the buffer with new bytes.
     #
     # The number of bytes that will be replaced depend on the size of the

data/lib/ione/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Ione
-  VERSION = '1.0.0.pre1'.freeze
+  VERSION = '1.0.0.pre2'.freeze
 end

data/spec/integration/io_spec.rb

@@ -48,78 +48,6 @@ describe 'An IO reactor' do
       protocol_handlers.sample.data.should == 'hello world'
     end
   end
-
-  context 'when talking to Redis' do
-    let :protocol_handler do
-      begin
-        io_reactor.connect(ENV['SERVER_HOST'], 6379, 1).map { |c| IoSpec::RedisProtocolHandler.new(c) }.value
-      rescue Ione::Io::ConnectionError
-        nil
-      end
-    end
-
-    before do
-      io_reactor.start.value
-    end
-
-    after do
-      io_reactor.stop.value
-    end
-
-    it 'can set a value' do
-      pending('Redis not running', unless: protocol_handler)
-      response = protocol_handler.send_request('SET', 'foo', 'bar').value
-      response.should == 'OK'
-    end
-
-    it 'can get a value' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'foo', 'bar').flat_map do
-        protocol_handler.send_request('GET', 'foo')
-      end
-      f.value.should == 'bar'
-    end
-
-    it 'can delete values' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'hello', 'world').flat_map do
-        protocol_handler.send_request('DEL', 'hello')
-      end
-      f.value.should == 1
-    end
-
-    it 'handles nil values' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('DEL', 'hello').flat_map do
-        protocol_handler.send_request('GET', 'hello')
-      end
-      f.value.should be_nil
-    end
-
-    it 'handles errors' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('SET', 'foo')
-      expect { f.value }.to raise_error("ERR wrong number of arguments for 'set' command")
-    end
-
-    it 'handles replies with multiple elements' do
-      pending('Redis not running', unless: protocol_handler)
-      f = protocol_handler.send_request('DEL', 'stuff')
-      f.value
-      f = protocol_handler.send_request('RPUSH', 'stuff', 'hello', 'world')
-      f.value.should == 2
-      f = protocol_handler.send_request('LRANGE', 'stuff', 0, 2)
-      f.value.should == ['hello', 'world']
-    end
-
-    it 'handles nil values when reading multiple elements' do
-      pending('Redis not running', unless: protocol_handler)
-      protocol_handler.send_request('DEL', 'things')
-      protocol_handler.send_request('HSET', 'things', 'hello', 'world')
-      f = protocol_handler.send_request('HMGET', 'things', 'hello', 'foo')
-      f.value.should == ['world', nil]
-    end
-  end
 end
 
 module IoSpec
@@ -141,143 +69,4 @@ module IoSpec
       @lock.synchronize { @data << new_data }
     end
   end
-
-  class LineProtocolHandler
-    def initialize(connection)
-      @connection = connection
-      @connection.on_data(&method(:process_data))
-      @lock = Mutex.new
-      @buffer = ''
-      @requests = []
-    end
-
-    def on_line(&listener)
-      @line_listener = listener
-    end
-
-    def write(command_string)
-      @connection.write(command_string)
-    end
-
-    def process_data(new_data)
-      lines = []
-      @lock.synchronize do
-        @buffer << new_data
-        while newline_index = @buffer.index("\r\n")
-          line = @buffer.slice!(0, newline_index + 2)
-          line.chomp!
-          lines << line
-        end
-      end
-      lines.each do |line|
-        @line_listener.call(line) if @line_listener
-      end
-    end
-  end
-
-  class RedisProtocolHandler
-    def initialize(connection)
-      @line_protocol = LineProtocolHandler.new(connection)
-      @line_protocol.on_line(&method(:handle_line))
-      @lock = Mutex.new
-      @responses = []
-      @state = BaseState.new(method(:handle_response))
-    end
-
-    def send_request(*args)
-      promise = Ione::Promise.new
-      @lock.synchronize do
-        @responses << promise
-      end
-      request = "*#{args.size}\r\n"
-      args.each do |arg|
-        arg_str = arg.to_s
-        request << "$#{arg_str.bytesize}\r\n#{arg_str}\r\n"
-      end
-      @line_protocol.write(request)
-      promise.future
-    end
-
-    def handle_response(result, error=false)
-      promise = @lock.synchronize do
-        @responses.shift
-      end
-      if error
-        promise.fail(StandardError.new(result))
-      else
-        promise.fulfill(result)
-      end
-    end
-
-    def handle_line(line)
-      @state = @state.handle_line(line)
-    end
-
-    class State
-      def initialize(result_handler)
-        @result_handler = result_handler
-      end
-
-      def complete!(result)
-        @result_handler.call(result)
-      end
-
-      def fail!(message)
-        @result_handler.call(message, true)
-      end
-    end
-
-    class BulkState < State
-      def handle_line(line)
-        complete!(line)
-        BaseState.new(@result_handler)
-      end
-    end
-
-    class MultiBulkState < State
-      def initialize(result_handler, expected_elements)
-        super(result_handler)
-        @expected_elements = expected_elements
-        @elements = []
-      end
-
-      def handle_line(line)
-        if line.start_with?('$')
-          line.slice!(0, 1)
-          if line.to_i == -1
-            @elements << nil
-          end
-        else
-          @elements << line
-        end
-        if @elements.size == @expected_elements
-          complete!(@elements)
-          BaseState.new(@result_handler)
-        else
-          self
-        end
-      end
-    end
-
-    class BaseState < State
-      def handle_line(line)
-        next_state = self
-        first_char = line.slice!(0, 1)
-        case first_char
-        when '+' then complete!(line)
-        when ':' then complete!(line.to_i)
-        when '-' then fail!(line)
-        when '$'
-          if line.to_i == -1
-            complete!(nil)
-          else
-            next_state = BulkState.new(@result_handler)
-          end
-        when '*'
-          next_state = MultiBulkState.new(@result_handler, line.to_i)
-        end
-        next_state
-      end
-    end
-  end
 end

data/spec/ione/byte_buffer_spec.rb

@@ -175,6 +175,11 @@ module Ione
         buffer.append('hello')
         expect { buffer.discard(7) }.to raise_error(RangeError)
       end
+
+      it 'raises an error when the specified number of bytes is negative' do
+        buffer.append('hello')
+        expect { buffer.discard(-7) }.to raise_error(RangeError)
+      end
     end
 
     describe '#read' do
@@ -196,6 +201,11 @@ module Ione
         expect { buffer.discard(5).read(1) }.to raise_error(RangeError)
       end
 
+      it 'raises an error when the specified number of bytes is negative' do
+        buffer.append('hello')
+        expect { buffer.read(-4) }.to raise_error(RangeError)
+      end
+
       it 'returns a string with binary encoding' do
         buffer.append('hello')
         buffer.read(4).encoding.should == ::Encoding::BINARY
@@ -322,6 +332,30 @@ module Ione
       end
     end
 
+    describe '#index' do
+      it 'returns the first index of the specified substring' do
+        buffer.append('fizz buzz')
+        buffer.index('zz').should == 2
+      end
+
+      it 'returns the first index of the specified substring, after the specified index' do
+        buffer.append('fizz buzz')
+        buffer.index('zz', 3).should == 7
+      end
+
+      it 'returns nil when the substring is not found' do
+        buffer.append('hello world')
+        buffer.index('zz').should be_nil
+      end
+
+      it 'returns the first index of the specified substring after the buffer has been modified' do
+        buffer.append('foo bar')
+        buffer.read(1)
+        buffer.append(' baz baz')
+        buffer.index('baz', 8).should == 11
+      end
+    end
+
     context 'when reading and appending' do
       it 'handles heavy churn' do
         1000.times do

data/spec/ione/future_spec.rb

@@ -696,12 +696,26 @@ module Ione
           future.should be_resolved
         end
 
-        it 'calls callbacks immediately' do
+        it 'is completed' do
+          future.should be_completed
+        end
+
+        it 'is not failed' do
+          future.should_not be_failed
+        end
+
+        it 'calls its value callbacks immediately' do
           value = nil
           future.on_value { |v| value = v }
           value.should == 'hello world'
         end
 
+        it 'calls its complete callbacks immediately' do
+          f = nil
+          future.on_complete { |ff| f = ff }
+          f.should_not be_nil
+        end
+
         it 'does not block on #value' do
           future.value.should == 'hello world'
         end
@@ -718,16 +732,30 @@ module Ione
       end
 
       context 'returns a future which' do
-        it 'is failed when created' do
+        it 'is failed' do
           future.should be_failed
         end
 
-        it 'calls callbacks immediately' do
+        it 'is completed' do
+          future.should be_completed
+        end
+
+        it 'is not resolved' do
+          future.should_not be_resolved
+        end
+
+        it 'call its failure callbacks immediately' do
           error = nil
           future.on_failure { |e| error = e }
           error.message.should == 'bork'
         end
 
+        it 'calls its complete callbacks immediately' do
+          f = nil
+          future.on_complete { |ff| f = ff }
+          f.should_not be_nil
+        end
+
         it 'does not block on #value' do
           expect { future.value }.to raise_error('bork')
         end

data/spec/spec_helper.rb

@@ -1,8 +1,26 @@
 # encoding: utf-8
 
-require 'ione'
+ENV['SERVER_HOST'] ||= '127.0.0.1'.freeze
+
+require 'bundler/setup'
 
 require 'support/fake_server'
 require 'support/await_helper'
 
-ENV['SERVER_HOST'] ||= '127.0.0.1'.freeze
+unless ENV['COVERAGE'] == 'no' || RUBY_ENGINE == 'rbx'
+  require 'coveralls'
+  require 'simplecov'
+
+  if ENV.include?('TRAVIS')
+    Coveralls.wear!
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+
+  SimpleCov.start do
+    add_group 'Source', 'lib'
+    add_group 'Unit tests', 'spec/cql'
+    add_group 'Integration tests', 'spec/integration'
+  end
+end
+
+require 'ione'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
+  version: 1.0.0.pre2
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-01 00:00:00.000000000 Z
+date: 2014-03-15 00:00:00.000000000 Z
 dependencies: []
 description: Reactive programming framework for Ruby, painless evented IO, futures
   and an efficient byte buffer