cuboid 0.0.0 → 0.0.1alpha

data/lib/cuboid/support/filter/base.rb

@@ -0,0 +1,110 @@
+module Cuboid
+module Support::Filter
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+# @abstract
+class Base
+
+    attr_reader :collection
+
+    DEFAULT_OPTIONS = {
+        hasher: :hash
+    }
+
+    # @param    [Set]  options
+    # @option   options [Symbol]    (:hasher)
+    #   Method to call on the item to obtain its hash.
+    def initialize( options = {} )
+        @options = DEFAULT_OPTIONS.merge( options )
+        @hasher  = @options[:hasher].to_sym
+    end
+
+    # @param    [#persistent_hash] item
+    #   Item to insert.
+    #
+    # @return   [Base]
+    #   `self`
+    def <<( item )
+        @collection << calculate_hash( item )
+        self
+    end
+
+    # @param    [#persistent_hash] item
+    #   Item to check.
+    #
+    # @return   [Bool]
+    def include?( item )
+        @collection.include? calculate_hash( item )
+    end
+
+    def empty?
+        @collection.empty?
+    end
+
+    def any?
+        !empty?
+    end
+
+    def size
+        @collection.size
+    end
+
+    def clear
+        @collection.clear
+    end
+
+    def merge( other )
+        case other
+            when self.class
+
+                @collection.merge other.collection
+
+            when Array
+
+                other.each do |k|
+                    fail 'Cannot merge with unhashed entries' if !k.is_a?( Numeric )
+                    @collection << k
+                end
+
+            else
+                fail ArgumentError,
+                     "Don't know how to merge with: #{other.class}"
+        end
+
+        self
+    end
+
+    def ==( other )
+        hash == other.hash
+    end
+
+    def hash
+        @collection.hash
+    end
+
+    def dup
+        self.class.new( @options.dup ).merge self
+    end
+
+    def _dump( _ )
+        Marshal.dump( to_rpc_data )
+    end
+
+    def self._load( data )
+        from_rpc_data Marshal.load( data )
+    end
+
+    def collection=( c )
+        @collection = c
+    end
+
+    private
+
+    def calculate_hash( item )
+        item.send @hasher
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/filter/set.rb

@@ -0,0 +1,29 @@
+require 'set'
+
+module Cuboid
+module Support::Filter
+
+# Filter based on a Set.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Set < Base
+
+    # @param    (see Base#initialize)
+    def initialize(*)
+        super
+        @collection = ::Set.new
+    end
+
+    def to_rpc_data
+        [@options, @collection.to_a]
+    end
+
+    def self.from_rpc_data( data )
+        options, items = data
+        new( options ).merge items
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/glob.rb

@@ -0,0 +1,27 @@
+module Cuboid
+module Support
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Glob
+
+    def self.to_regexp( glob )
+        escaped = Regexp.escape( glob ).gsub( '\*', '.*?' )
+        Regexp.new( "^#{escaped}$", Regexp::IGNORECASE )
+    end
+
+    attr_reader :regexp
+
+    def initialize( glob )
+        @regexp = self.class.to_regexp( glob )
+    end
+
+    def =~( str )
+        @regexp.match? str
+    end
+    alias :matches? :=~
+    alias :match? :matches?
+
+end
+
+end
+end

data/lib/cuboid/support/mixins.rb

@@ -0,0 +1,8 @@
+module Cuboid::Mixins
+end
+
+lib = Cuboid::Options.paths.mixins
+require lib + 'observable'
+require lib + 'terminal'
+require lib + 'profiler'
+require lib + 'parts'

data/lib/cuboid/support/mixins/observable.rb

@@ -0,0 +1,99 @@
+module Cuboid
+module Support
+module Mixins
+
+# Provides a flexible way to make any object observable for multiple events.
+#
+# The observable classes use:
+#
+#    * `notify_<event>( *args )`
+#
+# to notify observers of events.
+#
+# The observers request notifications using:
+#
+#    * `observable.<event>( &block )`
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Observable
+    include UI::Output
+    include Utilities
+
+    include MonitorMixin
+
+    def self.included( base )
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def advertise( *ad_events )
+            ad_events.each do |event|
+                define_method event do |&block|
+                    add_observer( event, &block )
+                end
+
+                define_method "notify_#{event}" do |*args|
+                    notify_observers( event, *args )
+                end
+
+                private "notify_#{event}"
+            end
+
+            nil
+        end
+    end
+
+    def initialize
+        super
+
+        @__observers = {}
+    end
+
+    private
+
+    def observers
+        @__observers
+    end
+
+    def add_observer( event, &block )
+        fail ArgumentError, 'Missing block' if !block
+        synchronize do
+            observers_for( event ) << block
+        end
+
+        self
+    end
+
+    def notify_observers( event, *args )
+        synchronize do
+            observers_for( event ).each do |block|
+                exception_jail( false ) { block.call( *args ) }
+            end
+        end
+
+        nil
+    end
+
+    def dup_observers
+        observers.inject({}) { |h, (k, v)| h[k] = v.dup; h }
+    end
+
+    def set_observers( obs )
+        @__observers = obs
+    end
+
+    def observers_for( event )
+        observers[event.to_sym] ||= []
+    end
+
+    def clear_observers
+        synchronize do
+            observers.clear
+        end
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/support/mixins/parts.rb

@@ -0,0 +1,20 @@
+module Cuboid
+module Support
+module Mixins
+
+module Parts
+
+    def self.included( base )
+        dir = Utilities.caller_path( 3 ).split( '.rb', 2 ).first
+        Dir.glob( "#{dir}/parts/**/*.rb" ).each { |f| require f }
+
+        parts = base.const_get( :Parts )
+        parts.constants.each do |part_name|
+            base.include parts.const_get( part_name )
+        end
+    end
+
+end
+end
+end
+end

data/lib/cuboid/support/mixins/profiler.rb

@@ -0,0 +1,93 @@
+module Cuboid
+module Support
+module Mixins
+
+module Profiler
+
+    @@on = false
+
+    class <<self
+
+        def included( base )
+            base.extend ClassMethods
+        end
+
+        def enable!
+            @@on = true
+        end
+
+        def disable!
+            @@on = false
+        end
+
+        def on?
+            @@on
+        end
+
+        def results
+            h = {}
+            ObjectSpace.each_object( Class ) do |klass|
+                next if !klass.included_modules.include? self
+                next if klass.profile_data.empty?
+
+                h[klass] = {
+                    sorted_total: klass.profile_data_total,
+                    sorted_avg:   klass.profile_data_avg
+                }
+            end
+            h
+        end
+
+    end
+
+    module ClassMethods
+
+        def profile_data
+            @profile ||= {}
+        end
+
+        def profile_data_avg
+            ::Hash[self.profile_data.sort_by { |_, d| d[:avg] }.reverse]
+        end
+
+        def profile_data_total
+            ::Hash[self.profile_data.sort_by { |_, d| d[:total] }.reverse]
+        end
+
+    end
+
+    def profile_proc( *args, &block )
+        return block.call( *args ) if !Support::Mixins::Profiler.on?
+
+        profile_wrap_proc( &block ).call *args
+    end
+
+    def profile_wrap_proc( &block )
+        return block if !Support::Mixins::Profiler.on?
+
+        proc do |*args|
+            t = Time.now
+            r = block.call( *args )
+
+            loc = block.source_location.join( ':' )
+            loc.gsub!( Options.paths.root, '' )
+
+            data = self.class.profile_data[loc] ||= {
+                total: 0,
+                count: 0,
+                avg:   0
+            }
+
+            data[:total] += Time.now - t
+            data[:count] += 1
+            data[:avg]    = data[:total] / data[:count]
+
+            r
+        end
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/support/mixins/spec_instances.rb

@@ -0,0 +1,65 @@
+module Cuboid
+module Support
+module Mixins
+
+# @note Only for when running specs!
+#
+# Keeps track of every initialized instance so that they can be properly
+# cleaned-up later.
+module SpecInstances
+
+    def self.prepended( base )
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+        # @abstract
+        def _spec_instance_cleanup( i )
+            fail 'Not implemented.'
+        end
+
+        def _spec_instances_cleanup
+            _spec_instances.each do |i|
+                _spec_instance_cleanup i
+            end
+
+            _spec_instances_clear
+        end
+
+        def _spec_instances_clear
+            _spec_instances.clear
+        end
+
+        def _spec_instance( instance )
+            return if !_spec_instances_collect?
+            _spec_instances << instance
+        end
+
+        def _spec_instances_collect!
+            @_spec_instances_collect = true
+        end
+
+        def _spec_instances_collect?
+            @_spec_instances_collect
+        end
+
+        private
+
+        def _spec_instances
+            @_spec_instances ||= Concurrent::Array.new
+        end
+
+    end
+
+    def initialize(*)
+        super
+
+        self.class._spec_instance self
+    end
+
+end
+
+end
+end
+end