HelperClasses 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e9d72b8fe43505cae6d07152f6bf45f9d94cec5
+  data.tar.gz: c8ec6b3f48a225602628f578122ac32f5bb7388a
+SHA512:
+  metadata.gz: cdd44f845254cadfc4771dce2c205fdca28139550e0d1bf6d2393cb67fd0f03f12a3cca089ce8ff3e5f5f117cd82a16f2614cd4288504d621f1ead249ec733a0
+  data.tar.gz: 3404bd78e68baa95a8c991714c80a0f9326c50dd8624e40ea907e76fa5c79315a0a12368cb44321826cc3b0dac0d1060c092d35e16cc9f78e0e6928dcf83b84c

data/LICENSE

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

data/README

@@ -0,0 +1,78 @@
+== 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
+
+=== 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/lib/helperclasses.rb

@@ -0,0 +1,3 @@
+require 'helperclasses/hashaccessor'
+require 'helperclasses/arraysym'
+require 'helperclasses/dputs'

data/lib/helperclasses/arraysym.rb

@@ -0,0 +1,25 @@
+
+module HelperClasses
+  module ArraySym
+    refine Array do
+      # Comptaibility for Ruby < 1.9
+      if ! Array.respond_to? :to_h
+        def to_h
+          Hash[ *self ]
+        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,86 @@
+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 = 60
+    @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
+        end
+        show and puts "\n   *** It is now: " + 
+          Time.now.strftime( "%Y-%m-%d %H:%M:%S" )
+        $dputs_time = now
+      end
+      DPuts.mutex.synchronize do
+        width = DPuts.terminal_width
+        width -= 30.0
+        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 and len = len - pos + 1
+            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(n, &s)
+      if DEBUG_LVL >= n
+        s = yield s
+        dputs_out( n, s, caller(0)[1] )
+      end
+    end
+
+    def ddputs( n, &s )
+      s = yield s
+      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
+
+  end
+end

data/lib/helperclasses/hashaccessor.rb

@@ -0,0 +1,41 @@
+module HelperClasses
+  module HashAccessor
+    refine Hash do
+      # 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
+  end
+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

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: HelperClasses
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Linus Gasser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-28 00:00:00.000000000 Z
+dependencies: []
+description: Array.to_sym, Hash-accessors and debug-outputs with lazy evaluation
+email: ineiti@linusetviviane.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./LICENSE"
+- "./README"
+- "./lib/helperclasses.rb"
+- "./lib/helperclasses/arraysym.rb"
+- "./lib/helperclasses/dputs.rb"
+- "./lib/helperclasses/hashaccessor.rb"
+- "./test/test_arraysym.rb"
+- "./test/test_dputs.rb"
+- "./test/test_hashaccessor.rb"
+- LICENSE
+- README
+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.0
+signing_key: 
+specification_version: 4
+summary: Helpers for Array, Hash and debug-output
+test_files: []