fuby 0.0.1

data/lib/fuby/shift_unless.rb

@@ -0,0 +1,12 @@
+require_relative 'method_added_as_filter'
+
+module Fuby
+  refine ::Array do
+
+    def shift_unless
+      shift unless yield first
+    end
+
+    method_added_as_filter :shift_unless
+  end
+end

data/lib/fuby/shift_until.rb

@@ -0,0 +1,12 @@
+require_relative 'method_added_as_filter'
+
+module Fuby
+  refine ::Array do
+
+    def shift_until &blk
+      shift index(&blk)
+    end
+
+    method_added_as_filter :shift_until
+  end
+end

data/lib/fuby/shift_while.rb

@@ -0,0 +1,16 @@
+require_relative 'not'
+require_relative 'shift_until'
+require_relative 'method_added_as_filter'
+
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def shift_while &blk
+      shift_until &(blk.not)
+    end
+
+    method_added_as_filter :shift_while
+  end
+end

data/lib/fuby/splat.rb

@@ -0,0 +1,11 @@
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine Module
+
+    def splat
+      ::Enumerator.new { |result| each { |sig| result.<< *sig } }
+    end
+
+  end
+end

data/lib/fuby/strip.rb

@@ -0,0 +1,24 @@
+require_relative 'plus'
+
+using Fuby
+
+module Fuby
+  refine ::String do
+
+    def strip pattern = nil
+      return super unless ::RegExp === pattern
+      strip_beginning(pattern).strip_ending(pattern)
+    end
+
+    def strip_beginning pattern
+      pattern = /^/ + pattern unless /^\^/ === pattern.source
+      sub pattern, ''
+    end
+
+    def strip_ending pattern
+      pattern = pattern + /$/ unless /\$$/ === pattern.source
+      sub pattern, ''
+    end
+
+  end
+end

data/lib/fuby/subclass.rb

@@ -0,0 +1,22 @@
+require 'fuby/include'
+
+using Fuby
+
+module Fuby
+  refine ::Module do
+
+    def subclass *sig, &blk
+      case self
+      
+      when Class
+        Class.new self
+      
+      when Module
+        Class.new.include! self
+      
+      else super
+      end.include! *sig, &blk
+    end
+
+  end
+end

data/lib/fuby/submodule.rb

@@ -0,0 +1,22 @@
+require 'fuby/include'
+
+using Fuby
+
+module Fuby
+  refine ::Module do
+
+    def submodule *sig, &blk
+      case self
+      
+      when Class
+        Class.new self
+      
+      when Module
+        Module.new.include! self
+      
+      else super
+      end.include! *sig, &blk
+    end
+
+  end
+end

data/lib/fuby/suffix_of.rb

@@ -0,0 +1,19 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def suffix_of? that
+      eql? that.drop -length
+    end
+
+    def matches_suffix_of? that
+      matches? that.drop - length
+    end
+
+    method_added_as_binary_operator :suffix_of?, :matches_suffix_of?
+
+  end
+end
+
+Dir.glob "*_suffix_of.rb", &method(:require)

data/lib/fuby/suffixes.rb

@@ -0,0 +1,11 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def suffixes
+      (0 .. length - 1).map &(method :drop)
+    end
+
+  end
+end

data/lib/fuby/take.rb

@@ -0,0 +1,20 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def take i = 1
+      return []    if empty?
+      return super if i >= 0
+      return super i % length
+    end
+
+    def take! i = 1
+      pop length - i % length
+      self
+    end
+
+  end
+end
+
+Dir.glob "#{ __FILE__.chomp ".rb" }_*.rb", &method(:require)

data/lib/fuby/take_until.rb

@@ -0,0 +1,17 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def take_until &blk
+      take_while &(blk.not)
+    end
+
+    def take_until! &blk
+      take_while! &blk.not
+    end
+
+    method_added_as_filter :take_until, :take_until!
+
+  end
+end

data/lib/fuby/take_while.rb

@@ -0,0 +1,14 @@
+using Fuby
+
+module Fuby
+  refine ::Array do
+
+    def take_while! &blk
+      pop length - index(&blk)
+      self
+    end
+
+    method_added_as_filter :take_while, :take_while!
+
+  end
+end

data/lib/fuby/tap.rb

@@ -0,0 +1,28 @@
+using Fuby
+
+module Fuby
+  refine ::Object do
+
+    def tap &blk
+      return super if block_given?
+      return self
+    end
+
+    alias_method :tap?, :tap
+    alias_method :tap!, :tap
+
+  end
+  refine ::NilClass do
+
+    def tap?
+      self
+    end
+
+    def tap!
+      raise ::TypeError
+    end
+
+    alias_method :tap_each, :tap?
+
+  end
+end

data/lib/fuby/to.rb

@@ -0,0 +1 @@
+Dir.glob "#{ __FILE__.chomp ".rb" }_*.rb", &method(:require)

data/lib/fuby/to_boolean.rb

@@ -0,0 +1,32 @@
+using Fuby
+
+module Fuby
+  refine ::Numeric do
+
+    def to_boolean
+      self > 0
+    end
+
+    alias_method :to_b, :to_boolean
+
+  end
+  refine ::String do
+
+    def to_boolean
+      /^(t(rue)?|0*1|y(es)?)$/i === self
+    end
+
+    alias_method :to_b, :to_boolean
+
+  end
+  refine ::Symbol do
+
+    def to_boolean
+      @to_boolean = to_s.to_boolean if @to_boolean.nil?
+      @to_boolean
+    end
+
+    alias_method :to_b, :to_boolean
+
+  end
+end

data/lib/fuby/to_camel_case.rb

@@ -0,0 +1,32 @@
+require_relative 'to_components'
+
+using Fuby
+
+module Fuby
+  refine ::String do
+
+    def to_camelCase
+      components = to_components
+      first      = components.shift.downcase
+      components.map! { |str| str.sub /[A-z0-9]/, &:upcase }
+      components.unshift first
+      components.join
+    end
+
+    def to_CamelCase
+      to_components.map! { |str| str.sub /[A-z0-9]/, &:upcase }.join
+    end
+
+  end
+  refine ::Symbol do
+
+    def to_camelCase
+      @to_camelCase ||= to_s.to_camelCase.to_sym
+    end
+
+    def to_CamelCase
+      @to_CamelCase ||= to_s.to_CamelCase.to_sym
+    end
+
+  end
+end

data/lib/fuby/to_case.rb

@@ -0,0 +1 @@
+Dir.glob "to_*_case.rb", &method(:require)

data/lib/fuby/to_components.rb

@@ -0,0 +1,33 @@
+using Fuby
+
+module Fuby
+  refine ::String do
+
+    def to_components
+      return downcase.to_components if /[A-Z]/ === self unless /[a-z]/ === self # it's all CAPS
+      scan /[A-Z]+[0-9]*(?=_|\b|[^A-z]|[A-Z][a-z])|[A-Z]?[a-z]+[0-9]*(?=_|\b|[^a-z]|[A-Z])|[0-9]+[a-z]*/
+      # 
+      # presuming either some form of camelCase or lower_case, either:
+      # 
+      # a run of capitals optionally followed by an integer, excluding the capital leading a following CamelCase word
+      # e.g. HTML5, IE9
+      # 
+      # a run of lower-case letters optionally followed by an integer
+      # e.g. html5, ie9
+      # 
+      # a number or number word
+      # e.g. 1st, 2nd
+      # 
+      # a proper camelCase component
+    end
+
+  end
+  refine ::Symbol do
+
+    def to_components
+      @to_components ||= to_s.to_components.map(&:to_sym).freeze
+      @to_components.dup
+    end
+
+  end
+end

data/lib/fuby/to_dash_case.rb

@@ -0,0 +1,28 @@
+require_relative 'to_components'
+
+using Fuby
+
+module Fuby
+  refine ::String do
+
+    def to_DASH_CASE
+      to_components.join('-').upcase
+    end
+
+    def to_dash_case
+      to_components.join('-').downcase
+    end
+
+  end
+  refine ::Symbol do
+
+    def to_DASH_CASE
+      @to_DASH_CASE ||= to_s.to_DASH_CASE.to_sym
+    end
+
+    def to_dash_case
+      @to_dash_case ||= to_s.to_dash_case.to_sym
+    end
+
+  end
+end

data/lib/fuby/to_hash.rb

@@ -0,0 +1,25 @@
+require_relative 'descendants'
+require_relative 'each_with_index_or_key'
+
+using Fuby
+
+module Fuby
+  module ::Enumerable # can't refine a Module
+
+    def to_hash
+      {}.tap { |hash| each_with_index_or_key { |val, key| hash[key] = val } }
+    end
+
+    alias_method :to_h, :to_hash
+
+  end
+  refine ::Hash do
+
+    def to_hash
+      dup
+    end
+
+    alias_method :to_h, :to_hash
+
+  end
+end

data/lib/fuby/to_pred.rb

@@ -0,0 +1,7 @@
+class Object
+
+  def to_pred
+    method :===
+  end
+
+end

data/lib/fuby/to_proc.rb

@@ -0,0 +1,45 @@
+module Fuby
+  refine ::Array do
+
+    def to_proc
+      proc &method(:[])
+    end
+
+  end
+  refine ::Hash do
+    
+    def to_proc
+      proc do |arg|
+        if has_key? arg
+          self[arg]
+        else
+          self[keys.detect { |key| key === arg }]
+        end
+      end
+    end
+
+  end
+  refine ::String do
+
+    def to_proc
+      proc { |*sig| format self, *sig }
+    end
+
+  end
+  refine ::Regexp do
+    
+    def to_proc
+      proc do |arg|
+        arg[ arg.length - 1] if arg = match(arg)
+      end
+    end
+
+  end
+  refine ::Integer do
+
+    def to_proc
+      proc { |arg| arg[self] }
+    end
+
+  end
+end