zucker 0.9

data/lib/zucker/1/ivars.rb

@@ -0,0 +1,26 @@
+def instance_variables_from(obj, *only)
+  iter =
+  if    obj.is_a? Binding
+    obj.eval('local_variables').map{|e| [obj.eval(e), e] }
+  elsif obj.is_a? Hash
+    obj.map{|k,v| [v,k] }
+  else
+#  elsif obj.is_a? Enumerable
+    obj.each.with_index
+  end
+
+  ret = []
+  iter.each{ |value, arg|
+    arg = arg.to_s
+    if only.include?(arg) || only.include?(arg.to_sym) || only.empty?
+      arg = '_' + arg  if (48..57).member? arg.unpack('C')[0]  # 1.8+1.9
+      ret << ivar = :"@#{arg}"
+      self.instance_variable_set ivar, value
+    end
+  }
+  ret
+end
+alias ivars instance_variables_from
+
+# J-_-L
+

data/lib/zucker/1/kernel.rb

@@ -0,0 +1,20 @@
+def activate_warnings!
+  $VERBOSE = true
+end
+
+def deactivate_warnings!
+  $VERBOSE = false
+end
+
+def warnings_activated?
+  $VERBOSE
+end
+
+def library?
+  __FILE__ != $PROGRAM_NAME
+end
+
+def ignore_sigint! # ctrl+c
+   Signal.trap *%w|SIGINT IGNORE|
+end
+

data/lib/zucker/1/mcopy.rb

@@ -0,0 +1,9 @@
+class Object
+  def mcopy
+    Marshal.load Marshal.dump self
+  end
+  # alias copy mcopy
+end
+
+# J-_-L
+

data/lib/zucker/1/mm.rb

@@ -0,0 +1,31 @@
+module Kernel
+  def method_list(levels = 1)
+    if self.is_a? Module
+      klass, method_function = self, :public_methods
+    else
+      klass, method_function = self.class, :public_instance_methods
+
+      eigen = self.singleton_methods
+      if !eigen.empty?
+        puts :Eigenclass # sorry for not being up to date, I just love the word
+        p self.singleton_methods
+      end
+    end
+
+    levels.times{ |level|
+      if cur = klass.ancestors[level]
+        p cur                               # put class name
+        p cur.send method_function, false   # put methods of the class
+      else
+        break
+      end
+    }
+
+    self # or whatever
+  end
+
+  alias mm method_list
+end
+
+# J-_-L
+

data/lib/zucker/1/regexp2proc.rb

@@ -0,0 +1,10 @@
+class Regexp
+  def to_proc
+    proc do |e|
+      e.to_s[self]
+    end
+  end
+end
+
+# J-_-L
+

data/lib/zucker/1/sandbox.rb

@@ -0,0 +1,15 @@
+def sandbox(rescueblock=nil)
+  Thread.start do
+    $SAFE = 4
+    yield
+  end.value
+rescue SecurityError => e
+  if rescueblock
+    rescueblock.call e
+  else
+    raise e
+  end
+end
+
+# J-_-L
+

data/lib/zucker/1/specification/D_spec.rb

@@ -0,0 +1,27 @@
+require 'D'
+
+describe 'Object#D' do
+
+  let :a do
+    [ 1, "1", 2..5, [], {:hallo => :du}, nil, true ]
+  end
+
+  it 'should not change the object"s value' do
+    a.each{ |e|
+      (e.D).should == e
+    }
+  end
+
+  it "should puts .inspect if no block is given (and not change the object's value)" do
+#    a.each{ |e|
+#      (e.D).should == e
+#    }
+  end
+
+  it "should puts the block if it is given (and not change the object's value)" do
+    a.each{ |e|
+      (e.D{|value| "This is a: #{value}"}).should == e
+    }
+  end
+end
+

data/lib/zucker/1/specification/aliases_spec.rb

@@ -0,0 +1,34 @@
+require 'aliases'
+
+describe '(aliases)' do
+  it 'should create these aliases [ sorry, no real spec for this one :P ] ' do
+  # alias is_an? is_a?
+
+  #  module Enumerable
+  #    alias with zip
+  #    alias %    zip
+  #  end
+
+  #  class Array
+  #    alias ** product
+  #  end
+
+  #  class Hash
+  #    alias + merge
+  #  end
+
+  #  class Binding
+  #    #alias [] eval
+  #    def [](expr)
+  #      self.eval "#{expr}"
+  #    end
+  #  end
+
+  end
+
+  it 'should define these constants' do
+    Infinity.finite?.should == false
+    NaN.nan?.should         == true
+  end
+end
+

data/lib/zucker/1/specification/array2proc_spec.rb

@@ -0,0 +1,8 @@
+require 'array2proc'
+
+describe 'Array#to_proc' do
+  it 'should call the method of the first symbol, using the remaining elements as paramaters' do
+    [1,2,3,4].map( &[:to_s, 2] ).should == ["1", "10", "11", "100"]
+  end
+end
+

data/lib/zucker/1/specification/array_spec.rb

@@ -0,0 +1,23 @@
+require 'array'
+
+describe 'Array#^' do
+  it 'should do an exclusive or' do
+    a = [1,2,3,4]
+    b = [3,4,5,6]
+    (a^b).should == [1,2,5,6]
+  end
+end
+
+describe 'Array#sum' do
+  it 'should sum the array' do
+    [1,2,3,4,5].sum.should   == 15
+    %w|More Ruby|.sum.should == 'MoreRuby'
+  end
+end
+
+describe 'Array#chrs' do
+  it 'should convert the array to a string, using each element as ord value for the char' do
+    [72, 97, 108, 108, 111].chrs.should == 'Hallo'
+  end
+end
+

data/lib/zucker/1/specification/binding_spec.rb

@@ -0,0 +1,6 @@
+require 'binding'
+
+describe 'Binding#inspect' do
+  it 'should output the current environment'
+end
+

data/lib/zucker/1/specification/blank_spec.rb

@@ -0,0 +1,20 @@
+require 'blank'
+
+describe 'Object#blank?' do
+  it 'should be blank for blank values' do
+    blank_values   = [ nil, false, '', '   ', "  \n\t  \r ", [], {}, // ]
+
+    blank_values.each{ |blank|
+      blank.blank?.should == true
+    }
+  end
+
+  it 'should not be blank for non blank values' do
+    present_values = [ Object.new, true, 0, 1, 'a', [nil], { nil => nil } ]
+
+    present_values.each{ |present|
+      present.blank?.should == false
+    }
+  end
+end
+

data/lib/zucker/1/specification/class2proc_spec.rb

@@ -0,0 +1,9 @@
+require 'class2proc'
+require 'set'
+
+describe 'Class#to_proc' do
+  it 'should create new instances of the class' do
+    [ [1,2],[3,5,6,7,3] ].map(&Set).should == [ Set[1,2], Set[5,6,7,3] ]
+  end
+end
+

data/lib/zucker/1/specification/egonil_spec.rb

@@ -0,0 +1,30 @@
+require 'egonil'
+
+describe 'egonil' do
+  it 'should not raise nil exceptions in the block' do
+    proc do
+      egonil{ nil.some_methods.that[:do].not.exist }
+    end.should_not raise_exception
+  end
+
+  it 'should return the nil_value if given' do
+    egonil(9){ nil.some_methods.that[:do].not.exist }.should == 9
+  end
+
+  it 'should restore default behaviour after the block' do
+    proc do
+      egonil{ nil.some_methods.that[:do].not.exist }
+    end.should_not raise_exception
+
+    proc do
+      nil.a_method
+    end.should raise_exception NoMethodError
+  end
+
+  it 'raise NoMethodError for non-nil objects' do
+    proc do
+      egonil{ 5.a_method }
+    end.should raise_exception NoMethodError
+  end
+end
+

data/lib/zucker/1/specification/enumerable_spec.rb

@@ -0,0 +1,8 @@
+require 'enumerable'
+
+describe 'Enumerable#mash' do
+  it 'should "map" a hash' do
+    [1,2,3].mash{|e| [e, e.to_s] }.should == {1=>'1',2=>'2',3=>'3',}
+  end
+end
+

data/lib/zucker/1/specification/hash2proc_spec.rb

@@ -0,0 +1,12 @@
+require 'hash2proc'
+
+describe 'Hash#to_proc' do
+  it 'should run the proc given in the value for a key in the hash' do
+    [1,2,3,4].map(&{
+      4 => :to_s,
+      # 3 => [:to_s, 2]  # "11" =>  if array2proc is used
+      2 => lambda {|e| e + 1000}
+    }).should == [1, 1002, 3, "4"]
+  end
+end
+

data/lib/zucker/1/specification/hash_spec.rb

@@ -0,0 +1,10 @@
+require 'hash'
+
+describe 'Hash.zip' do
+  it 'should zip together both given enumerables and take them as key=>values for a new hash'
+end
+
+describe 'Hash#<<' do
+  it 'should append new elements to the hash'
+end
+

data/lib/zucker/1/specification/iterate_spec.rb

@@ -0,0 +1,54 @@
+require 'iterate'
+
+describe 'Object#iterate' do
+  let :a   do [1, 2, 3]     end
+  let :b   do %w|a b c d|   end
+  let :res do Hash.new {[]} end
+
+  it 'should behave like Enumerable#each for a single argument' do
+    iterate a do |ele|
+      res[:iter] << ele
+    end
+
+    a.each do |ele|
+      res[:each] << ele
+    end
+
+    res[:iter].should == res[:each]
+  end
+
+  it 'should pass the right params to the block' do
+    res = Hash.new {[]} # TODO: why?
+    res[:iter_a_b] = [] # ....
+    res[:iter_b_a] = [] # ....
+
+
+    iterate a, b do |e,f|
+      res[:iter_a_b] << [e, f]
+#      p res[:iter_a_b], e, f
+    end
+
+    res[:iter_a_b].should == [
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c'],
+      [nil, 'd'],
+    ]
+
+    iterate b, a do |e,f|
+      res[:iter_b_a] << [e, f]
+    end
+
+    res[:iter_b_a].should == [
+      ['a', 1],
+      ['b', 2],
+      ['c', 3],
+      ['d', nil],
+    ]
+
+  end
+
+  it 'should return enumerators if no block is applied' do
+  end
+end
+

data/lib/zucker/1/specification/ivars_spec.rb

@@ -0,0 +1,20 @@
+require 'ivars'
+
+describe 'instance_variables_from' do
+  it 'should tansform the given parameter to instance variables' do
+    def a_method(a = 1, b = 2)
+      instance_variables_from binding # assigns @a and @b
+
+      params = {:c => 3, :d => 4}
+      ivars params # # assigns @c and @d
+    end
+
+    a_method
+    @a.should == 1
+    @b.should == 2
+    @c.should == 3
+    @d.should == 4
+
+  end
+end
+

data/lib/zucker/1/specification/kernel_spec.rb

@@ -0,0 +1,34 @@
+require 'kernel'
+
+describe 'activate_warnings!' do
+  it 'should set $VERBOSE to true' do
+    activate_warnings!
+    $VERBOSE.should == true
+  end
+end
+
+describe 'deactivate_warnings!' do
+  it 'should set $VERBOSE to false' do
+    deactivate_warnings!
+    $VERBOSE.should == false
+  end
+end
+
+describe 'warnings_activated?' do
+  it 'should return $VERBOSE' do
+    warnings_activated?.should == $VERBOSE
+  end
+end
+
+describe 'library?' do
+  it 'should return false if the file is invoked directly' do
+    library?.should == ( __FILE__ != $PROGRAM_NAME )
+  end
+end
+
+describe 'ignore_sigint!' do
+  it 'should catch ctrl+c signals' do
+    # ...
+  end
+end
+

data/lib/zucker/1/specification/mcopy_spec.rb

@@ -0,0 +1,13 @@
+require 'mcopy'
+
+describe 'Object#mcopy' do
+  it 'create a (deep) copy via marshalling' do
+    a = %w[hello world]
+    b = a.mcopy
+    b.should == a
+
+    b[0][1,1] = ''
+    b.should_not == a
+  end
+end
+