zucker 0.9 → 1

data/lib/zucker/1/hash2proc.rb

@@ -10,3 +10,5 @@ class Hash
   end
 end
 
+# J-_-L
+

data/lib/zucker/D.rb

@@ -0,0 +1,19 @@
+module Kernel
+  def D(*args, &block)
+    if args.empty?
+      tap{
+        if block_given?
+          puts yield self
+        else
+          puts self.inspect
+        end
+      }
+    else
+      raise ArgumentError, ".D - The parser thought that the code after .D are method arguments... Please don't put a space after D or use .D() or .D{} in this case!"
+#      eval ...
+    end
+  end
+end
+
+# J-_-L
+

data/lib/zucker/aliases.rb

@@ -0,0 +1,28 @@
+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
+
+# constants - who would use these in real-world code for other things?
+Infinity = 1.0 / 0.0 # or 2*Float::MAX
+NaN      = 0.0 / 0.0
+
+# J-_-L
+

data/lib/zucker/all.rb

@@ -1,2 +1,6 @@
-require 'zucker/1/all'
+# require all the sugar ;)
+# see README for an explaination of what they do
+
+require 'zucker/1/default'
+require 'zucker/1/debug'
 

data/lib/zucker/array.rb

@@ -0,0 +1,17 @@
+class Array
+  def ^(other) # TODO: more efficient
+    (self - other) +
+    (other - self)
+  end
+
+  def sum # sry, you just need this one too often
+    inject :+
+  end
+
+  def chrs
+    self.pack 'C*'
+  end
+end
+
+# J-_-L
+

data/lib/zucker/array2proc.rb

@@ -0,0 +1,10 @@
+class Array
+  def to_proc
+    Proc.new{ |obj|
+      obj.send *self
+    }
+  end
+end
+
+# J-_-L
+

data/lib/zucker/binding.rb

@@ -0,0 +1,25 @@
+class Binding
+  def inspect
+    put_vars = lambda { |array|
+      if array.empty?
+        ' - none'
+      else
+        array.map{|e| " - #{e}: #{ self.eval '#{e}'}"}*"\n"
+      end
+    }
+
+"#{self.to_s}
+local vars
+#{ put_vars[ self.eval 'local_variables' ] }
+(instance vars)
+#{ put_vars[ self.eval 'instance_variables' ] }
+self
+ - #{self.eval 'self'}
+block_given?
+ - #{self.eval 'block_given?'}"
+
+  end
+end
+
+# J-_-L
+

data/lib/zucker/blank.rb

@@ -0,0 +1,26 @@
+class Object
+  def blank?
+    if respond_to? :empty? then empty? else !self end
+  end
+
+  def present?
+    !blank?
+  end
+end
+
+
+{ # what to do              # for which classes
+  lambda{ true }         => [FalseClass, NilClass],
+  lambda{ false }        => [TrueClass, Numeric],
+  lambda{ empty? }       => [Array, Hash],
+  lambda{ self !~ /\S/ } => [String],
+  lambda{ self == //   } => [Regexp],
+
+}.each{ |action, klass_array|
+  klass_array.each{ |klass|
+    klass.send :define_method, :blank?, &action
+  }
+}
+
+# J-_-L
+

data/lib/zucker/class2proc.rb

@@ -0,0 +1,10 @@
+class Class
+  def to_proc
+    Proc.new do |*args|
+      self.new *args
+    end
+  end
+end
+
+# J-_-L
+

data/lib/zucker/debug.rb

@@ -1,2 +1,4 @@
-require 'zucker/1/debug'
+require 'zucker/1/D'
+require 'zucker/1/mm'
+require 'zucker/1/binding'
 

data/lib/zucker/default.rb

@@ -1,2 +1,25 @@
-require 'zucker/1/default'
+# default
+zucker = %w|
+aliases
+array
+array2proc
+blank
+class2proc
+egonil
+enumerable
+hash
+hash2proc
+iterate
+ivars
+kernel
+mcopy
+regexp2proc
+sandbox
+square_brackets_for
+string
+unary
+union
+|
+
+zucker.each{|rb| require "zucker/1/#{rb}"}
 

data/lib/zucker/desc/D.yaml

@@ -0,0 +1,23 @@
+D:
+  summary: Easy debug printing with the ⇧p⇧ alternative ⇧.D⇧. It outputs to stdout and returns ⇧self⇧. Accepts a block.
+  methods:
+    Object#D: |
+      some.D.methods.D.noone.D.knows.D
+      # ...outputs 4 lines with the inspected objects
+      # => (result)
+
+      21+Math.sin(42).D
+      # outputs -0.916521547915634
+      # => 20.0834784520844
+
+      name = 'Earth'
+      'Hello ' + name.D{|e| "The length is: #{e.size}"}
+      # outputs "The length is: 5"
+      # => 'Hello Earth'
+  package: debug
+  info:
+  - "This is inspired by the funny →⇧.tap⇧ method→http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions→"
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/aliases.yaml

@@ -0,0 +1,16 @@
+aliases:
+  summary: Some convenient aliases (and constants) for existing methods.
+  package: default
+  methods:
+    Object#is_an?: Object.is_a?
+    Enumerable#with: Enumerable#zip
+    Enumerable#%: Enumerable#zip
+    Array#**: Array#product
+    Hash#+: Hash#merge
+    Binding#[]: Binding#eval
+    Infinity: 1.0 / 0.0
+    NaN: 0.0 / 0.0
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/array.yaml

@@ -0,0 +1,14 @@
+array:
+  summary: Methods one could miss for ⇧Array⇧.
+  why:
+  - ⇧Array⇧ has ⇧&⇧ and ⇧|⇧, but why does it not have ⇧^⇧?
+  - ⇧sum⇧ is an alias for ⇧inject(:+)⇧, but it is just needed pretty often!
+  methods:
+    Array#^: "[1,2,3,4] ^ [3,4,5,6]  # => [1,2,5,6]"
+    Array#sum: "[1,2,3,4,5].sum  # => 15"
+    Array#chrs: "[72, 97, 108, 108, 111].chrs  # => 'Hallo'"
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/array2proc.yaml

@@ -0,0 +1,13 @@
+array2proc:
+  summary: Calls the method named by the first paramenter and passes the other elements as paramaters.
+  why: When using ⇧Symbol#to_proc⇧, you often wish to pass parameters.
+  methods:
+    Array#to_proc: '[1,2,3,4].map( &[:to_s, 2] )  # => ["1", "10", "11", "100"]'
+  info:
+  - Inspired by →this article→http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby→.
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/binding.yaml

@@ -0,0 +1,10 @@
+binding:
+  summary: Adds a verbose Binding#inspect
+  why: It gives you information about the current environment
+  methods:
+    Binding#inspect: binding.inspect
+  package: debug
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/blank.yaml

@@ -0,0 +1,12 @@
+blank:
+  summary: Does pretty the same as in ActiveSupport (Every object can be asked if it is blank)
+  why: It's too familiar ;)
+  methods:
+    Object#blank?: "'an object'.blank? # => false"
+  package: default
+  info:
+  - See ActiveSupport
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/class2proc.yaml

@@ -0,0 +1,12 @@
+class2proc:
+  summary: Creates a new instance of the class.
+  methods:
+    Class#to_proc: "[ [1,2],[3,5,6,7,3] ].map(&Set) # => [ Set[1,2], Set[5,6,7,3] ]"
+  package: default
+  info:
+  - Inspired by Ruby Facets.
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/egonil.yaml

@@ -0,0 +1,17 @@
+egonil:
+  summary: Creates a block, where ⇧nil⇧ does not raise ⇧NoMethodError⇧s.
+  methods:
+    egonil, nn: |
+      egonil do
+        nil.some_methods.that[:do].not.exist
+      end # => nil
+
+      nn(5){ nil.some_methods.that[:do].not.exist }
+      # => 5
+  package: default
+  info:
+  - See →this post→http://rbjl.net/26-the-28-bytes-of-ruby-joy→ for more information and discussion
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/enumerable.yaml

@@ -0,0 +1,11 @@
+enumerable:
+  summary: ⇧Enumerable⇧ extensions.
+  methods:
+    Enumerable#mash: "[1,2,3].mash{|e| [e, e.to_s] } # => {1=>'1',2=>'2',3=>'3'}"
+  package: default
+  info:
+  - Inspired by Ruby Facets' mash
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/hash.yaml

@@ -0,0 +1,12 @@
+hash:
+  summary: Some sugar for dealing with hashs.
+  methods:
+    Hash.zip: "Hash.zip [1,2,3], [4,5,6] # => {1 => 4, 2 => 5, 3 => 6}"
+    Hash#<<: "{1 => 2} << [3, 4] # => {1 => 2, 3 => 4}"
+  package: default
+  info:
+  - Some of the operators are inspired by Ruby Facets
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/hash2proc.yaml

@@ -0,0 +1,11 @@
+hash2proc:
+  summary: Use a hash to apply procs to specific objects.
+  methods:
+    Hash#to_proc: "[1,2,3,4].map(&{\n2 => lambda {|e| e + 1000},\n4 => :to_s,\n}) # => [1, 1002, 3, '4']"
+  package: default
+  info:
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/iterate.yaml

@@ -0,0 +1,17 @@
+iterate:
+  summary: Iterate over one or more collections.
+  why: "It's like ⇧.each⇧ with two differences: It feels more like a control structure and you can easily iterate over multiple objects."
+  methods:
+    iterate: |
+      iterate [1,2], [3,4,5] do |e,f|
+        puts "#{e},#{f}"
+      end
+      # outputs
+      #  1,3
+      #  2,4
+      #  ,5
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/desc/ivars.yaml

@@ -0,0 +1,20 @@
+ivars:
+  summary: This method lets you easily assign lots of instance variables.
+  why: |
+   Often, you have to write boilerplate code for assigning instance varialbles, for example this one:
+   ⇧def initialize(variable1, variable2)
+     @variable1, @variable2 = variable1, variable2
+   end⇧
+  methods:
+    instance_variables_from, ivars: |
+      def a_method(a = 1, b = 2)
+        instance_variables_from binding # assigns @a and @b
+
+        params = {:c => 3, :d => 4}
+        instance_variables_from params # # assigns @c and @d
+      end
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+