zucker 13.1 → 100.0.0

data/lib/zucker.rb

@@ -1,52 +1,22 @@
-# documentation at http://rubyzucker.info or doc/zucker_doc.html
+begin
+  require 'refine'
+rescue LoadError
+  if RUBY_VERSION < '2.0'
+    warn "The zucker library depends on refinements, please install the refine gem, when running a RubyVersion < 2.0"
+  end
+end
 
 module Zucker
-  # version and date get modified by the :prepare_release rake task
-  VERSION = '13.1'
-  DATE = '2013-04-30'
-  
-  # cube list
-  PACKS = {
-    :control    => %w|egonil iterate tap sandbox kernel|,
-    :env        => %w|engine info os ruby_version|,
-    :extensions => %w|array case enumerable file hash string unary union|,
-    :object     => %w|blank mcopy not|,
-    :to_proc    => %w|array_to_proc class_to_proc hash_to_proc regexp_to_proc|,
-    :shortcuts  => %w|aliases alias_for square_brackets_for ivars|,
-    :debug      => %w|binding cc dd mm oo qq regexp_visualize|,
-  }
-
-  NON_1_8_CUBES = %w|not case|
+  VERSION = '100.0.0'
+  DATE = '2014-04-01'
 
   class << self
-    # Zucker require helpers
-    def require_cube(cube)
-      unless RUBY_VERSION < '1.9' && Zucker::NON_1_8_CUBES.include?(cube)
-        require "zucker/#{cube}"
-      end
-    end
-
-    def require_pack(pack)
-      PACKS[pack.to_sym].each{ |cube|
-        require_cube cube
-      }
-    end
-
-    def require_this(filename) # pack shortcut
-      pack = ::File.basename( filename ).chomp( ::File.extname( filename ))
-      require_pack(pack)
-    end
-
-    def require_default
-      PACKS.map{ |pack, _|
-        require_pack pack if pack != :debug
-      }.compact
+    def require(cube)
+      require_relative "zucker/#{cube}"
     end
 
     def require_all
-      require_default + [require_pack( :debug )]
+      Dir[File.dirname(__FILE__) + '/zucker/*'].each{ |f| self.require File.basename(f) }
     end
   end
 end
-
-# J-_-L

data/lib/zucker/alias_for.rb

@@ -1,22 +1,15 @@
 require 'zucker'
-module Zucker AliasFor = true end
 
-def alias_for(m, *aliases)
-  aliases.each{ |a|
-    class_eval "alias :'#{ a.to_s }' :'#{ m.to_s }'"
-  }
-end
-alias aliases_for alias_for
+module Zucker
+  module AliasFor
+    refine Module do
+      private
 
-class Module
-  def alias_method_for(m, *alias_methods)
-    alias_methods.each{ |a|
-      class_eval do
-        alias_method a.to_sym, m.to_sym
+      def alias_for(m, *aliases)
+        aliases.each{ |a| class_eval "alias :'#{ a }' :'#{ m }'" }
       end
-    }
+
+      alias aliases_for alias_for
+    end
   end
-  alias alias_methods_for alias_method_for
 end
-
-# J-_-L

data/lib/zucker/all.rb

@@ -1,4 +1,2 @@
 require 'zucker'
 Zucker.require_all
-
-# J-_-L

data/lib/zucker/array_op.rb

@@ -0,0 +1,15 @@
+require 'zucker'
+
+module Zucker
+  module ArrayOp
+    refine Array do
+      def ^(other)
+        (self - other) + (other - self)
+      end
+
+      def **(*o, &block)
+        product *o, &block
+      end
+    end
+  end
+end

data/lib/zucker/blank.rb

@@ -1,29 +1,47 @@
 require 'zucker'
-module Zucker Blank = true end
 
-class Object
-  def blank?
-    if respond_to? :empty? then empty? else !self end
-  end
+module Zucker
+  module Blank
+    refine Object do
+      def blank?
+        if respond_to? :empty? then empty? else !self end
+      end
 
-  def present?
-    !blank?
-  end
-end
+      def present?
+        !blank?
+      end
+    end
+
+    refine NilClass do
+      def blank?() true end
+    end
 
+    refine FalseClass do
+      def blank?() true 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],
+    refine TrueClass do
+      def blank?() false end
+    end
 
-}.each{ |action, klass_array|
-  klass_array.each{ |klass|
-    klass.send :define_method, :blank?, &action
-  }
-}
+    refine Numeric do
+      def blank?() false end
+    end
 
-# J-_-L
+    refine Array do
+      def blank?() empty? end
+    end
 
+    refine Hash do
+      def blank?() empty? end
+    end
+
+    refine String do
+      def blank?() self !~ /\S/ end
+    end
+
+    refine Regexp do
+      def blank?() self == // end
+    end
+  end
+end

data/lib/zucker/camel_snake.rb

@@ -0,0 +1,15 @@
+require 'zucker'
+
+module Zucker
+  module CamelSnake
+    refine String do
+      def to_snake
+        gsub(/(?<!^)[A-Z]/) do "_#$&" end.downcase
+      end
+
+      def to_camel
+        gsub(/(?:^|_)([a-z])/) do $1.upcase end
+      end
+    end
+  end
+end

data/lib/zucker/constantize.rb

@@ -0,0 +1,29 @@
+require 'zucker'
+
+module Zucker
+  module Constantize
+    refine String do
+      def constantize(default_value = nil) # always uses global scope as in AS... is this good?
+        get_constant = lambda{
+          self.split(/::/).inject( Object ){ |base_constant, current_constant|
+            base_constant.const_get current_constant
+          }
+        }
+
+        if !default_value && !block_given?
+          get_constant.call
+        else
+          begin
+            get_constant.call
+          rescue NameError
+            if block_given?
+              yield self
+            else
+              default_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zucker/dir_extras.rb

@@ -0,0 +1,20 @@
+require 'zucker'
+require 'fileutils'
+
+module Zucker
+  module DirExtras
+    refine Dir.singleton_class do
+      def join(*args)
+        File.join(*args)
+      end
+
+      def split(*args)
+        File.split(*args)
+      end
+
+      def rm(*args)
+        FileUtils.rm_r(*args)
+      end
+    end
+  end
+end

data/lib/zucker/egonil.rb

@@ -1,28 +1,17 @@
 require 'zucker'
-module Zucker Egonil = true end
 
-# code by Yohan, slightly edited and comments by me
-def egonil(&block)
-  # grip methods
-  ori_method_missing   = NilClass.instance_method(:method_missing)
-  catch_method_missing = NilClass.instance_method(:catch_method_missing)
-  # activate ego mode
-  NilClass.send :define_method, :method_missing, catch_method_missing
-  # run code
-  yield
-ensure
-  # no matter what happens: restore default nil behaviour
-  NilClass.send :define_method, :method_missing, ori_method_missing
-end
+module Zucker
+  module Egonil
+    refine Object do
+      private
 
-# this is the ego nil
-class NilClass
-  def catch_method_missing(m, *args, &block)
-    nil
+      def egonil(&block)
+        mm = NilClass.instance_method(:method_missing)
+        NilClass.send :define_method, :method_missing, ->(*){}
+        yield
+      ensure
+        NilClass.send :define_method, :method_missing, mm
+      end
+    end
   end
-end
-
-alias nn egonil
-
-# J-_-L
-
+end

data/lib/zucker/file_extras.rb

@@ -0,0 +1,33 @@
+require 'zucker'
+
+module Zucker
+  module FileExtras
+    refine File.singleton_class do
+      def filename(*args, &block)
+        basename(*args, &block)
+      end
+
+      def gsub(filename, regex_hash)
+        data = File.read filename
+        File.open(filename,'w'){ |file|
+          regex_hash.each{ |regex, new_string|
+            regex = regex.to_s unless regex.is_a? Regexp
+
+            if new_string.is_a? Proc
+              data.gsub! regex, &new_string
+            else
+              data.gsub! regex, new_string
+            end
+          }
+          file.print data
+        }
+      end
+
+
+      def delete!(filename)
+        return nil if !File.exist?(filename)
+        File.delete filename
+      end
+    end
+  end
+end

data/lib/zucker/hash_extras.rb

@@ -0,0 +1,11 @@
+require 'zucker'
+
+module Zucker
+  module HashExtras
+    refine Hash.singleton_class do
+      def zip(keys, values)
+        Hash[ *keys.zip(values).flatten ]
+      end
+    end
+  end
+end

data/lib/zucker/hash_op.rb

@@ -0,0 +1,28 @@
+require 'zucker'
+
+module Zucker
+  module HashOp
+    refine Hash do
+      def <<(other)
+        case
+        when other.is_a?(Hash)
+          merge! other
+        when other.is_a?(Enumerable) || other.respond_to?(:to_splat)
+          merge! Hash[*other]
+        else
+          raise TypeError, 'can only append other Hashs and Enumerables (or Classes that implement to_splat)'
+        end
+      end
+
+      def &(other)
+        Hash[ *select{ |k,v|
+          other[k] == v
+        }.flatten ]
+      end
+
+      def +(*o, &block)
+        merge *o, &block
+      end
+    end
+  end
+end

data/lib/zucker/instance_variables_from.rb

@@ -0,0 +1,34 @@
+require 'zucker'
+
+module Zucker
+  module InstanceVariablesFrom
+    refine Object do
+      private
+
+      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
+    end
+  end
+end
+
+

data/lib/zucker/iterate.rb

@@ -1,28 +1,31 @@
 require 'zucker'
-module Zucker Iterate = true end
 
-def iterate(*params)
-  # params.shift.zip(*params).each{ |*elements| yield *elements }
-  raise ArgumentError, "wrong number of arguments (0)" if params.empty?
+module Zucker
+  module Iterate
+    refine Object do
+      def iterate(*params)
+        # params.shift.zip(*params).each{ |*elements| yield *elements }
+        raise ArgumentError, "wrong number of arguments (0)" if params.empty?
 
-  first = params.shift
-  if params.empty? # single param - like each
-    if block_given?
-      first.map{|e| yield e }
-    else
-      first.map.to_enum
-    end
-  else # multiple params
-    max_size = [first, *params].max_by(&:count).size
-    padded_first = first.to_a + [nil]*(max_size - first.count)  # append nils
-    obj = padded_first.zip(*params)
-    if block_given?
-      obj.map{|es| yield(*es) }
-    else
-      obj.map.to_enum
+        first = params.shift
+        if params.empty? # single param - like each
+          if block_given?
+            first.map{|e| yield e }
+          else
+            first.map.to_enum
+          end
+        else # multiple params
+          max_size = [first, *params].max_by(&:count).size
+          padded_first = first.to_a + [nil]*(max_size - first.count)  # append nils
+          obj = padded_first.zip(*params)
+          if block_given?
+            obj.map{|es| yield(*es) }
+          else
+            obj.map.to_enum
+          end
+        end
+      end
     end
   end
 end
 
-# J-_-L
-