helper_classes 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2cc2efbfcfed05e72c9003554b4a7e3c344f925
+  data.tar.gz: 3426825c61f9d9b782dc46d507c20bca84164f43
+SHA512:
+  metadata.gz: b19fbe9429c4097b68464cdfc05ec33bb91d9da52ebc6ae04236e88359bb33c11caa85ff9af718260df64f2f940ddf127df56ae39da1ee3adea1cbcfb8dfee45
+  data.tar.gz: 3d71d53497721d7e8fdeb724707d81d8363a3feaceb7db61db57aae6a28e47317214b6cec7a7bd68867062aa429d593f9b1215c465e4dc9105243e45b043e45c

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+/nbproject
+.hg*
+.idea
+commit
+.DS_Store
+test/test_config

data/LICENSE

@@ -0,0 +1,3 @@
+== HelperClasses
+
+GPLv3 or any later version

data/README.md

@@ -0,0 +1,100 @@
+== HelperClasses
+
+Some simple classes to help in everyday tasks
+
+=== DPuts
+
+Ever wanted to have detailed debug-output, but in the end even PRODUCING the
+string without printing it was too long? Here comes DPuts! It let's you define
+different debug-levels and the strings are only evaluated if they're about
+to be printed! Great for that 10MB-dump that you only want for debugging...
+
+Usage:
+
+```
+include HelperClasses::DPuts
+
+DEBUG_LVL = 5
+dputs(5){ "String with some #{huge_db.inspect}" }
+```
+
+This will evaluate and print the ```huge_db``` variable, while
+
+```
+include HelperClasses::DPuts
+
+DEBUG_LVL = 4
+dputs(5){ "String with some #{huge_db.inspect}" }
+```
+
+will NOT evaluate it! The debug-levels are arbitrarily chosen like this:
+
+0 - Errors
+1 - Info and warnings, important
+2 - Often used debug-messages - limit of production-use
+3 - More detailed debugging
+4
+5 - Dumping lots of raw data
+
+==== Fine-grained debugging
+
+If you have a function with lots of _dputs_ in it, and you'd like to output
+all debugging messages just from that function, you simply add
+
+```
+dputs_func
+```
+
+at the beginning of your function.
+
+If you want just one specific _dputs_ to be evaluated, just change its name to
+_ddputs_:
+
+```
+DEBUG_LVL = 0
+
+ddputs(5){"String with lots of data#{huge_var.inspect}"}
+```
+
+will be evaluated!
+
+=== Arraysym
+
+to_sym and to_sym! - calls .to_sym on all elements. Usage:
+
+```
+using HelperClasses::ArraySym
+
+p [ "a", "b" ].to_sym
+```
+
+Produces "[ :a, :b ]"
+
+=== HashAccessor
+
+This should be standard ruby. Access all elements of an array by
+prepending a "_".
+
+==== Getting a value
+
+```
+using HelperClasses::HashAccessor
+
+p { :a => 2, "a" => 3 }._a
+```
+
+Will print "2". So symbols have precedence over string-keys.
+
+==== Setting a value
+
+```
+using HelperClasses::HashAccessor
+
+a = { :a => 2, "a" => 3 }
+a._a = 4
+a._b = 5
+
+p a
+```
+
+Will print ```{ :a => 4, "a" => 3, :b => "5" }```

data/helper_classes.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = 'helper_classes'
+  s.version = '0.2.1'
+  s.date = '2015-05-12'
+  s.summary = 'Hash._accessor Array.to_sym and DPuts'
+  s.description = 'Added accessors to Hash, to_sym to Array and a nice debugging-interface called DPuts'
+  s.authors = ['Linus Gasser']
+  s.email = 'ineiti@linusetviviane.ch'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.homepage =
+      'https://github.com/ineiti/HelperClasses'
+  s.license = 'GPLv3'
+end

data/lib/helperclasses/arraysym.rb

@@ -0,0 +1,25 @@
+
+module HelperClasses
+  module ArraySym
+    class Array
+      # Comptaibility for Ruby <= 2.0
+      if ![].respond_to? :to_h
+        def to_h
+          Hash[*self.flatten]
+        end
+      end
+
+      def to_sym
+        collect{|v| v.to_sym }
+      end
+
+      def to_sym!
+        self.replace( to_sym() )
+      end
+    
+      def to_s
+        "[#{join(",")}]"
+      end
+    end
+  end
+end

data/lib/helperclasses/dputs.rb

@@ -0,0 +1,111 @@
+module HelperClasses
+  require 'thread'
+  require 'singleton'
+
+  module DPuts
+    extend self
+    attr_accessor :mutex, :silent, :show_time, :terminal_width, :log_file
+
+    @mutex = Mutex.new
+    @silent = false
+    @show_time = false
+    @terminal_width = 160
+    @log_file = false
+
+    def dputs_out(n, s, call)
+      return if DPuts.silent
+      if precision = DPuts.show_time
+        $dputs_time ||= Time.now - 120
+        now = Time.now
+        show = false
+        case precision
+          when /sec/
+            show = now.to_i != $dputs_time.to_i
+          when /min/
+            show = (now.to_i / 60).floor != ($dputs_time.to_i / 60).floor
+          when /hour/
+            show = (now.to_i / 3600).floor != ($dputs_time.to_i / 3600).floor
+        end
+        if show
+          puts "\n   *** It is now: " +
+                   Time.now.strftime('%Y-%m-%d %H:%M:%S')
+          $dputs_time = now
+        end
+      end
+      DPuts.mutex.synchronize do
+        width = DPuts.terminal_width.to_i || 160
+        width = [width - 30.0, 10].max
+        file, func = call.split(' ')
+        file = file[/^.*\/([^.]*)/, 1]
+        who = (':' + n.to_s + ':' + file.to_s +
+            func.to_s).ljust(30, ['X', 'x', '*', '-', '.', ' '][n])
+        lines = []
+        pos = 0
+        while (pos < s.length)
+          len = width
+          if s.length - pos > width
+            len = s.rindex(/[, .;=&>]/, pos + width)
+            len = len ? len - pos + 1 : width
+            if len < width / 2
+              len = width
+            end
+          end
+          lines.push s.slice(pos, len)
+          pos += len
+        end
+        puts who + ' ' + lines.shift.to_s
+        lines.each { |l|
+          puts ' ' * (32) + l
+        }
+      end
+    end
+
+
+    def dputs_getcaller
+      caller(0)[2].sub(/:.*:in/, '').sub(/block .*in /, '')
+    end
+
+    def dputs_func
+      $DPUTS_FUNCS ||= []
+      $DPUTS_FUNCS.push(dputs_getcaller) unless $DPUTS_FUNCS.index(dputs_getcaller)
+    end
+
+    def dputs_unfunc
+      $DPUTS_FUNCS ||= []
+      $DPUTS_FUNCS.index(dputs_getcaller) and $DPUTS_FUNCS.delete(dputs_getcaller)
+    end
+
+    def dputs(n, &s)
+      n *= -1 if ($DPUTS_FUNCS and $DPUTS_FUNCS.index(dputs_getcaller))
+      if !self.class.const_defined?(:DEBUG_LVL) or
+          self.class.const_get(:DEBUG_LVL) >= n
+        s = yield s
+        dputs_out(n, s, caller(0)[1])
+      end
+    end
+
+    def ddputs(n, &s)
+      s = yield s
+      #dp caller(0)
+      dputs_out(-n, s, caller(0)[1])
+    end
+
+    def dp(s)
+      dputs_out(0, s.class == String ? s : s.inspect, caller(0)[1])
+      s
+    end
+
+    def log_msg(mod, msg)
+      dputs(1) { "Info from #{mod}: #{msg}" }
+      return if not DPuts.log_file
+      File.open(DPuts.log_file, 'a') { |f|
+        str = Time.now.strftime("%a %y.%m.%d-%H:%M:%S #{mod}: #{msg}")
+        f.puts str
+      }
+    end
+
+    def dlog_msg(mod, msg)
+      ddputs(1){"Info from #{mod}: #{msg}"}
+    end
+  end
+end

data/lib/helperclasses/hashaccessor.rb

@@ -0,0 +1,44 @@
+module HelperClasses
+  module HashAccessor
+    refine Hash do
+    end
+  end
+end
+
+class Hash
+  # Converts all keys of a hash to syms recursively
+  def to_sym
+    ret = {}
+    each { |k, v|
+      ret[k.to_sym] = v.class == Hash ? v.to_sym : v
+    }
+    ret
+  end
+
+  def to_sym!
+    self.replace(to_sym())
+  end
+
+  def method_missing(s, *args)
+    case s.to_s
+      when "to_ary"
+        super(s, args)
+      when /^_.*[^=]$/
+        key = s.to_s.sub(/^_{1,2}/, '').to_sym
+        self.has_key? key and return self[key]
+        self.has_key? key.to_s and return self[key.to_s]
+        if s.to_s =~ /^__/
+          return self[key] = {}
+        else
+          return nil
+        end
+      when /^_.*=$/
+        key = /^_{1,2}(.*)=$/.match(s.to_s)[1].to_sym
+        self.has_key? key and return self[key] = args[0]
+        self.has_key? key.to_s and return self[key.to_s] = args[0]
+        return self[key] = args[0]
+      else
+        super(s, args)
+    end
+  end
+end

data/lib/helperclasses/readconfig.rb

@@ -0,0 +1,50 @@
+module HelperClasses
+  module ReadConfig
+    extend self
+
+    # Searches in this order:
+    # ~/.config
+    # ~
+    # /etc
+    #
+    # Returns nil if nothing found
+    def file_name(file)
+      %w( ~/.config ~ /etc ).each { |d|
+        file_abs = File.expand_path("#{d}/#{file}")
+        File.exists?(file_abs) and return file_abs
+      }
+      nil
+    end
+
+    # Very simple bash-reader, doesn't do array or multi-line configurations
+    def bash(file, downcase = false)
+      return nil unless File.exists? file
+      IO.readlines(file).collect { |l|
+        if l =~ /^#/
+          nil
+        elsif l =~ /([^ ]+)=(.*)/
+          [(downcase ? $1.downcase : $1).to_sym, $2]
+        end
+      }.compact.to_h
+    end
+
+    # Ruby file-reader, returns created hash
+    # THIS IS ABSOLUTELY INSECURE AND WILL EAT YOUR KITTENS!
+    # It returns what the file returns at the end - so most probably you'll want
+    # something like
+    #
+    #   { one: 1,
+    #     two: 2 }
+    #
+    # in that config-file
+    def ruby(file)
+      return {} unless File.exists? file.to_s
+      return eval(IO.readlines(file).join)
+    end
+
+    def json(file)
+      p 'Not implemented yet'
+      exit
+    end
+  end
+end

data/lib/helperclasses/service.rb

@@ -0,0 +1,104 @@
+require 'helperclasses/dputs'
+require 'helperclasses/system'
+
+module HelperClasses
+  module Service
+    attr_accessor :system, :services
+
+    extend self
+    extend HelperClasses::DPuts
+    @system = case System.run_str 'uname -a'
+                when /ARCH/
+                  :ArchLinux
+                when /Ubuntu/
+                  :Ubuntu
+                when /Darwin/
+                  :MacOSX
+                else
+                  nil
+              end
+
+    @services = {
+        samba: {ArchLinux: %w( smbd nmbd ), Ubuntu: %w(smbd nmbd)},
+        cups: {ArchLinux: 'org.cups.cupsd', Ubuntu: 'cupsd'}
+    }
+
+    def service_get(service)
+      begin
+        @services[service.to_sym][@system]
+      rescue NoMethodError => _e
+        service.to_s
+      end
+    end
+
+    def service_run(service, cmd)
+      return unless @system
+      if !cmd
+        log_msg :Services, "System #{@system} can't start services"
+        return false
+      end
+      service_name = service_get(service)
+      if !service_name
+        log_msg :Services, "System #{@system} doesn't have service #{service}"
+        return false
+      end
+      cmd_system = cmd[@system]
+      if !cmd_system
+        log_msg :Services, "System #{@system} doesn't know how to do #{cmd}"
+        return false
+      end
+      [service_name].flatten.each { |s|
+        c = cmd_system.sub(/##/, s)
+        if !System.run_bool(c)
+          log_msg :Services, "Command #{c} failed"
+          return false
+        end
+      }
+    end
+
+    def start(service)
+      service_run(service, {ArchLinux: 'systemctl start ##',
+                            Ubuntu: '/etc/init.d/## start',
+                            MacOSX: nil}
+      )
+    end
+
+    def stop(service)
+      service_run(service, {ArchLinux: 'systemctl stop ##',
+                            Ubuntu: '/etc/init.d/## stop',
+                            MacOSX: nil}
+      )
+    end
+
+    def restart(service)
+      service_run(service, {ArchLinux: 'systemctl restart ##',
+                            Ubuntu: '/etc/init.d/## restart',
+                            MacOSX: nil}
+      )
+    end
+
+    def enable(service)
+      service_run(service, {ArchLinux: 'systemctl enable ##',
+                            Ubuntu: nil,
+                            MacOSX: nil}
+      )
+    end
+
+    def disable(service)
+      service_run(service, {ArchLinux: 'systemctl disable ##',
+                            Ubuntu: nil,
+                            MacOSX: nil}
+      )
+    end
+
+    def enable_start(service)
+      enable(service)
+      start(service)
+    end
+
+    def stop_disable(service)
+      disable(service)
+      stop(service)
+    end
+  end
+end

data/lib/helperclasses/system.rb

@@ -0,0 +1,53 @@
+# System-interaction for different flavours of Unix
+require 'helperclasses/dputs'
+
+module HelperClasses
+  module System
+    extend self
+    extend HelperClasses::DPuts
+    include HelperClasses::DPuts
+
+    def run_str(cmd)
+      dputs(3) { "Running command --#{cmd}--" }
+      %x[ #{cmd} ]
+    end
+
+    def run_bool(cmd)
+      dputs(3) { "Running command --#{cmd}--" }
+      Kernel.system("#{cmd} > /dev/null 2>&1")
+    end
+
+    def exists?(cmd)
+      dputs(3) { "Exist command --#{cmd}--?" }
+      run_bool("which #{cmd} > /dev/null 2>&1")
+    end
+
+    def rescue_all(msg = 'Error')
+      begin
+        yield
+      rescue Exception => e
+        dputs(0) { "#{Time.now.strftime('%a %y.%m.%d-%H:%M:%S')} - #{msg}" }
+        dputs(0) { "#{e.inspect}" }
+        dputs(0) { "#{e.to_s}" }
+        e.backtrace.each { |l| dputs(0) { l } }
+      end
+    end
+
+    def iptables(*args)
+      if !@iptables_cmd
+        if System.exists?('iptables')
+          @iptables_cmd = 'iptables'
+          @iptables_wait = (System.run_str('iptables --help') =~ /\s-w\s/) ? '-w' : ''
+        else
+          @iptables_cmd = ''
+        end
+      end
+
+      if @iptables_cmd != ''
+        System.run_str("#{@iptables_cmd} #{@iptables_wait} #{args.join(' ')}")
+      else
+        return ''
+      end
+    end
+  end
+end

data/lib/helperclasses/timing.rb

@@ -0,0 +1,21 @@
+module HelperClasses
+  class Timing
+    def initialize(dbg = 0)
+      @dbg_lvl = dbg
+      @time = Time.now
+    end
+
+    def probe(msg = '')
+      t = sprintf('%6f', (Time.now - @time).to_f)
+      dputs(@dbg_lvl) { "#{msg}: #{t}" }
+      @time = Time.now
+    end
+
+    def self.measure(msg = '', dbg = 0)
+      t = Timing.new(dbg)
+      ret = yield
+      t.probe(msg)
+      ret
+    end
+  end
+end

data/lib/helperclasses.rb

@@ -0,0 +1,7 @@
+require 'helperclasses/arraysym'
+require 'helperclasses/dputs'
+require 'helperclasses/hashaccessor'
+require 'helperclasses/readconfig'
+require 'helperclasses/service'
+require 'helperclasses/system'
+require 'helperclasses/timing'

data/test/hc_service.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+
+class TC_Service < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_service_get
+    Service.system = :ArchLinux
+
+    assert_equal %w(smbd nmbd), Service.service_get(:samba)
+    assert_equal 'dnsmasq', Service.service_get(:dnsmasq)
+  end
+end

data/test/test.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.push '../lib', '.'
+
+require 'test/unit'
+require 'helperclasses'
+include HelperClasses
+
+tests = Dir.glob( 'hc_*.rb' )
+#tests = %w(  )
+
+tests.each{|t|
+  begin
+    require "hc_#{t}"
+  rescue LoadError => e
+    require t
+  end
+}

data/test/test_arraysym.rb

@@ -0,0 +1,5 @@
+require 'helperclasses/arraysym'
+
+using HelperClasses::ArraySym
+
+p ["a", "b"].to_sym

data/test/test_dputs.rb

@@ -0,0 +1,12 @@
+require "helperclasses/dputs"
+
+DEBUG_LVL = 5
+
+include HelperClasses
+
+DPuts.dputs(5){"Hello"}
+
+include DPuts
+
+dputs( 5 ){"Hello there"}
+

data/test/test_hashaccessor.rb

@@ -0,0 +1,9 @@
+require 'helperclasses/hashaccessor'
+
+using HelperClasses::HashAccessor
+
+a = { :a => 3, "b" => 4 }
+
+p a.to_sym
+p a._a
+p a._b

data/test/test_readconfig.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push('../lib')
+require 'helperclasses/readconfig'
+
+include HelperClasses
+
+testfile = 'test_config'
+IO.write(testfile, "#!/bin/bash
+# This is an example config
+TEST=hi
+DB=foo.db
+# This shouldn't pass
+TEST2 = hi
+# And some unrelated stuff
+if '$1'; then
+fi
+")
+
+test = ReadConfig.bash( testfile )
+p test
+
+def printit
+  p test
+end
+
+printit

data/test/test_system.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push '../lib'
+
+require 'helperclasses/system'
+include HelperClasses::System
+
+rescue_all do
+  puts 'Hello there'
+end
+puts
+
+rescue_all do
+  puts "Some math: #{10/0}"
+end
+puts
+
+rescue_all('math-error') do
+  puts "Some math: #{10/0}"
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: helper_classes
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Linus Gasser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-12 00:00:00.000000000 Z
+dependencies: []
+description: Added accessors to Hash, to_sym to Array and a nice debugging-interface
+  called DPuts
+email: ineiti@linusetviviane.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- helper_classes.gemspec
+- lib/helperclasses.rb
+- lib/helperclasses/arraysym.rb
+- lib/helperclasses/dputs.rb
+- lib/helperclasses/hashaccessor.rb
+- lib/helperclasses/readconfig.rb
+- lib/helperclasses/service.rb
+- lib/helperclasses/system.rb
+- lib/helperclasses/timing.rb
+- test/hc_service.rb
+- test/test.rb
+- test/test_arraysym.rb
+- test/test_dputs.rb
+- test/test_hashaccessor.rb
+- test/test_readconfig.rb
+- test/test_system.rb
+homepage: https://github.com/ineiti/HelperClasses
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Hash._accessor Array.to_sym and DPuts
+test_files:
+- test/hc_service.rb
+- test/test.rb
+- test/test_arraysym.rb
+- test/test_dputs.rb
+- test/test_hashaccessor.rb
+- test/test_readconfig.rb
+- test/test_system.rb