facets 2.6.0 → 2.7.0

data/lib/more/facets/string/mask.rb

@@ -1,278 +0,0 @@
-require 'facets/functor'
-
-class String
-
-  # Create a mask.
-  def to_mask(re=nil)
-    Mask.new(self,re)
-  end
-
-  # = Mask
-  #
-  class Mask
-
-    ESC = "\032" # ASCII SUBSTITUTE
-
-  class << self
-
-    def [](string, re=nil)
-      new(string, re)
-    end
-
-    end # class<< self
-
-  protected
-
-    attr :string
-
-  private
-
-    def initialize(string, re=nil)
-      @string = string.dup
-      mask!(re) if re
-    end
-
-  public
-
-    def inspect ; string.inspect ; end
-    def to_s    ; string ; end
-
-    def [](*a)
-      string[*a]
-    end
-
-    def mask(re)
-      self.class.new(string,re)
-    end
-
-    def mask!(re)
-      string.gsub!(re){ |s| ESC * s.size }
-    end
-
-    # Mask subtraction. Where the characters are the same,
-    # the result is "empty", where they differ the result
-    # reflects the last string.
-    #
-    #     "abc..123"      "ab..789."
-    #   - "ab..789."    - "abc..123"
-    #     ----------      ----------
-    #     "....789."      "..c..123"
-    #
-    def -(other)
-      i = 0
-      o = ''
-      while i < string.size
-        if string[i,1] == other[i,1]
-          o << ESC
-        else
-          o << other[i,1]
-        end
-        i += 1
-      end
-      self.class.new(o)
-    end
-
-    # Mask ADD. As long as there is a value other
-    # then empty the character filters though.
-    # The last string takes precedence.
-    #
-    #     "abc..123"      "ab..789."
-    #   + "ab..789."    + "abc..123"
-    #     ----------      ----------
-    #     "abc.7893"      "abc.7123"
-    #
-    def +(other)
-      i = 0
-      o = ''
-      while i < string.size
-        if other[i,1] == ESC
-          o << string[i,1]
-        else
-          o << other[i,1]
-        end
-        i += 1
-      end
-      self.class.new(o)
-    end
-
-    # Mask OR is the same as ADD.
-    alias_method :|, :+
-
-    # Mask XAND. Where the characters are the same, the
-    # result is the same, where they differ the result
-    # reflects the later.
-    #
-    #     "abc..123"      "ab..789."
-    #   * "ab..789."    | "abc..123"
-    #     ----------      ----------
-    #     "ab..789."      "abc..123"
-    #
-    def *(other)
-      i = 0
-      o = ''
-      while i < string.size
-        if (c = string[i,1]) == other[i,1]
-          o << c
-        else
-          o << other[i,1]
-        end
-        i += 1
-      end
-      self.class.new(o)
-    end
-
-    # Mask AND. Only where they are
-    # then same filters through.
-    #
-    #     "abc..123"      "ab..789."
-    #   & "ab..789."    | "abc..123"
-    #     ----------      ----------
-    #     "ab......"      "ab......"
-    #
-    def &(other)
-      i = 0
-      o = ''
-      while i < string.size
-        if (c = string[i,1]) == other[i,1]
-          o << c
-        else
-          o << ESC
-        end
-        i += 1
-      end
-      self.class.new(o)
-    end
-
-    # Mask XOR operation. Only where there
-    # is an empty slot will the value filter.
-    #
-    #     "abc..123"      "ab..789."
-    #   | "ab..789."    | "abc..123"
-    #     ----------      ----------
-    #     "..c.7..3"      "..c.7..3"
-    #
-    def ^(other)
-      i = 0
-      o = ''
-      while i < string.size
-        if string[i,1] == ESC
-          o << other[i,1]
-        elsif other[i,1] == ESC
-          o << string[i,1]
-        else
-          o << ESC
-        end
-        i += 1
-      end
-      self.class.new(o)
-    end
-
-    #
-    def ==(other)
-      case other
-      when String::Mask
-        string == other.string
-      else
-        string == other.to_s
-      end
-    end
-
-    # Apply a method to the internal string
-    # and return a new mask.
-    def apply(s=nil,*a,&b)
-      if s
-        string.send(s,*a,&b).to_mask
-      else
-        @_self ||= Functor.new do |op, *a|
-          string.send(op,*a).to_mask
-        end
-      end
-    end
-
-    def replace(string)
-      @string = string.to_s
-    end
-
-    def instance_delegate
-      @string
-    end
-
-    # Functor on the interal string.
-    #def self
-    #  @_self ||= Functor.new do |op, *a|
-    #    @string = @string.send(op, *a)
-    #  end
-    #end
-
-    # Delegate any missing methods to underlying string.
-    #
-    def method_missing(s, *a, &b)
-      begin
-        str = string.send(s, *a, &b)
-      rescue NoMethodError
-        super(s, *a, &b)
-      end
-    end
-
-  end
-end
-
-
-=begin spec
-
-  require 'quarry/spec'
-
-  Quarry.spec "String::Mask" do
-
-    x1 = String::Mask["abc..123", '.']
-    x2 = String::Mask["ab..789.", '.']
-
-    verify "sub" do
-      r = x1 - x2
-      a = String::Mask["....789.", '.']
-      r.assert == a
-      r = x2 - x1
-      a = String::Mask["..c..123", '.']
-      r.assert == a
-    end
-
-    verify "add" do
-      r = x1 + x2
-      a = String::Mask["abc.7893", '.']
-      r.assert == a
-      r = x2 + x1
-      a = String::Mask["abc.7123", '.']
-      r.assert == a
-    end
-
-    verify "xand" do
-      r = x1 * x2
-      a = String::Mask["ab..789.", '.']
-      r.assert == a
-      r = x2 * x1
-      a = String::Mask["abc..123", '.']
-      r.assert == a
-    end
-
-    verify "and" do
-      r = x1 & x2
-      a = String::Mask["ab......", '.']
-      r.assert == a
-      r = x2 & x1
-      a = String::Mask["ab......", '.']
-      r.assert == a
-    end
-
-    verify "xor" do
-      r = x1 ^ x2
-      a = String::Mask["..c.7..3", '.']
-      r.assert == a
-      r = x2 ^ x1
-      a = String::Mask["..c.7..3", '.']
-      r.assert == a
-    end
-
-  end
-
-=end
-

data/lib/more/facets/string/obfuscate.rb

@@ -1,65 +0,0 @@
-module English
-
-  # = String Obfuscation
-  #
-  # The Obfuscate mixin provides a means of applying common
-  # scrambling patterns to strings.
-  #
-  # This module is automatically mixed into the String class, but
-  # the mixin is designed in such a way that it can be mixed into
-  # any class that supports the #to_s method.
-  #
-  # Examples
-  #
-  #   "superman".jumble  #=> "SUpeRmAn"
-  #
-  module Obfuscate
-
-    # Jumble string.
-    #
-    #
-    def jumble
-      j = ''
-      to_s.split(//).each_with_index{ |c,i| j << ( i % 2 == 0 ? c.downcase : c.upcase ) }
-      j
-    end
-
-    # Dresener Obfuscation.
-    #
-    # Scramble the inner characters of words leaving the text still readable
-    # (research at Cambridge University, code by KurtDresner).
-    #
-    # For example, the above text may result in:
-    #
-    #   Srblamce the iennr cchrteaars of wodrs lvenaig the txet stlil rbeaadle
-    #   (rreceash at Cbamigdre Uverintisy, cdoe by KrneruestDr?)
-    #
-    # :credit: Kurt Dresener
-    def dresner
-      to_s.gsub(/\B\w+\B/){$&.split(//).sort_by{rand}}
-    end
-
-    # Include Replace mixin if base class/module supports #replace method.
-    def self.included(base)
-      if base.instance_methods.include?('replace') or
-         base.instance_methods.include?(:replace) # Ruby 1.9
-        base.module_eval{ include Replace }
-      end
-    end
-
-    # TODO: Replace this will dynamic generate of inplace methods.
-    #       But only when the base defines #replace (?) Need to
-    #       think about this some more.
-    module Replace
-      def jumble!        ; replace(jumble)        ; end
-      def dresner!       ; replace(dresner)       ; end
-    end
-
-  end
-
-end
-
-class String #:nodoc:
-  include English::Obfuscate
-end
-

data/lib/more/facets/string/stylize.rb

@@ -1,169 +0,0 @@
-class String
-
-  # = String Stylization Extensions
-  #
-  # The Stylize mixin provides common transformation to strings.
-  #
-  # This module is automatically mixed into the String class, but
-  # the mixin is designed in such a way that it can be mixed into
-  # any class that supports the #to_s method.
-  #
-  # Examples
-  #
-  #   "super_man".dasherize  #=> "super-man"
-  #
-  #--
-  # TODO: With #pathize, is downcasing really needed? After all paths
-  #       can have capitalize letters ;p
-  #
-  # TODO: With #methodize, is downcasing any but the first letter
-  #       really needed? Desipite Matz preference methods can have
-  #       capitalized letters.
-  #++
-  module Stylize
-
-    # Ordinalize turns a number string into an ordinal string
-    # used to denote the position in an ordered sequence such
-    # as 1st, 2nd, 3rd, 4th.
-    #
-    #   '1'.ordinalize     # => "1st"
-    #   '2'.ordinalize     # => "2nd"
-    #   '1002'.ordinalize  # => "1002nd"
-    #   '1003'.ordinalize  # => "1003rd"
-    #
-    def ordinalize
-      number_string = to_s
-      if number_string =~ /\d{1,2}$/
-        number = $1.to_i     
-        if (11..13).include?(number.to_i % 100)
-          r = "#{number}th"
-        else
-          r = case number.to_i % 10
-            when 1; "#{number}st"
-            when 2; "#{number}nd"
-            when 3; "#{number}rd"
-            else    "#{number}th"
-          end
-        end
-        number_string.sub(/\d{1,2}$/, r)
-      else
-        number_string
-      end
-    end
-
-    # Replaces underscores with dashes in the string.
-    #
-    #   "puni_puni".dasherize  #=> "puni-puni"
-    #
-    def dasherize
-      to_s.gsub(/_/, '-')
-    end
-
-    # The reverse of +camelize+. Makes an underscored, lowercase form from
-    # the expression in the string.
-    #
-    # Changes '::' to '/' to convert namespaces to paths.
-    #
-    #   "ActiveRecord".underscore          #=> "active_record"
-    #   "ActiveRecord::Errors".underscore  #=> active_record/errors
-    #
-    def underscore
-      to_s.
-      gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-    end
-
-    # Converts a module or method name into a unix pathname.
-    # This method is geared toward code reflection.
-    #
-    #   "MyModule::MyClass".pathize    #=> my_module/my_class
-    #   "my_module__my_class".pathize  #=> my_module/my_class
-    #
-    # TODO: Make sure that all scenarios return a valid unix path.
-    # TODO: Make sure it is revertible.
-    #
-    # See also #modulize, #methodize
-    def pathize
-      to_s.
-      gsub(/__/, '/').
-      gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-    end
-
-    # Converts a module name into a valid method name.
-    # This method is geared toward code reflection.
-    #
-    # Examples
-    #   "SuperMan".methodize          #=> "super_man"
-    #   "SuperMan::Errors".methodize  #=> "super_man__errors
-    #   "MyModule::MyClass".methodize #=> "my_module__my_class"
-    #
-    # See also #modulize, #pathize
-    def methodize
-      to_s.
-      gsub(/\//, '__').
-      gsub(/::/, '__').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-    end
-
-    # Converts a pathized or methodized string into a valid ruby
-    # class or module name. This method is geared toward code
-    # reflection.
-    #
-    #   "camel_case".modulize          #=> "CamelCase"
-    #   "camel/case".modulize          #=> "Camel::Case"
-    #   "my_module__my_path".modulize  #=> "MyModule::MyPath"
-    #
-    # See also #methodize, #pathize
-    def modulize
-      to_s.
-      gsub(/__(.?)/){ "::#{$1.upcase}" }.
-      gsub(/\/(.?)/){ "::#{$1.upcase}" }.
-      gsub(/(?:_+)([a-z])/){ $1.upcase }.
-      gsub(/(^|\s+)([a-z])/){ $1 + $2.upcase }
-    end
-
-    # Removes the module part from a modularized expression.
-    #
-    #   "English::Style".demodulize  #=> "Style"
-    #   "Style".demodulize           #=> "Style"
-    #
-    #def demodulize
-    #  to_s.gsub(/^.*::/, '')
-    #end
-
-    # Include Replace mixin if base class/module supports #replace method.
-    def self.included(base)
-      if base.instance_methods.include?('replace') or
-         base.instance_methods.include?(:replace) # Ruby 1.9
-        base.module_eval{ include Replace }
-      end
-    end
-
-    # In place versions of Stylize methods.
-    module Replace
-      def ordinalize!    ; replace(ordinalize) ; end
-      def pathize!       ; replace(pathize)    ; end
-      def methodize!     ; replace(methodize)  ; end
-      def modulize!      ; replace(modulize)   ; end
-      def dasherize!     ; replace(dasherize)  ; end
-      def underscore!    ; replace(underscore) ; end
-    end
-
-  end
-
-end
-
-class String #:nodoc:
-  include String::Stylize
-end
-