as-extensions 0.1.0 → 0.1.1

data/ext/array.rb

@@ -44,12 +44,20 @@ Array.class_eval do
     self[0] = x
   end
 
-  def fpop
-    [last,init]
+  def fpop(n=nil)
+    n.nil? ? [last,init] : [self[(-n)..(-1)],self[0..(-(n+1))]]
   end
 
-  def fshift
-    [head,tail]
+  def fpush(*a)
+    self+a
+  end
+
+  def fshift(n=nil)
+    n.nil? ? [head,tail] : [self[0..(n-1)],self[n..-1]]
+  end
+
+  def funshift(*a)
+    a+self
   end
 
   alias :head :first

data/ext/base64.rb

@@ -0,0 +1,21 @@
+Base64.class_eval do
+
+  module_function
+
+  def urlsafe_encode64(bin,no_padding=nil)
+    r = strict_encode64(bin).tr("+/", "-_")
+    2.times{r.chomp!('=')} if no_padding
+    r
+  end
+
+  def urlsafe_decode64(str,no_padding=nil)
+    t = if no_padding
+      case (str.size % 4)
+        when 2; "#{str}=="
+        when 3; "#{str}="
+      else str end
+    else str end
+    strict_decode64(t.tr("-_", "+/"))
+  end
+
+end

data/ext/enumerable.rb

@@ -18,11 +18,12 @@
 #++
 
 Enumerable.class_eval do
-  
+
   # When a method doesn't exist, convert to an Array
-  def method_missing(method_sym, *arguments, &block)
-    if !is_a?(Array) && respond_to?(:to_a) then to_a.send(method_sym, *arguments, &block)
-    else super end
+  def method_missing(s,*args,&blk)
+    if [:to_str,:to_int].include?(s) || is_a?(Array) || !respond_to?(:to_a)
+      super
+    else to_a.send(s,*args,&blk) end
   end
-  
+
 end

data/ext/set.rb

@@ -18,10 +18,10 @@
 #++
 
 Set.class_eval do
-  
+
   # If method doesn't exist, consider as an Array.
-  def method_missing(s, *args, &blk)
-    self.to_a.send(s, *args, &blk)
+  def method_missing(s,*args,&blk)
+    [:to_str,:to_int].include?(s) ? super : to_a.send(s,*args,&blk)
   end
-  
+
 end

data/ext/string.rb

@@ -60,8 +60,8 @@ String.class_eval do
   
   # Consider the String as an Array of chars for a few methods
   if (RUBY_VERSION < "1.9")
-    def method_missing(n,*a,&b)
-      if ASE_ARRAY_METHODS.include?(n) then chars.to_a.send(n,*a,&b).join else super end
+    def method_missing(s,*args,&blk)
+      ASE_ARRAY_METHODS.include?(n) ? chars.to_a.send(s,*args,&blk).join : super
     end
   else
     ASE_ARRAY_METHODS.each{|n| define_method(n){|*a,&b| chars.to_a.send(n,*a,&b).join}}

data/ext/symbol.rb

@@ -18,11 +18,11 @@
 #++
 
 Symbol.class_eval do
-  
+
   # When a method doesn't exist, consider the Symbol as a String
   # Warning: this will *not* convert back to Symbol
-  def method_missing(method_sym, *arguments, &block)
-    to_s.send(method_sym, *arguments, &block)
+  def method_missing(s,*args,&blk)
+    [:to_str,:to_int].include?(s) ? super : to_s.send(s,*args,&blk)
   end
-  
+
 end

data/lib/as-extensions.rb

@@ -21,44 +21,49 @@
 $KCODE = "U" if (RUBY_VERSION < "1.9") && ($KCODE == "NONE")
 
 module ASE
-    
+
   class << self
-    
+
     # Require a part / parts of a library
-    def require_part(part, dir=nil)
+    def require_part(part,dir=nil)
       orig = caller(1).first.split(':').first
-      dir ||= File.join( File.dirname(orig), File.basename(orig, ".rb") )
+      dir ||= File.join(File.dirname(orig),File.basename(orig,".rb"))
       if part.is_a?(::Array)
-        part.each do |p| require_part(p, dir) end
+        part.each{|p| require_part(p,dir)}
       else
-        require File.join(dir, part)
+        require File.join(dir,part)
       end
     end
-    
+
     # Require an extension / extensions of a library
-    def require_ext(ext, dir=nil)
+    def require_ext(ext,dir=nil)
       orig = caller(1).first.split(':').first
-      dir ||= File.join( File.dirname(File.dirname(orig)), 'ext' )
+      dir ||= File.join( File.dirname(File.dirname(orig)),"ext")
       if ext.is_a?(::Array)
-        ext.each do |e| require_ext(e, dir) end
+        ext.each{|e| require_ext(e,dir)}
       else
-        require File.join(dir, ext)
+        require File.join(dir,ext)
       end
     end
-    
+
   end # class << self
-  
-  # This loading order (extra-ext, need, logger, log) is necessary to bootstrap need()
-  require_part %w{ extra-ext need }
-  need 'logger'
-  require_part 'log'
-  
+
+  # This loading order (extra-ext, need, logger, log)
+  # is necessary to bootstrap need()
+  require_part %w{extra-ext need}
+  need "logger"
+  require_part "log"
+
   # Now we can load everything normally
-  need %w{ active_support babosa fileutils map open-uri pathname uri set socket }
-  need %w{ active_support/core_ext }
-  require_part %w{ fs enum deep net test time ext-logic }
-  require_ext %w{ array datetime dir enumerable file hash io object set socket string symbol time uri }
-  
+  need %w{active_support babosa base64 fileutils map open-uri pathname uri
+           set socket}
+  need %w{active_support/core_ext}
+  require_part %w{fs enum deep net test time ext-logic}
+  require_ext %w{array base64 datetime dir enumerable file hash io object set
+                  socket string symbol time uri}
+
 end
 
-ActiveSupport::const_set('Extension', ASE) unless ActiveSupport::const_defined?('Extension')
+unless ActiveSupport::const_defined?("Extension")
+  ActiveSupport::const_set("Extension",ASE)
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Pierre Chapuis
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-23 00:00:00 +02:00
+date: 2011-08-05 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,6 +80,7 @@ extra_rdoc_files:
 - README.md
 files: 
 - ext/array.rb
+- ext/base64.rb
 - ext/boolean.rb
 - ext/datetime.rb
 - ext/dir.rb