celluloid 0.17.4 → 0.18.0

data/culture/gems/README.md

@@ -1,39 +0,0 @@
-# Motivation
-To achieve the higher level of modularity, Celluloid was split into small sub-projects that naturally depend on each other.
-Bundler can't handle circular dependencies properly and currently the only workaround is to list all celluloid-ish dependencies in both Gemfile and gemspec.
-This is error-prone and not efficient. Thus it was required to put some better workaround in place.
-
-# Configuration
-The list of gems and their properties are now defined in `dependencies.yml`.
-
-For example:
-
-```yml
-celluloid:
-  bundler:
-    github: celluloid/celluloid
-    branch: 0.17.0-prerelease
-celluloid-extras:
-  bundler:
-    github: celluloid/celluloid-extras
-celluloid-supervision:
-  bundler:
-    github: celluloid/celluloid-supervision
-celluloid-pool:
-  bundler:
-    github: celluloid/celluloid-pool
-celluloid-fsm:
-  bundler:
-    github: celluloid/celluloid-fsm
-timers:
-  gemspec:
-     - ~> 4.0.0
-  bundler:
-    github: celluloid/timers
-```
-
-# Modification of `gemspec` and `Gemfile`
-
-The injection of dependencies into `gemspec` and `Gemfile` is handled by `Celluloid::Sync.gems()`, which routes to either `Celluloid::Gems.gemspec` or `Celluloid::Gems.gemfile` depending on what is passed to it:
-
-* Discussed in [SYNC.md](../SYNC.md#how-do-you-install-it-in-gemfile-and-gemspec-then)

data/culture/gems/dependencies.yml

@@ -1,85 +0,0 @@
-bundler:
-  dependency: development
-
-nenv:
-  dependency: development
-
-dotenv:
-  dependency: development
-
-benchmark_suite:
-  dependency: development
-
-rubocop:
-  dependency: development
-
-transpec:
-  dependency: development
-
-pry:
-  dependency: development
-
-rake:
-  dependency: development
-
-rspec:
-  dependency: development
-
-guard-rspec:
-  dependency: development
-
-rspec-retry:
-  dependency: development
-
-coveralls:
-  dependency: development
-  gemfile:
-    require: false
-
-celluloid:
-  dependency: core
-  version: ">= 0.17.2"
-  gemfile:
-    github: celluloid/celluloid
-    branch: master
-    submodules: true
-
-celluloid-essentials:
-  dependency: module
-  gemfile:
-    github: celluloid/celluloid-essentials
-    branch: master
-    submodules: true
-
-celluloid-supervision:
-  dependency: module
-  gemfile:
-    github: celluloid/celluloid-supervision
-    branch: master
-    submodules: true
-
-celluloid-pool:
-  dependency: module
-  gemfile:
-    github: celluloid/celluloid-pool
-    branch: master
-    submodules: true
-
-celluloid-fsm:
-  dependency: module
-  gemfile:
-    github: celluloid/celluloid-fsm
-    branch: master
-    submodules: true
-
-celluloid-extras:
-  dependency: module
-  gemfile:
-    github: celluloid/celluloid-extras
-    branch: master
-    submodules: true
-
-timers:
-  version: ">= 4.1.1"
-  gemfile:
-    github: celluloid/timers

data/culture/gems/loader.rb

@@ -1,101 +0,0 @@
-require "yaml"
-
-module Celluloid
-  module Sync
-    module Gemfile
-      class << self
-        def [](dsl)
-          dsl.source("https://rubygems.org")
-          dsl.gemspec # Runs gemspec, but also @sets gem_name.
-          Gems.gemfile(dsl)
-        end
-      end
-    end
-    module Gemspec
-      class << self
-        def [](gem)
-          Gems.gemspec(gem)
-        end
-      end
-    end
-  end
-  module Gems
-    extend self
-    @gem_name = nil
-
-    undef gems rescue nil
-    def gems
-      File.expand_path("../dependencies.yml", __FILE__)
-    end
-
-    unless @dependencies ||= nil
-      @dependencies = YAML.load_file(gems) if File.exist?(gems)
-    end
-
-    unless @dependencies.is_a?(Hash) && @dependencies.any?
-      fail "Celluloid cannot find its dependencies."
-    end
-
-    undef core? rescue nil
-    def core?(name=@gem_name)
-      return false unless @dependencies[name].is_a? Hash
-      @dependencies[name]["dependency"] == "core"
-    end
-
-    undef separate? rescue nil
-    def separate?
-      !@dependencies.keys.include?(@gem_name)
-    end
-
-    undef gemspec rescue nil
-    def gemspec(gem)
-      @gem_name = gem.name
-      loader do |name, spec|
-        # Rules for dependencies, to avoid so-called circular dependency:
-        # - Only the core gem lists all the modules as runtime dependencies.
-        # - If this gem is not in the dependencies list, then it needs the core gem at runtime;
-        #   the module gems are development dependencies only. This is a depending separate gem.
-        #   There is the core gem, module gems, true dependencies, and separately depending gems.
-        # - If the dependency is a module, it is only a development dependency to other modules,
-        #   and even the core gem is a development dependency. It is not expected to be used alone.
-        meth = case spec["dependency"]
-               when "core", "module"
-                 # For the core gem, all modules are runtime dependencies.
-                 # For separate gems, only the core gem is a runtime dependency.
-                 if core? || (separate? && core?(name))
-                   :add_runtime_dependency
-                 else
-                   :add_development_dependency
-                 end
-               when "development"
-                 :add_development_dependency
-               else
-                 :add_dependency
-               end
-        gem.send(meth, name, spec["version"] || ">= 0")
-      end
-    end
-
-    undef gemfile rescue nil
-    def gemfile(dsl)
-      loader do |name, spec|
-        params = [name, spec["version"] || ">= 0"]
-        req = spec["gemfile"] || {}
-        params << req.each_with_object({}) { |(k, v), o| o[k.to_sym] = v }
-        current = dsl.dependencies.find { |d| d.name == name }
-        dsl.dependencies.delete(current) if current
-        dsl.gem(*params)
-      end
-    end
-
-    private
-
-    def loader
-      @dependencies.each do |name, spec|
-        next if name == @gem_name
-        spec ||= {}
-        yield name, spec
-      end
-    end
-  end
-end

data/culture/rubocop/README.md

@@ -1,38 +0,0 @@
-# About
-[RuboCop](https://github.com/bbatsov/rubocop) is a ruby static code analyzer.
-It's more than just a lint. It verifies the code against ruby best practices and performs code correctness analysis.
-Celluloid culture doesn't always agree with all rubocop default policies and so we provide a rubocop configuration file that overrides its default behavior.
-
-# Integration
-
-[Integrate `celluloid/culture`](../README.md#integration), then include `culture/rupocop/.rubocop.yml` in your default rubocop config.
-
-##### Add celluloid/culture as GIT submodule:
-
-* See instructions: [Integrate the `celluloid/culture` sub-module](../README.md#integration)
-
-##### Include `culture/rupocop/rubocop.yml` in the `.rubocop.yml` in the root of your project:
-```yml
-inherit_from:
-  - culture/rubocop/rubocop.yml
-```
-
-# How to add rubocop to your project
-
-The `rubocop` gem is automatically included by `Celluloid::Sync.gems` when that is [implemented](../SYNC.md).
-
-##### Add a 'rubocop' target in your `Rakefile`
-
-# Hints
-It's possible to use rubocop for autocorrection of minor problems.
-
-Always verify these changes by running:
-
-```sh
-bundle exec rubocop
-```
-
-Once you are ready to auto-corret the issues you are shown, run it with the `-a` option:
-```sh
-bundle exec rubocop -a
-```

data/culture/rubocop/lint.yml

@@ -1,8 +0,0 @@
-Lint/HandleExceptions:
-  Enabled: false
-
-Lint/LiteralInCondition:
-  Enabled: false
-
-Lint/UnusedBlockArgument:
-  Enabled: false

data/culture/rubocop/metrics.yml

@@ -1,15 +0,0 @@
-Metrics/MethodLength:
-  CountComments: false
-  Max: 20
-
-Metrics/LineLength:
-  Max: 120
-
-Metrics/CyclomaticComplexity:
-  Max: 9
-
-Metrics/PerceivedComplexity:
-  Max: 9
-
-Metrics/AbcSize:
-  Max: 20

data/culture/rubocop/rubocop.yml

@@ -1,5 +0,0 @@
-inherit_from:
-    - lint.yml
-    - metrics.yml
-    - style.yml
-    - perf.yml

data/culture/rubocop/style.yml

@@ -1,57 +0,0 @@
-Style/Documentation:
-  Enabled: false
-
-Style/ModuleFunction:
-  Enabled: false
-
-Style/AndOr:
-  Enabled: true
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/EachWithObject:
-  Enabled: true
-
-Style/InfiniteLoop:
-  Enabled: false
-
-Style/SpaceAroundEqualsInParameterDefault:
-  Enabled: false
-
-Style/SpaceInsideBlockBraces:
-  Enabled: false
-
-Style/AccessModifierIndentation:
-  Enabled: false
-
-Style/TrailingComma:
-  Enabled: true
-  EnforcedStyleForMultiline: comma
-
-Style/SpaceInsideBlockBraces:
-  Enabled: true
-  EnforcedStyle: space
-
-Style/SpaceInsideHashLiteralBraces:
-  Enabled: true
-  EnforcedStyle: no_space
-
-Style/EmptyLinesAroundAccessModifier:
-  Enabled: false
-
-Style/RescueModifier:
-  Enabled: false
-
-Style/GlobalVars:
-  Enabled: false
-
-Style/FormatString:
-  EnforcedStyle: percent
-
-Style/TrailingUnderscoreVariable:
-  Enabled: false
-
-Style/ParallelAssignment:
-  Enabled: false

data/culture/spec/gems_spec.rb

@@ -1,2 +0,0 @@
-Rspec.describe Celluloid::Gems do
-end

data/culture/spec/sync_spec.rb

@@ -1,2 +0,0 @@
-Rspec.describe Celluloid::Sync do
-end

data/culture/sync.rb

@@ -1,56 +0,0 @@
-require "forwardable"
-
-module Celluloid
-  module Sync
-    class << self
-      undef gem_path rescue nil
-      def gem_path
-        File.expand_path("../../", __FILE__)
-      end
-
-      undef gem_name rescue nil
-      def gem_name
-        Dir["#{File.expand_path('../../', __FILE__)}/*.gemspec"].first.gsub(".gemspec", "").split("/").last
-      end
-
-      undef gem_name? rescue nil
-      def gem_name?
-        !gem_name.nil?
-      end
-
-      undef lib_path rescue nil
-      def lib_path
-        File.expand_path("../../lib", __FILE__)
-      end
-
-      undef lib_gempath rescue nil
-      def lib_gempath
-        "#{lib_path}/#{gem_name.split('-').join('/')}"
-      end
-
-      undef scenario rescue nil
-      def scenario
-        File.basename($PROGRAM_NAME)
-      end
-
-      undef bundler? rescue nil
-      def bundler?
-        scenario == "bundle"
-      end
-    end
-
-    fail "Missing gemspec." unless gem_name?
-    $LOAD_PATH.push(gem_path)
-    $LOAD_PATH.push(lib_path)
-
-    # TODO: This will likely need to be done differently if INSIDE a cut gem.
-    if scenario == "bundle"
-      `cd #{gem_path}/culture; git pull origin master` if ARGV.first == "update"
-    end
-
-    require("#{gem_path}/culture/gems/loader")
-    if File.exist?(version = "#{lib_gempath}/version.rb")
-      require(version)
-    end
-  end
-end

data/culture/tasks/rspec.rake

@@ -1,5 +0,0 @@
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:rcov) do |task|
-  task.rcov = true
-end

data/culture/tasks/rubocop.rake

@@ -1,2 +0,0 @@
-require "rubocop/rake_task"
-RuboCop::RakeTask.new

data/lib/celluloid/actor/manager.rb

@@ -1,7 +0,0 @@
-module Celluloid
-  class Actor
-    class Manager
-      include Celluloid
-    end
-  end
-end

data/lib/celluloid/backported.rb

@@ -1,2 +0,0 @@
-$CELLULOID_BACKPORTED = true
-require "celluloid/autostart"

data/lib/celluloid/current.rb

@@ -1,2 +0,0 @@
-$CELLULOID_BACKPORTED = false
-require "celluloid/autostart"

data/lib/celluloid/deprecate.rb

@@ -1,21 +0,0 @@
-class Thread
-  def self.mailbox
-    Celluloid.mailbox
-  end
-
-  def self.receive(timeout = nil, &block)
-    Celluloid.receive(timeout, &block)
-  end
-end
-
-# TODO: Remove link to Interal::Logger
-module Celluloid
-  SyncCall = Call::Sync
-  EventedMailbox = Mailbox::Evented
-  InternalPool = Group::Pool
-  TaskThread = Task::Threaded
-  TaskFiber = Task::Fibered
-  ActorSystem = Actor::System
-  Task::TerminatedError = TaskTerminated
-  Task::TimeoutError = TaskTimeout
-end

data/lib/celluloid/fiber.rb

@@ -1,32 +0,0 @@
-# Fibers are hard... let's go shopping!
-begin
-  require "fiber"
-rescue LoadError => ex
-  if defined? JRUBY_VERSION
-    if RUBY_VERSION < "1.9.2"
-      raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
-    end
-
-    # Fibers are broken on JRuby 1.6.5. This works around the issue
-    if JRUBY_VERSION[/^1\.6\.5/]
-      require "jruby"
-      org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
-      class org.jruby.ext.fiber::ThreadFiber
-        field_accessor :state
-      end
-
-      class Fiber
-        def alive?
-          JRuby.reference(self).state != org.jruby.ext.fiber.ThreadFiberState::FINISHED
-        end
-      end
-    else
-      # Just in case subsequent JRuby releases have broken fibers :/
-      raise ex
-    end
-  elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
-    raise LoadError, "Celluloid requires Rubinius 1.9 mode. Please pass the -X19 flag."
-  else
-    raise ex
-  end
-end

data/lib/celluloid/managed.rb

@@ -1,3 +0,0 @@
-$CELLULOID_BACKPORTED = false
-$CELLULOID_MANAGED = true
-require "celluloid/autostart"

data/lib/celluloid/notices.rb

@@ -1,15 +0,0 @@
-module Celluloid
-  module Notices
-    class << self
-      @@notices = []
-
-      def backported
-        @@notices << [:info, "Celluloid #{Celluloid::VERSION} is running in BACKPORTED mode. [ http://git.io/vJf3J ]"]
-      end
-
-      def output
-        @@notices.each { |type, notice| Celluloid::Internals::Logger.send type, notice }
-      end
-    end
-  end
-end

data/spec/deprecate/actor_system_spec.rb

@@ -1,72 +0,0 @@
-RSpec.describe "Deprecated Celluloid::ActorSystem" do
-  subject { Celluloid::ActorSystem.new }
-
-  class DeprecatedTestActor
-    include Celluloid
-  end
-
-  it "supports non-global ActorSystem" do
-    subject.within do
-      expect(Celluloid.actor_system).to eq(subject)
-    end
-  end
-
-  it "starts default actors" do
-    subject.start
-    expect(subject.registered).to eq(Celluloid::ActorSystem::ROOT_SERVICES.map { |r| r[:as] })
-    subject.shutdown
-  end
-
-  it "support getting threads" do
-    subject.start
-    queue = Queue.new
-    thread = subject.get_thread do
-      expect(Celluloid.actor_system).to eq(subject)
-      queue << nil
-    end
-    queue.pop
-    subject.shutdown
-  end
-
-  it "allows a stack dump" do
-    expect(subject.stack_dump).to be_a(Celluloid::StackDump)
-  end
-
-  it "returns named actors" do
-    subject.start
-
-    subject.within do
-      DeprecatedTestActor.supervise_as :test
-    end
-
-    expect(subject.registered).to include(:test)
-    subject.shutdown
-  end
-
-  it "returns running actors" do
-    expect(subject.running).to be_empty
-
-    first = subject.within do
-      DeprecatedTestActor.new
-    end
-
-    second = subject.within do
-      DeprecatedTestActor.new
-    end
-
-    expect(subject.running).to eq([first, second])
-    subject.shutdown
-  end
-
-  it "shuts down" do
-    subject.shutdown
-
-    expect { subject.get_thread }
-      .to raise_error(Celluloid::NotActive)
-  end
-
-  it "warns nicely when no actor system is started" do
-    expect { DeprecatedTestActor.new }
-      .to raise_error("Celluloid is not yet started; use Celluloid.boot")
-  end
-end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/block_spec.rb

@@ -1,52 +0,0 @@
-RSpec.describe "Deprecated Blocks", actor_system: :global do
-  class DeprecatedBlockActor
-    include Celluloid
-
-    def initialize(name)
-      @name = name
-    end
-    attr_reader :name
-
-    def ask_for_something(other)
-      sender_actor = current_actor
-      $data << [:outside, @name, current_actor.name]
-      other.do_something_and_callback do |value|
-        $data << [:yielded, @name, current_actor.name]
-        $data << receive_result(:self)
-        $data << current_actor.receive_result(:current_actor)
-        $data << sender_actor.receive_result(:sender)
-        "somevalue"
-      end
-    end
-
-    def do_something_and_callback
-      $data << [:something, @name, current_actor.name]
-      $data << yield(:foo)
-    end
-
-    def receive_result(result)
-      [result, @name, current_actor.name]
-    end
-  end
-
-  it "works" do
-    $data = []
-
-    a1 = DeprecatedBlockActor.new("one")
-    a2 = DeprecatedBlockActor.new("two")
-
-    a1.ask_for_something a2
-
-    expected = [
-      [:outside, "one", "one"],
-      [:something, "two", "two"],
-      [:yielded, "one", "one"],
-      [:self, "one", "one"],
-      [:current_actor, "one", "one"],
-      [:sender, "one", "one"],
-      "somevalue",
-    ]
-
-    expect($data).to eq(expected)
-  end
-end unless $CELLULOID_BACKPORTED == false

data/spec/deprecate/calls_spec.rb

@@ -1,39 +0,0 @@
-RSpec.describe "Deprecated Celluloid::SyncCall", actor_system: :global do
-  subject { Celluloid::SyncCall.new }
-
-  let(:actor) { DeprecatedCallExampleActor.new }
-
-  context "when obj does not respond to a method" do
-    it "raises a NoMethodError" do
-      expect do
-        actor.the_method_that_wasnt_there
-      end.to raise_exception(NoMethodError)
-      expect(actor).to be_alive
-    end
-
-    context "when obj raises during inspect" do
-      it "should emulate obj.inspect" do
-        expect(actor).to_not receive(:inspect)
-        expect { actor.no_such_method }.to raise_exception(
-          NoMethodError,
-          /undefined method `no_such_method' for #\<DeprecatedCallExampleActor:0x[a-f0-9]+>/,
-        )
-      end
-    end
-  end
-
-  it "aborts with ArgumentError when a method is called with too many arguments" do
-    expect do
-      actor.actual_method("with too many arguments")
-    end.to raise_exception(ArgumentError)
-
-    expect(actor).to be_alive
-  end
-
-  it "preserves call chains across synchronous calls" do
-    actor2 = DeprecatedCallExampleActor.new(actor)
-
-    uuid, next_actor_uuid = actor2.chained_call_ids
-    expect(uuid).to eq next_actor_uuid
-  end
-end unless $CELLULOID_BACKPORTED == false