bblib 0.2.2 → 0.3.0

data/lib/object/bbobject.rb

@@ -1,3 +1,7 @@
+require_relative 'attr'
+require_relative 'hooks'
+require_relative 'simple_serialize'
+
 module BBLib
 
   def self.to_hash obj
@@ -25,4 +29,16 @@ module BBLib
     return hash
   end
 
+  def self.named_args *args
+    args.last.is_a?(Hash) && args.last.keys.all?{|k|k.is_a?(Symbol)} ? args.last : Hash.new
+  end
+
+  def self.named_args! *args
+    if args.last.is_a?(Hash) && args.last.keys.all?{|k|k.is_a?(Symbol)}
+      args.delete_at(-1)
+    else
+      Hash.new
+    end
+  end
+
 end

data/lib/object/hooks.rb

@@ -0,0 +1,69 @@
+module BBLib::Hooks
+
+  def method_added name
+    before_hooks_for(name).each do |hook|
+      next if before_hooked_methods[hook] && before_hooked_methods[hook].include?(name)
+      add_before_hook(name, hook)
+    end
+    after_hooks_for(name).each do |hook|
+      next if after_hooked_methods[hook] && after_hooked_methods[hook].include?(name)
+      add_after_hook(name, hook)
+    end
+  end
+
+  def before hook, *methods
+    methods.each{ |m| before_hooks[hook] = methods }
+  end
+
+  def before_hooks
+    @before_hooks ||= {}
+  end
+
+  def before_hooked_methods
+    @before_hooked_methods ||= {}
+  end
+
+  def before_hooks_for name
+    before_hooks.map{ |n, m| m.include?(name)? n : nil }.reject(&:nil?)
+  end
+
+  def add_before_hook method, hook
+    before_hooked_methods[hook] = Array.new unless before_hooked_methods[hook]
+    before_hooked_methods[hook] += [method]
+    original = instance_method(method)
+    define_method(method) do |*args, &block|
+      # puts "ARGS: #{args}"
+      method(hook).call
+      original.bind(self).call(*args, &block)
+    end
+  end
+
+  def after hook, *methods
+    methods.each{ |m| after_hooks[hook] = methods }
+  end
+
+  def after_hooks
+    @after_hooks ||= {}
+  end
+
+  def after_hooked_methods
+    @after_hooked_methods ||= {}
+  end
+
+  def after_hooks_for name
+    after_hooks.map{ |n, m| m.include?(name) ? n : nil }.reject(&:nil?)
+  end
+
+  def add_after_hook method, hook
+    after_hooked_methods[hook] = Array.new unless after_hooked_methods[hook]
+    after_hooked_methods[hook] += [method]
+    original = instance_method(method)
+
+    define_method(method) do |*args, &block|
+      rtr = original.bind(self).call(*args, &block)
+      method(hook).call
+      rtr
+    end
+  end
+
+end

data/lib/object/lazy_class.rb

@@ -0,0 +1,73 @@
+
+module BBLib
+
+  class LazyClass
+    extend Hooks
+    extend Attr
+    attr_reader :_serialize_fields
+
+    def initialize *args
+      _pre_setup
+      lazy_setup
+      _lazy_init(*args)
+    end
+
+    def serialize
+      _serialize_fields.map do |name, h|
+        value = send(h[:method])
+        if !h[:always] && value == h[:ignore]
+          nil
+        else
+          [ name, value ]
+        end
+      end.reject(&:nil?).to_h
+    end
+
+    protected
+
+      def lazy_setup
+        # Instantiate necessary variables here
+      end
+
+      def _lazy_init *args
+        BBLib::named_args(*args).each do |k,v|
+          if self.respond_to?("#{k}=".to_sym)
+            send("#{k}=".to_sym, v)
+          end
+        end
+        lazy_init *args
+        custom_lazy_init BBLib::named_args(*args), *args
+      end
+
+      def _pre_setup
+        self.methods.each do |m|
+          if m.to_s.start_with?('__reset_')
+            send(m) rescue nil
+          end
+        end
+      end
+
+      def lazy_init *args
+        # Define custom initialization here...
+      end
+
+      def custom_lazy_init *args
+        # Left in for legacy support...don't use this!
+      end
+
+      def serialize_method name, method = nil, ignore: nil, always: false
+        return if method == :serialize || name == :serialize && method.nil?
+        _serialize_fields[name.to_sym] = {
+          method: (method.nil? ? name.to_sym : method.to_sym),
+          ignore: ignore,
+          always: always
+        }
+      end
+
+      def _serialize_fields
+        @_serialize_fields ||= Hash.new
+      end
+
+  end
+
+end

data/lib/opal/bbopal.rb

@@ -0,0 +1,16 @@
+module BBLib
+
+  def self.in_opal?
+    RUBY_ENGINE == 'opal'
+  end
+
+end
+
+if BBLib.in_opal?
+  class Element
+
+    alias_native :replace_with, :replaceWith
+    alias_native :prepend
+    alias_native :get_context, :getContext
+  end
+end

data/lib/os/bbos.rb

@@ -0,0 +1,93 @@
+require_relative 'bbsys'
+
+module BBLib
+
+  module OS
+
+    def self.os
+      return :windows if windows?
+      return :mac if mac?
+      return :linux if linux?
+    end
+
+    def self.windows?
+      builds = ['mingw', 'mswin', 'cygwin', 'bccwin']
+      !(/#{builds.join('|')}/i =~ RUBY_PLATFORM).nil?
+    end
+
+    def self.linux?
+      !windows? && !mac?
+    end
+
+    def self.unix?
+      !windows?
+    end
+
+    def self.mac?
+      builds = ['darwin']
+      !(/#{builds.join('|')}/i =~ RUBY_PLATFORM).nil?
+    end
+
+    def self.os_info
+      if windows?
+        data = `wmic os get manufacturer,name,organization,osarchitecture,version /format:list`
+        data = data.split("\n").reject{ |r| r.strip == '' }.map do |m|
+          spl = m.split('=')
+          [spl.first.to_clean_sym.downcase, spl[1..-1].join('=')]
+        end.to_h
+        data[:name] = data[:name].split('|').first
+        data[:osarchitecture] = data[:osarchitecture].extract_integers.first
+        data.hpath_move( 'osarchitecture' => 'bits' )
+        data[:host] = `hostname`.strip
+        data[:os] = os
+        data
+      else
+        release = {}
+        begin
+          # First attempt to get release info uses lsb_release
+          release = `lsb_release -a`.split("\n").map do |l|
+            spl = l.split(':')
+            [
+              spl.first.downcase.to_clean_sym,
+              spl[1..-1].join(':').strip
+            ]
+          end.to_h
+          release.hpath_move('description' => 'name', 'release' => 'name', 'distributor_id' => 'manufacturer')
+        rescue
+          # Try finding the release file and parsing it instead of lsb_release
+          begin
+            release = `cat /etc/*release`
+              .split("\n")
+              .reject{ |l| !(l.include?(':') || l.include?('=')) }
+              .map{|l| l.msplit('=',':') }
+              .map{ |a| [a.first.downcase.to_clean_sym, a[1..-1].join(':').uncapsulate] }
+              .to_h
+          rescue
+            # Both attempts failed
+          end
+        end
+        {
+          release: `uname -r`.strip,
+          bits:    `uname -r` =~ /x86_64/i ? 64 : 32,
+          host:    `uname -n`.strip,
+          os:      os
+        }.merge(release)
+      end
+    end
+
+    # The following is Windows specific code
+    if windows?
+
+      def self.parse_wmic cmd
+        `#{cmd} /format:list`
+          .split("\n\n\n").reject(&:empty?)
+          .map{ |l| l.split("\n\n")
+            .map{ |l| spl = l.split('='); [spl.first.strip.downcase.to_clean_sym, spl[1..-1].join('=').strip ] }.to_h
+          }.reject(&:empty?)
+      end
+
+    end
+
+  end
+
+end

data/lib/os/bbsys.rb

@@ -0,0 +1,238 @@
+
+
+
+module BBLib
+  module OS
+
+    def self.cpu_usages
+      if windows?
+        {
+          total: `wmic cpu get loadpercentage /format:value`.extract_numbers.first.to_f
+        }
+      elsif linux? || mac?
+        system_stats[:cpu]
+      else
+        nil
+      end
+    end
+
+    def self.uptime
+      if windows?
+        uptime = `net statistics server`.split("\n").find{|l| l.start_with?('Statistics since ')}.split(/since /i).last.strip
+        Time.now - Time.strptime(uptime, '%m/%d/%Y %l:%M:%S %p')
+      else
+        `cat /proc/uptime`.extract_numbers.first
+      end
+    end
+
+    def self.cpu_used_p
+      cpu_usages[:total]
+    end
+
+    def self.cpu_free_p
+      100 - cpu_used
+    end
+
+    def self.mem_total
+      if windows?
+        `wmic computersystem get TotalPhysicalMemory`.extract_numbers.first / 1024.0
+      elsif linux?
+        system_stats.hpath('memory.total')
+      else
+        nil
+      end
+    end
+
+    def self.mem_used
+      mem_total.to_f - mem_free.to_f
+    end
+
+    def self.mem_used_p
+      (mem_used.to_f / mem_total.to_f) * 100.0
+    end
+
+    def self.mem_free
+      if windows?
+        `wmic os get freephysicalmemory /format:value`.extract_numbers.first
+      elsif linux?
+        system_stats.hpath('memory.free')
+      else
+        nil
+      end
+    end
+
+    def self.mem_free_p
+      (mem_free.to_f / mem_total.to_f) * 100.0
+    end
+
+    def self.system_stats
+      if windows?
+        memfree  = mem_free
+        memtotal = mem_total
+        memused  = memtotal - memfree
+        {
+          cpu: cpu_usages,
+          memory: {
+            free:   memfree,
+            used:   memused,
+            total:  memtotal,
+            free_p: (memfree / memtotal.to_f) * 100,
+            used_p: (memused / memtotal.to_f) * 100
+          },
+          uptime: uptime
+        }
+      else
+        stats = `top -b -n2 -d 0.1`.split("\n")
+        cpu   = stats.find_all{|l| l =~ /\A\%?Cpu\(s\)/i }.last.extract_numbers
+        loads = stats.find_all{|l| l =~ / load average\: /i }.last.scan(/load average:.*/i).first.extract_numbers
+        mem   = stats.find_all{|l| l =~ /KiB Mem|Mem\:/i }.last.extract_numbers
+        time  = `cat /proc/uptime`.extract_numbers
+        {
+          cpu: {
+            user:                cpu[0],
+            system:              cpu[1],
+            nice:                cpu[2],
+            total:               cpu[0..2].inject(0){ |sum, v| sum += v.to_f },
+            idle:                cpu[3],
+            wait:                cpu[4],
+            hardware_interrupts: cpu[5],
+            software_interrupts: cpu[6],
+            hypervisor:          cpu[7]
+          },
+          uptime: time[0],
+          uptime_idle: time[1],
+          memory: {
+            free:   mem[1],
+            used:   mem[2],
+            total:  mem[0],
+            cache:  mem[3],
+            free_p: (mem[1] / mem[0].to_f) * 100,
+            used_p: (mem[2] / mem[0].to_f) * 100
+          },
+          load_average: {
+            1 => loads[0],
+            5 => loads[1],
+            15 => loads[2]
+          }
+        }
+      end
+    end
+
+    def self.processes
+      if windows?
+        tasks = `tasklist /v`
+        cpu = `wmic path win32_perfformatteddata_perfproc_process get PercentProcessorTime,percentusertime,IDProcess /format:list`
+        cpu = cpu.split("\n\n\n\n").reject(&:empty?)
+              .map{ |l| l.scan(/\d+/).map(&:to_i)}
+              .map{ |n|[ n[0], {cpu: n[1], user: n[2] }]}.to_h
+        lines = tasks.split("\n")[3..-1].map{ |l| l.split(/\s{2,}/) }
+        mem = mem_total
+        cmds = `wmic process get processid,commandline /format:csv`.split("\n")[1..-1].reject{ |r| r.strip  == ''}.map{ |l| l.split(',')[1..-1] }.map{ |l| [l.last.to_i, l[0..-2].join(',')]}.to_h
+        lines.map do |l|
+          pid = l[1].extract_numbers.first
+          {
+            name: l[0],
+            pid:  pid,
+            user: l[4],
+            mem:  (((l[3].gsub(',', '').extract_numbers.first / mem_total) * 100) rescue nil),
+            cpu:  (cpu[pid][:cpu] rescue nil),
+            cmd:  cmds[pid]
+          }
+        end
+      else
+        t = `ps -e -o comm,pid,ruser,%cpu,%mem,cmd`
+        lines = t.split("\n")[1..-1].map{ |l| l.split(/\s+/) }
+        lines.map{ |l| l.size == 6 ? l : [l[0], l[1], l[2], l[3], l[4], l[5..-1].join(' ')] }
+        lines.map do |l|
+          {
+            name: l[0],
+            pid:  l[1].to_i,
+            user: l[2],
+            cpu:  l[3].to_f,
+            mem:  l[4].to_f,
+            cmd:  l[5]
+          }
+        end
+      end
+    end
+
+    def self.filesystems
+      if windows?
+        types = {
+          0 => 'Unknown',
+          1 => 'No Root Directory',
+          2 => 'Removable Disk',
+          3 => 'Local Disk',
+          4 => 'Network Drive',
+          5 => 'Compact Disc',
+          6 => 'RAM Disk'
+        }
+        parse_wmic('wmic logicaldisk get name,description,filesystem,freespace,size,volumename,volumeserialnumber,providername,drivetype')
+          .map do |v|
+            v.hpath_move(
+              'freespace'          => 'free',
+              'providername'       => 'provider',
+              'volumename'         => 'volume_name',
+              'volumeserialnumber' => 'serial_number',
+              'filesystem'         => 'filesystem_type',
+              'name'               => 'disk'
+            )
+            dt = v.delete(:drivetype).to_i
+            v[:type] = types[dt]
+            if (2..4) === dt
+              v[:free]   = v[:free].to_i
+              v[:size]   = v[:size].to_i
+              v[:used]   = v[:size] - v[:free]
+              v[:free_p] = (v[:free] / v[:size].to_f) * 100
+              v[:used_p] = (v[:used] / v[:size].to_f) * 100
+            end
+            v
+          end
+      else
+        `df -aTB 1`
+          .split("\n")[1..-1]
+          .map{ |l| l.split(/\s{2,}|(?<=\d)\s|(?<=%)\s|(?<=\-)\s|(?<=\w)\s+(?=\w+\s+\d)/)}
+          .map do |i|
+            {
+              filesystem: i[0],
+              type:       i[1],
+              size:       i[2].to_i,
+              used:       i[3].to_i,
+              available:  i[4].to_i,
+              used_p:     i[5].extract_integers.first.to_f,
+              mount:      i[6],
+            }
+          end
+      end
+    end
+
+
+    # A mostly platform agnostic call to get root volumes
+    def self.root_volumes
+      if BBLib.windows?
+        begin # For windows
+          `wmic logicaldisk get name`.split("\n").map{ |m| m.strip }[1..-1].reject{ |r| r == '' }
+        rescue
+          begin # Windows attempt 2
+            `fsutil fsinfo drives`.scan(/(?<=\s)\w\:/)
+          rescue
+            nil
+          end
+        end
+      else
+        begin
+          `ls /`.split("\n").map{ |m| m.strip }.reject{ |r| r == '' }
+        rescue # All attempts failed
+          nil
+        end
+      end
+    end
+
+    # Windows only method to get the volume labels of disk drives
+    def self.root_volume_labels
+      return nil unless BBLib.windows?
+      `wmic logicaldisk get caption,volumename`.split("\n")[1..-1].map{ |m| [m.split("  ").first.to_s.strip, m.split("  ")[1..-1].to_a.join(' ').strip] }.reject{ |o,t| o == '' }.to_h
+    end
+
+  end
+end