cuboid 0.0.0 → 0.0.3

data/lib/cuboid/support/database/queue.rb

@@ -0,0 +1,149 @@
+module Cuboid
+module Support::Database
+
+# Flat-file Scheduler implementation
+#
+# Behaves pretty much like a Ruby Scheduler however it transparently serializes and
+# saves its entries to the file-system under the OS's temp directory **after**
+# a specified {#max_buffer_size} (for in-memory entries) has been exceeded.
+#
+# It's pretty useful when you want to reduce memory footprint without
+# having to refactor any code since it behaves just like a Ruby Scheduler
+# implementation.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Queue < Base
+
+    # Default {#max_buffer_size}.
+    DEFAULT_MAX_BUFFER_SIZE = 100
+
+    # @return   [Integer]
+    #   How many entries to keep in memory before starting to off-load to disk.
+    attr_accessor :max_buffer_size
+
+    # @return   [Array<Object>]
+    #   Objects stored in the memory buffer.
+    attr_reader :buffer
+
+    # @return   [Array<String>]
+    #   Paths to files stored to disk.
+    attr_reader :disk
+
+    # @see Cuboid::Database::Base#initialize
+    def initialize( options = {} )
+        super( options )
+
+        @max_buffer_size = options[:max_buffer_size] || DEFAULT_MAX_BUFFER_SIZE
+
+        @disk    = []
+        @buffer  = []
+        @waiting = []
+        @mutex   = Mutex.new
+    end
+
+    # @note Defaults to {DEFAULT_MAX_BUFFER_SIZE}.
+    #
+    # @return   [Integer]
+    #   How many entries to keep in memory before starting to off-load to disk.
+    def max_buffer_size
+        @max_buffer_size
+    end
+
+    # @param    [Object]    obj
+    #   Object to add to the queue.
+    def <<( obj )
+        synchronize do
+            if @buffer.size < max_buffer_size
+                @buffer << obj
+            else
+                @disk << dump( obj )
+            end
+
+            begin
+                t = @waiting.shift
+                t.wakeup if t
+            rescue ThreadError
+                retry
+            end
+        end
+    end
+    alias :push :<<
+    alias :enq :<<
+
+    # @return   [Object]
+    #   Removes an object from the queue and returns it.
+    def pop( non_block = false )
+        synchronize do
+            loop do
+                if internal_empty?
+                    raise ThreadError, 'queue empty' if non_block
+                    @waiting.push Thread.current
+                    @mutex.sleep
+                else
+                    return @buffer.shift if !@buffer.empty?
+                    return load_and_delete_file( @disk.shift )
+                end
+            end
+        end
+    end
+    alias :deq :pop
+    alias :shift :pop
+
+    # @return   [Integer]
+    #   Size of the queue, the number of objects it currently holds.
+    def size
+        buffer_size + disk_size
+    end
+    alias :length :size
+
+    def free_buffer_size
+        max_buffer_size - buffer_size
+    end
+
+    def buffer_size
+        @buffer.size
+    end
+
+    def disk_size
+        @disk.size
+    end
+
+    # @return   [Bool]
+    #   `true` if the queue if empty, `false` otherwise.
+    def empty?
+        synchronize do
+            internal_empty?
+        end
+    end
+
+    # Removes all objects from the queue.
+    def clear
+        synchronize do
+            @buffer.clear
+
+            while !@disk.empty?
+                path = @disk.pop
+                next if !path
+                delete_file path
+            end
+        end
+    end
+
+    def num_waiting
+        @waiting.size
+    end
+
+    private
+
+    def internal_empty?
+        @buffer.empty? && @disk.empty?
+    end
+
+    def synchronize( &block )
+        @mutex.synchronize( &block )
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/database.rb

@@ -0,0 +1,5 @@
+lib = Cuboid::Options.paths.support + '/database/'
+require lib + 'base'
+require lib + 'queue'
+require lib + 'categorized_queue'
+require lib + 'hash'

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/filter.rb

@@ -0,0 +1,3 @@
+lib = Cuboid::Options.paths.support + 'filter/'
+require lib + 'base'
+require lib + 'set'

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/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

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

@@ -0,0 +1,57 @@
+require 'io/console'
+
+module Cuboid
+module Support
+module Mixins
+
+# Terminal manipulation methods.
+module Terminal
+
+    # Clears the line before printing using `puts`.
+    #
+    # @param    [String]    str
+    #   String to output
+    def reputs( str = '' )
+        reprint str + "\n"
+    end
+
+    # Clears the line before printing.
+    #
+    # @param    [String]    str
+    #   String to output.
+    def reprint( str = '' )
+        print restr( str )
+    end
+
+    def restr( str = '' )
+        "\e[0K" + str
+    end
+
+    # Clear the bottom of the screen
+    def clear_screen
+        print "\e[2J"
+    end
+
+    def empty_screen
+        move_to_home
+        rows, cols = $stdin.winsize
+        (rows - 1).times{ puts ' ' * cols }
+        move_to_home
+    end
+
+    # Moves cursor top left to its home
+    def move_to_home
+        print "\e[H"
+    end
+
+    # Flushes the STDOUT buffer
+    def flush
+        $stdout.flush
+    end
+
+    extend self
+end
+
+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.rb

@@ -0,0 +1,11 @@
+module Cuboid::Support
+end
+
+lib = Cuboid::Options.paths.support
+require lib + 'mixins'
+require lib + 'buffer'
+require lib + 'cache'
+require lib + 'crypto'
+require lib + 'database'
+require lib + 'filter'
+require lib + 'glob'

data/lib/cuboid/system/platforms/linux.rb

@@ -0,0 +1,26 @@
+require_relative 'mixins/unix'
+
+module Cuboid
+
+class System
+module Platforms
+class Linux < Base
+    include Mixins::Unix
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    def memory_free
+        memory.available_bytes
+    end
+
+    class <<self
+        def current?
+            Cuboid.linux?
+        end
+    end
+
+end
+
+end
+end
+end