zucker 0.9 → 1

data/lib/zucker/egonil.rb

@@ -0,0 +1,14 @@
+def egonil(nil_value = nil)
+  yield
+rescue NoMethodError => e
+  if e.message =~ /NilClass$/
+    nil_value
+  else
+    raise NoMethodError
+  end
+end
+
+alias nn egonil
+
+# J-_-L
+

data/lib/zucker/enumerable.rb

@@ -0,0 +1,12 @@
+module Enumerable
+  def mash
+    ret = {}
+    each{ |kv|
+      ret.store *( yield(kv)[0,2] )
+    }
+    ret
+  end
+end
+
+# J-_-L
+

data/lib/zucker/hash.rb

@@ -0,0 +1,19 @@
+class Hash
+  def self.zip(keys,values)
+    Hash[ *[1,2,3].zip( [4,5,6] ).flatten ]
+  end
+
+  def <<(other)
+    case
+    when other.is_a?(Hash)
+      merge! other
+    when other.respond_to?(:to_splat)
+      merge! Hash[*other]
+    else
+      raise TypeError, 'can only append other Hashs and Enumerables'
+    end
+  end
+end
+
+# J-_-L
+

data/lib/zucker/hash2proc.rb

@@ -0,0 +1,14 @@
+class Hash
+  def to_proc
+    Proc.new{ |obj|
+      if self.member? obj
+        self[obj].to_proc.call obj
+      else
+        obj
+      end
+    }
+  end
+end
+
+# J-_-L
+

data/lib/zucker/iterate.rb

@@ -0,0 +1,23 @@
+def iterate(*params)
+  # params.shift.zip(*params).each{ |*elements| yield *elements }
+
+  first = params.shift
+  if params.empty? # single param - like each
+    if block_given?
+      first.map{|e| yield e }
+    else
+      first.map
+    end
+  else
+    padded_first = Array.new( [first, *params].max_by(&:size).size ){|i| first[i] } # append nils
+    obj = padded_first.zip *params
+    if block_given?
+      obj.map{|es| yield *es }
+    else
+      obj.map.to_enum
+    end
+  end
+end
+
+# J-_-L
+

data/lib/zucker/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/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/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/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/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/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/spec/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/spec/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/spec/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/spec/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/spec/binding_spec.rb

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

data/lib/zucker/spec/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/spec/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/spec/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/spec/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/spec/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/spec/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/spec/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
+