celluloid 0.16.0 → 0.17.0

data/culture/celluloid-culture.gemspec

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "celluloid-culture"
+  spec.version       = "0.1.1"
+  spec.authors       = ["Tony Arcieri"]
+  spec.email         = ["bascule@gmail.com"]
+
+  spec.summary       = "The culture of Celluloid, in RubyGem form!"
+  spec.description   = "In which we try to codify Celluloid's life philosophy as Ruby"
+  spec.homepage      = "https://github.com/celluloid/culture"
+
+  spec.files        = Dir["README.md", "CHANGES.md", "LICENSE.txt", "lib/**/*", "spec/**/*"]
+  spec.require_path = "lib"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake",    "~> 10.0"
+end

data/culture/gems/README.md

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,78 @@
+bundler:
+nenv:
+dotenv:
+
+benchmark_suite:
+  dependency: development
+
+rubocop:
+  dependency: development
+
+pry:
+  dependency: development
+
+rake:
+  dependency: development
+
+rspec:
+  dependency: development
+
+coveralls:
+  dependency: development
+  gemfile:
+    require: false
+
+celluloid:
+  dependency: core
+  version: ">= 0.17.0.pre12"
+  gemfile:
+    github: celluloid/celluloid
+    branch: 0.17.0-prerelease
+    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.0.0"
+  gemfile:
+    github: celluloid/timers
+
+rspec-logsplit:
+  version: ">= 0.1.2"
+  gemfile:
+    github: "abstractive/rspec-logsplit"
+    branch: "master"
+    require: false

data/culture/gems/loader.rb

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,38 @@
+# 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

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

data/culture/rubocop/metrics.yml

@@ -0,0 +1,15 @@
+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

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

data/culture/rubocop/style.yml

@@ -0,0 +1,48 @@
+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

data/culture/spec/gems_spec.rb

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

data/culture/spec/sync_spec.rb

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

data/culture/sync.rb

@@ -0,0 +1,56 @@
+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

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

data/culture/tasks/rubocop.rake

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

data/examples/basic_usage.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/autostart"
+
+class Counter
+  # This is all you have to do to turn any Ruby class into one which creates
+  # Celluloid actors instead of normal objects
+  include Celluloid
+
+  # Now just define methods like you ordinarily would
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def increment(n = 1)
+    @count += n
+  end
+end
+
+# Create objects just like you normally would. 'actor' is now a proxy object
+# which talks to a Celluloid actor running in its own thread
+actor = Counter.new
+
+# The proxy obeys normal method invocation the way we'd expect. This prints 0
+p actor.count
+
+# This increments @count by 1 and prints 1
+p actor.increment
+
+# By using actor.async, you can make calls asynchronously. This immediately
+# requests execution of method by sending a message, and we have no idea
+# whether or not that request will actually complete because we don't wait
+# for a response. Async calls immediately return nil regardless of how long
+# the method takes to execute. Therefore, this will print nil.
+p actor.async.increment 41
+
+# In practice, the asynchronous call made above will increment the count before
+# we get here. However, do not rely on this behavior! Asynchronous methods are
+# inherently uncoordinated. If you need to coordinate asynchronous activities,
+# you will need to use futures or FSMs. See the corresponding examples for those.
+# Signals can also be used to coordinate asynchronous activities.
+#
+# The following line could possibly print either 1 or 42, depending on if the
+# asynchronous call above completed. In practice, it prints 42 on all Ruby
+# implementations because the asynchronous call above will always execute
+p actor.count