concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/thread_pool_shared.rb

@@ -62,13 +62,12 @@ share_examples_for :thread_pool do
     end
 
     it 'allows threads to exit normally' do
-      before_thread_count = Thread.list.size
       10.times{ subject << proc{ nil } }
+      subject.length.should > 0
       sleep(0.1)
-      Thread.list.size.should > before_thread_count
       subject.shutdown
       sleep(1)
-      Thread.list.size.should == before_thread_count
+      subject.length.should == 0
     end
   end
 

data/spec/concurrent/timer_task_spec.rb

@@ -87,7 +87,37 @@ module Concurrent
       end
 
       context '#kill' do
-        pending
+
+        it 'kills its threads while sleeping' do
+          Thread.should_receive(:kill).at_least(:once).times.with(any_args)
+          task = TimerTask.new(run_now: false){ nil }
+          task.run!
+          sleep(0.1)
+          task.kill
+        end
+
+        it 'kills its threads once executing' do
+          Thread.should_receive(:kill).at_least(2).times.with(any_args)
+          task = TimerTask.new(run_now: true){ nil }
+          task.run!
+          sleep(0.1)
+          task.kill
+        end
+
+        it 'returns true on success' do
+          task = TimerTask.new(run_now: false){ nil }
+          task.run!
+          sleep(0.1)
+          task.kill.should be_true
+        end
+
+        it 'returns false on exception' do
+          Thread.stub(:kill).with(any_args).and_raise(StandardError)
+          task = TimerTask.new(run_now: false){ nil }
+          task.run!
+          sleep(0.1)
+          task.kill.should be_false
+        end
       end
     end
 

data/spec/spec_helper.rb

@@ -8,14 +8,13 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
 
 SimpleCov.start do
   project_name 'concurrent-ruby'
-  add_filter '/md/'
+  add_filter '/coverage/'
+  add_filter '/doc/'
   add_filter '/pkg/'
   add_filter '/spec/'
   add_filter '/tasks/'
 end
 
-require 'eventmachine'
-
 require 'concurrent'
 
 # import all the support files

data/spec/support/functions.rb

@@ -15,3 +15,7 @@ end
 def jruby?
   RbConfig::CONFIG['ruby_install_name']=~ /^jruby$/i 
 end
+
+def rbx?
+  RbConfig::CONFIG['ruby_install_name']=~ /^rbx$/i 
+end

data/spec/support/less_than_or_equal_to_matcher.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_less_than_or_equal_to do |expected|
+  match do |actual|
+    actual <= expected
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0.pre.1
 platform: ruby
 authors:
 - Jerry D'Antonio
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-02-03 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -25,70 +25,79 @@ files:
 - lib/concurrent.rb
 - lib/concurrent/actor.rb
 - lib/concurrent/agent.rb
+- lib/concurrent/atomic.rb
 - lib/concurrent/cached_thread_pool.rb
 - lib/concurrent/cached_thread_pool/worker.rb
 - lib/concurrent/channel.rb
-- lib/concurrent/contract.rb
+- lib/concurrent/condition.rb
+- lib/concurrent/copy_on_notify_observer_set.rb
+- lib/concurrent/copy_on_write_observer_set.rb
+- lib/concurrent/count_down_latch.rb
+- lib/concurrent/dataflow.rb
 - lib/concurrent/dereferenceable.rb
 - lib/concurrent/event.rb
-- lib/concurrent/event_machine_defer_proxy.rb
 - lib/concurrent/fixed_thread_pool.rb
 - lib/concurrent/fixed_thread_pool/worker.rb
 - lib/concurrent/future.rb
 - lib/concurrent/global_thread_pool.rb
 - lib/concurrent/immediate_executor.rb
+- lib/concurrent/ivar.rb
+- lib/concurrent/mvar.rb
 - lib/concurrent/obligation.rb
 - lib/concurrent/postable.rb
 - lib/concurrent/promise.rb
 - lib/concurrent/runnable.rb
+- lib/concurrent/safe_task_executor.rb
 - lib/concurrent/scheduled_task.rb
 - lib/concurrent/stoppable.rb
 - lib/concurrent/supervisor.rb
+- lib/concurrent/thread_local_var.rb
 - lib/concurrent/timer_task.rb
 - lib/concurrent/utilities.rb
 - lib/concurrent/version.rb
 - lib/concurrent_ruby.rb
-- md/actor.md
-- md/agent.md
-- md/channel.md
-- md/dereferenceable.md
-- md/future.md
-- md/obligation.md
-- md/promise.md
-- md/scheduled_task.md
-- md/supervisor.md
-- md/thread_pool.md
-- md/timer_task.md
 - spec/concurrent/actor_spec.rb
 - spec/concurrent/agent_spec.rb
+- spec/concurrent/atomic_spec.rb
 - spec/concurrent/cached_thread_pool_spec.rb
 - spec/concurrent/channel_spec.rb
-- spec/concurrent/contract_spec.rb
-- spec/concurrent/event_machine_defer_proxy_spec.rb
+- spec/concurrent/condition_spec.rb
+- spec/concurrent/copy_on_notify_observer_set_spec.rb
+- spec/concurrent/copy_on_write_observer_set_spec.rb
+- spec/concurrent/count_down_latch_spec.rb
+- spec/concurrent/dataflow_spec.rb
+- spec/concurrent/dereferenceable_shared.rb
 - spec/concurrent/event_spec.rb
 - spec/concurrent/fixed_thread_pool_spec.rb
 - spec/concurrent/future_spec.rb
 - spec/concurrent/global_thread_pool_spec.rb
 - spec/concurrent/immediate_executor_spec.rb
+- spec/concurrent/ivar_spec.rb
+- spec/concurrent/mvar_spec.rb
 - spec/concurrent/obligation_shared.rb
+- spec/concurrent/obligation_spec.rb
+- spec/concurrent/observer_set_shared.rb
 - spec/concurrent/postable_shared.rb
 - spec/concurrent/promise_spec.rb
 - spec/concurrent/runnable_shared.rb
 - spec/concurrent/runnable_spec.rb
+- spec/concurrent/safe_task_executor_spec.rb
 - spec/concurrent/scheduled_task_spec.rb
 - spec/concurrent/stoppable_shared.rb
 - spec/concurrent/supervisor_spec.rb
+- spec/concurrent/thread_local_var_spec.rb
 - spec/concurrent/thread_pool_shared.rb
 - spec/concurrent/timer_task_spec.rb
 - spec/concurrent/uses_global_thread_pool_shared.rb
 - spec/concurrent/utilities_spec.rb
 - spec/spec_helper.rb
 - spec/support/functions.rb
+- spec/support/less_than_or_equal_to_matcher.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -99,40 +108,51 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.1
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
 specification_version: 4
-summary: Modern concurrency tools including agents, futures, promises, thread pools,
-  actors, and more.
+summary: Modern concurrency tools including agents, futures, promises, thread pools, actors, and more.
 test_files:
+- spec/spec_helper.rb
 - spec/concurrent/actor_spec.rb
 - spec/concurrent/agent_spec.rb
+- spec/concurrent/atomic_spec.rb
 - spec/concurrent/cached_thread_pool_spec.rb
 - spec/concurrent/channel_spec.rb
-- spec/concurrent/contract_spec.rb
-- spec/concurrent/event_machine_defer_proxy_spec.rb
+- spec/concurrent/condition_spec.rb
+- spec/concurrent/copy_on_notify_observer_set_spec.rb
+- spec/concurrent/copy_on_write_observer_set_spec.rb
+- spec/concurrent/count_down_latch_spec.rb
+- spec/concurrent/dataflow_spec.rb
+- spec/concurrent/dereferenceable_shared.rb
 - spec/concurrent/event_spec.rb
 - spec/concurrent/fixed_thread_pool_spec.rb
 - spec/concurrent/future_spec.rb
 - spec/concurrent/global_thread_pool_spec.rb
 - spec/concurrent/immediate_executor_spec.rb
+- spec/concurrent/ivar_spec.rb
+- spec/concurrent/mvar_spec.rb
 - spec/concurrent/obligation_shared.rb
+- spec/concurrent/obligation_spec.rb
+- spec/concurrent/observer_set_shared.rb
 - spec/concurrent/postable_shared.rb
 - spec/concurrent/promise_spec.rb
 - spec/concurrent/runnable_shared.rb
 - spec/concurrent/runnable_spec.rb
+- spec/concurrent/safe_task_executor_spec.rb
 - spec/concurrent/scheduled_task_spec.rb
 - spec/concurrent/stoppable_shared.rb
 - spec/concurrent/supervisor_spec.rb
+- spec/concurrent/thread_local_var_spec.rb
 - spec/concurrent/thread_pool_shared.rb
 - spec/concurrent/timer_task_spec.rb
 - spec/concurrent/uses_global_thread_pool_shared.rb
 - spec/concurrent/utilities_spec.rb
-- spec/spec_helper.rb
 - spec/support/functions.rb
-has_rdoc: 
+- spec/support/less_than_or_equal_to_matcher.rb
+has_rdoc:

data/lib/concurrent/contract.rb

@@ -1,21 +0,0 @@
-require 'concurrent/obligation'
-
-module Concurrent
-
-  class Contract
-    include Obligation
-
-    def initialize(opts = {})
-      @state = :pending
-      init_mutex
-      set_deref_options(opts)
-    end
-
-    def complete(value, reason)
-      @value = value
-      @reason = reason
-      @state = ( reason ? :rejected : :fulfilled )
-      event.set
-    end
-  end
-end

data/lib/concurrent/event_machine_defer_proxy.rb

@@ -1,22 +0,0 @@
-require 'concurrent/global_thread_pool'
-
-module Concurrent
-
-  class EventMachineDeferProxy
-
-    def post(*args, &block)
-      if args.empty?
-        EventMachine.defer(block)
-      else
-        new_block = proc{ block.call(*args) }
-        EventMachine.defer(new_block)
-      end
-      return true
-    end
-
-    def <<(block)
-      EventMachine.defer(block)
-      return self
-    end
-  end
-end

data/md/actor.md

@@ -1,404 +0,0 @@
-# All the world's a stage
-
-Actor-based concurrency is all the rage in some circles. Originally described in
-1973, the actor model is a paradigm for creating asynchronous, concurrent objects
-that is becoming increasingly popular. Much has changed since actors were first
-written about four decades ago, which has led to a serious fragmentation within
-the actor community. There is *no* universally accepted, strict definition of
-"actor" and actor implementations differ widely between languages and libraries.
-
-A good definition of "actor" is:
-
-> An independent, concurrent, single-purpose, computational entity that
-> communicates exclusively via message passing.
-
-The `Concurrent::Actor` class in this library is based solely on the
-[Actor](http://www.scala-lang.org/api/current/index.html#scala.actors.Actor) task
-defined in the Scala standard library. It does not implement all the features of
-Scala's `Actor` but its behavior for what *has* been implemented is nearly identical.
-The excluded features mostly deal with Scala's message semantics, strong typing,
-and other characteristics of Scala that don't really apply to Ruby.
-
-Unlike most of the abstractions in this library, `Actor` takes an *object-oriented*
-approach to asynchronous concurrency, rather than a *functional programming*
-approach.
-
-## Definition
-
-Actors are defined by subclassing the `Concurrent::Actor` class and overriding the
-`#act` method. The `#act` method can have any signature/arity but
-
-```ruby
-def act(*args)
-```
-
-is the most flexible and least error-prone signature. The `#act` method is called in
-response to a message being post to the `Actor` instance (see *Behavior* below).
-
-## Behavior
-
-The `Concurrent::Actor` class includes the `Concurrent::Runnable` module. This provides
-an `Actor` instance with the necessary methods for running and graceful stopping.
-This also means that an `Actor` can be managed by a `Concurrent::Supervisor` for
-fault tolerance.
-
-### Message Passing
-
-Messages from any thread can be sent (aka "post") to an `Actor` using several methods.
-When a message is post all arguments are gathered together and queued for processing.
-Messages are processed in the order they are received, one at a time, on a dedicated
-thread. When a message is processed the subclass `#act` method is called and the return
-value (or raised exception) is handled by the superclass based on the rules of the method
-used to post the message.
-
-All message posting methods are compatible with observation (see below).
-
-Message processing within the `#act` method is not limited in any way, but care should
-be taken to behave in a thread-safe, concurrency-friendly manner. A common practice is for
-one `Actor` to send messages to another `Actor` though this is hardly the only approach.
-
-Messages post to an `Actor` that is not running will be rejected.
-
-#### Fire and Forget
-
-The primary method of posting a message to an `Actor` is the simple `#post` method.
-When this method is called the message is queued for processing. The method returns
-false if it cannot be queued (the `Actor` is not running) otherwise it returns the
-size of the queue (after queueing the new message). The caller thread has no way
-to know the result of the message processing. When the `#post` method is used the
-only way to act upon the result of the message processing is via observation
-(see below).
-
-#### Post with an Obligation
-
-A common theme in modern asynchronous concurrency is for operations to return a
-"future" (or "promise"). In this context a "future" is not an instance of the
-`Concurrent::Future` class, but it is an object with similar behavior. Within
-this library "future" behavior is genericized by the `Concurrent::Obligation`
-mixin module (shared by `Future`, `Promise`, and others).
-
-To post a message that returns a `Obligation` use the `#post?` method. If the message
-cannot be queued the method will return `nil`. Otherwise an object implementing
-`Obligation` will returned. The `Obligation` has the exteced states (`:pending`,
-`:fulfilled`, and `:rejected`), the expected state-named predicate methods,
-plus `#value` and `#reason`. These methods all behave identically to `Concurrent::Future`.
-
-#### Post with Timeout
-
-Threads posting messages to an `Actor` should generally not block. Blocking to wait
-for an `Actor` to process a specific message defeats the purpose of asynchronous
-concurrency. The `#post!` method is provided when the caller absolutely must block.
-The first argument to `#post!` is a number of seconds to block while waiting for the
-operation to complete. All subsequent arguments constitute the message and are
-queued for delivery to the `#act` method. If the queued operation completes within
-the timeout period the `#post!` method returns the result of the operation.
-
-Unlike most methods in this library, the `#post!` method does not suppress exceptions.
-Because the `#post!` method return value represents the result of message processing
-the return value cannot effectively communicate failure. Instead, exceptions are used.
-Calls to the `#post!` method should generally be wrapped in `rescue` guards. The
-following exceptions may be raised by the `#post!` method:
-
-* `Concurrent::Runnable::LifecycleError` will be raised if the message cannot be
-  queued, such as when the `Actor` is not running.
-* `Concurrent::TimeoutError` will be raised if the message is not processed within
-  the designated timeout period
-* Any exception raised during message processing will be re-raised after all
-  post-processing operations (such as observer callbacks) have completed
-
-When the `#post!` method results in a timeout the `Actor` will attempt to cancel
-message processing, but cancellation is not guaranteed. If message processing has
-not begun the cancellation will normally occur. If message processing is in-progress
-when `#post!` reaches timeout then processing will be allowed to complete. Code that
-uses the `#post!` method must therefore not assume that a timeout means that message
-processing did not occur.
-
-#### Implicit Forward/Reply
-
-A common idiom is for an `Actor` to send messages to another `Actor`. This creates
-a "data flow" style of design not dissimilar to Unix-style pipe commands. Less common,
-but still frequent, is for an `Actor` to send the result of message processing back
-to the `Actor` that sent the message. In Scala this is easy to do. The underlying
-message passing system implicitly communicates to the receiver the address of the
-sender. Therefore, Scala actors can easily reply to the sender. Ruby has no similar
-message passing subsystem to implicit knowledge of the sender is not possible. This
-`Actor` implementation provides a `#forward` method that encapsulates both
-aforementioned idioms. The first argument to the `#forward` method is a reference
-to another `Actor` to which the receiving `Actor` should forward the result of
-the processed messages. All subsequent arguments constitute the message and are
-queued for delivery to the `#act` method.
-
-Upon successful message processing the `Actor` superclass will automatically
-forward the result to the receiver provided when `#forward` was called. If an
-exception is raised no forwarding occurs.
-
-### Error Handling
-
-Because `Actor` mixes in the `Concurrent::Runnable` module subclasses have access to
-the `#on_error` method and can override it to implement custom error handling. The
-`Actor` base class does not use `#on_error` so as to avoid conflit with subclasses
-which override it. Generally speaking, `#on_error` should not be used. The `Actor`
-base class provides concictent, reliable, and robust error handling already, and
-error handling specifics are tied to the message posting method. Incorrect behavior
-in an `#on_error` override can lead to inconsistent `Actor` behavior that may lead
-to confusion and difficult debugging.
-
-### Observation
-
-The `Actor` superclass mixes in the Ruby standard library
-[Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html)
-module to provide consistent callbacks upon message processing completion. The normal
-`Observable` methods, including `#add_observer` behave normally. Once an observer
-is added to an `Actor` it will be notified of all messages processed *after*
-addition. Notification will *not* occur for any messages that have already been
-processed.
-
-Observers will be notified regardless of whether the message processing is successful
-or not. The `#update` method of the observer will receive four arguments. The
-appropriate method signature is:
-
-```ruby
-def update(time, message, result, reason)
-```
-
-These four arguments represent:
-
-* The time that message processing was completed
-* An array containing all elements of the original message, in order
-* The result of the call to `#act` (will be `nil` if an exception was raised)
-* Any exception raised by `#act` (or `nil` if message processing was successful)
-
-### Actor Pools
-
-Every `Actor` instance operates on its own thread. When one thread isn't enough capacity
-to manage all the messages being sent to an `Actor` a *pool* can be used instead. A pool
-is a collection of `Actor` instances, all of the same type, that shate a message queue.
-Messages from other threads are all sent to a single queue against which all `Actor`s
-load balance.
-
-## Additional Reading
-
-* [API documentation](http://www.scala-lang.org/api/current/index.html#scala.actors.Actor)
-  for the original (now deprecated) Scala Actor
-* [Scala Actors: A Short Tutorial](http://www.scala-lang.org/old/node/242)
-* [Scala Actors 101](http://java.dzone.com/articles/scala-threadless-concurrent)
-
-## Examples
-
-Two `Actor`s playing a back and forth game of Ping Pong, adapted from the Scala example
-[here](http://www.scala-lang.org/old/node/242):
-
-```ruby
-class Ping < Concurrent::Actor
-
-  def initialize(count, pong)
-    super()
-    @pong = pong
-    @remaining = count
-  end
-  
-  def act(msg)
-
-    if msg == :pong
-      print "Ping: pong\n" if @remaining % 1000 == 0
-      @pong.post(:ping)
-
-      if @remaining > 0
-        @pong << :ping
-        @remaining -= 1
-      else
-        print "Ping :stop\n"
-        @pong << :stop
-        self.stop
-      end
-    end
-  end
-end
-
-class Pong < Concurrent::Actor
-
-  attr_writer :ping
-
-  def initialize
-    super()
-    @count = 0
-  end
-
-  def act(msg)
-
-    if msg == :ping
-      print "Pong: ping\n" if @count % 1000 == 0
-      @ping << :pong
-      @count += 1
-
-    elsif msg == :stop
-      print "Pong :stop\n"
-      self.stop
-    end
-  end
-end
-
-pong = Pong.new
-ping = Ping.new(10000, pong)
-pong.ping = ping
-
-t1 = ping.run!
-t2 = pong.run!
-sleep(0.1)
-
-ping << :pong
-```
-
-A pool of `Actor`s and a `Supervisor`
-
-```ruby
-QUERIES = %w[YAHOO Microsoft google]
-
-class FinanceActor < Concurrent::Actor
-  def act(query)
-    finance = Finance.new(query)
-    print "[#{Time.now}] RECEIVED '#{query}' to #{self} returned #{finance.update.suggested_symbols}\n\n"
-  end
-end
-
-financial, pool = FinanceActor.pool(5)
-
-overlord = Concurrent::Supervisor.new
-pool.each{|actor| overlord.add_worker(actor)}
-
-overlord.run! 
-
-financial.post('YAHOO')
-
-#>> [2013-10-18 09:35:28 -0400] SENT 'YAHOO' from main to worker pool
-#>> [2013-10-18 09:35:28 -0400] RECEIVED 'YAHOO' to #<FinanceActor:0x0000010331af70>...
-```
-
-The `#post` method simply sends a message to an actor and returns. It's a
-fire-and-forget interaction.
-
-```ruby
-class EchoActor < Concurrent::Actor
-  def act(*message)
-    p message
-  end
-end
-
-echo = EchoActor.new
-echo.run!
-
-echo.post("Don't panic") #=> true
-#=> ["Don't panic"]
-
-echo.post(1, 2, 3, 4, 5) #=> true
-#=> [1, 2, 3, 4, 5]
-
-echo << "There's a frood who really knows where his towel is." #=> #<EchoActor:0x007fc8012b8448...
-#=> ["There's a frood who really knows where his towel is."]
-```
-
-The `#post?` method returns an `Obligation` (same API as `Future`) which can be queried
-for value/reason on fulfillment/rejection.
-
-```ruby
-class EverythingActor < Concurrent::Actor
-  def act(message)
-    sleep(5)
-    return 42
-  end
-end
-
-life = EverythingActor.new
-life.run!
-sleep(0.1)
-
-universe = life.post?('What do you get when you multiply six by nine?')
-universe.pending? #=> true
-
-# wait for it...
-
-universe.fulfilled? #=> true
-universe.value      #=> 42
-```
-
-The `#post!` method is a blocking call. It takes a number of seconds to wait as the
-first parameter and any number of additional parameters as the message. If the message
-is processed within the given number of seconds the call returns the result of the
-operation. If message processing raises an exception the exception is raised again
-by the `#post!` method. If the call to `#post!` times out a `Concurrent::Timeout`
-exception is raised.
-
-```ruby
-life = EverythingActor.new
-life.run!
-sleep(0.1)
-
-life.post!(1, 'Mostly harmless.')
-
-# wait for it...
-#=> Concurrent::TimeoutError: Concurrent::TimeoutError
-```
-
-And, of course, the `Actor` class mixes in Ruby's `Observable`.
-
-```ruby
-class ActorObserver
-  def update(time, message, result, ex)
-    if result
-      print "(#{time}) Message #{message} returned #{result}\n"
-    elsif ex.is_a?(Concurrent::TimeoutError)
-      print "(#{time}) Message #{message} timed out\n"
-    else
-      print "(#{time}) Message #{message} failed with error #{ex}\n"
-    end
-  end
-end
-
-class SimpleActor < Concurrent::Actor
-  def act(*message)
-    message
-  end
-end
-
-actor = SimpleActor.new
-actor.add_observer(ActorObserver.new)
-actor.run!
-
-actor.post(1)
-#=> (2013-11-07 18:35:33 -0500) Message [1] returned [1]
-
-actor.post(1,2,3)
-#=> (2013-11-07 18:35:54 -0500) Message [1, 2, 3] returned [1, 2, 3]
-
-actor.post('The Nightman Cometh')
-#=> (2013-11-07 18:36:11 -0500) Message ["The Nightman Cometh"] returned ["The Nightman Cometh"]
-```
-
-## Copyright
-
-*Concurrent Ruby* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> 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.