Namespaces cleanups

[pitr-ch]

go through whole gem and make sure name-spacing is fine everywhere. It will be hard to correct after 1.0 release. One thing comes in mind the name-spacing around atomic reference (result of the gem merge) is little inconsistent, there may be more. Check Concurrent.methods for pollution. Hide constants which are not part of public API.

[pitr-ch]

Use similar documentation friendly pattern for the different implementations:

module Synchronization
    Implementation = case
                     when Concurrent.on_jruby?
                       JavaObject
                     when Concurrent.on_cruby? && (RUBY_VERSION.split('.').map(&:to_i) <=> [1, 9, 3]) <= 0
                       MonitorObject
                     when Concurrent.on_cruby?
                       MutexObject
                     when Concurrent.on_rbx?
                       RbxObject
                     else
                       MutexObject
                     end
    private_constant :Implementation

    class Object < Implementation
    end
  end

[jdantonio]

The naming of Atomic was a conversation in gitter earlier this week. My suggestion from that conversation:

We've considered changing the name of Concurrent::Atomic to Concurrent::AtomicReference before the 1.0 release and that's still an open question. We could add an Concurrent::AtomicReference alias in 0.9 and put a deprecation warning to Concurrent::Atomic then remove Concurrent::Atomic in 1.0.

[pitr-ch]

👍 for AtomicReference

[jdantonio]

AtomicReference change was merged to master in PR #277.

[ianks]

Nice. This was important because it will allow us to differentiate between different types of AtomicReferences (i.e. AtomicMarkableReference, etc.).

[pitr-ch]

Current Concurrent namespace

ls Concurrent
constants:
  AbstractExecutorService            Configuration                  GLOBAL_IO_EXECUTOR         NULL_LOGGER               SemaphoreImplementation
  AbstractStruct                     CONFIGURATION                  GLOBAL_LOGGER              Obligation                SerialExecutorService
  AbstractThreadLocalVar             ConfigurationError             GLOBAL_MONOTONIC_CLOCK     Observable                SerializedExecution
  Async                              CopyOnNotifyObserverSet        GLOBAL_TIMER_SET           PerThreadExecutor         SerializedExecutionDelegator
  AtExit                             CopyOnWriteObserverSet         ImmediateExecutor          PriorityQueue             SettableStruct
  AtExitImplementation               CountDownLatch                 ImmutabilityError          ProcessorCounter          SimpleExecutorService
  Atomic                             CyclicBarrier                  ImmutableStruct            Promise                   SingleThreadExecutor
  AtomicBoolean                      Delay                          IndirectImmediateExecutor  PromiseExecutionError     SingleThreadExecutorImplementation
  AtomicBooleanImplementation        DependencyCounter              InitializationError        PureCountDownLatch        Synchronization
  AtomicDirectUpdate                 Dereferenceable                IVar                       ReadWriteLock             ThreadLocalVar
  AtomicFixnum                       EDGE_VERSION                   LifecycleError             RejectedExecutionError    ThreadLocalVarImplementation
  AtomicFixnumImplementation         EngineDetector                 Logging                    ResourceLimitError        ThreadPoolExecutor
  AtomicNumericCompareAndSetWrapper  Event                          MaxRestartFrequencyError   RubyCachedThreadPool      ThreadPoolExecutorImplementation
  AtomicReference                    Executor                       MultipleAssignmentError    RubyExecutorService       TimeoutError
  CachedThreadPool                   ExecutorService                MutableStruct              RubyFixedThreadPool       TimerSet
  CachedThreadPoolImplementation     FILE_MAP                       MutexAtomicBoolean         RubySingleThreadExecutor  TimerTask
  CAtomicBoolean                     FixedThreadPool                MutexAtomicFixnum          RubyThreadLocalVar        Transaction
  CAtomicFixnum                      FixedThreadPoolImplementation  MutexAtomicReference       RubyThreadPoolExecutor    TVar
  CAtomicReference                   Future                         MutexPriorityQueue         SafeTaskExecutor          VERSION
  ConcurrentUpdateError              GLOBAL_FAST_EXECUTOR           MutexSemaphore             ScheduledTask
  Condition                          GLOBAL_IMMEDIATE_EXECUTOR      MVar                       Semaphore

I would like to suggest moving all implementation classes (Mutex.., C..., etc. ) out of the main space. It's implementation detail anyway. I am not sure how to go about it though. One option would be to move these to Concurrent::Implementations namespace. Thoughts?

[jdantonio]

I've been giving this a lot of thought and in principle I agree, and I think Concurrent::Implementation, Concurrent::Internal, or Concurrent::Core (or something similar) is fine. My only concern is that this release has gotten really big (over 250 commits). I'd like to get this release out the door and begin working on improving the test suite. Since these changes are internal, perhaps we can make this change in 1.0 release?

[pitr-ch]

I think it would be better for 0.9, we can postpone it after pre thought. We should also re-consider our directory structure. Currently it's not corresponding with the namespaces which is agains usual convention and might be confusing.