facets-glimmer 3.2.0

data/lib/core/facets/string/shatter.rb

@@ -0,0 +1,22 @@
+class String
+
+  # Breaks a string up into an array based on a regular expression.
+  # Similar to scan, but includes the matches.
+  #
+  #   s = "<p>This<b>is</b>a test.</p>"
+  #   s.shatter( /\<.*?\>/ )
+  #
+  # _produces_
+  #
+  #   ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+  #
+  # CREDIT: Trans
+
+  def shatter( re )
+    r = self.gsub( re ){ |s| "\1" + s + "\1" }
+    while r[0,1] == "\1" ; r[0] = '' ; end
+    while r[-1,1] == "\1" ; r[-1] = '' ; end
+    r.split("\1")
+  end
+
+end

data/lib/core/facets/string/similarity.rb

@@ -0,0 +1,90 @@
+class String
+
+  # A fuzzy matching mechanism. Returns a score from 0-1, based
+  # on the number of shared edges. To be effective, the strings
+  # must be of length 2 or greater.
+  #
+  #     "Alexsander".similarity("Aleksander")  #=> 0.9
+  #
+  # The way it works:
+  #
+  # 1. Converts each string into a "graph like" object, with edges ...
+  #
+  #        "alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ]
+  #        "aleksander" -> [ aleksander, aleksand ... etc. ]
+  #
+  # 2. Perform match, then remove any subsets from this matched set (i.e. a hit
+  # on "san" is a subset of a hit on "sander") ...
+  #
+  #        Above example, once reduced -> [ ale, sander ]
+  #
+  # 3. See's how many of the matches remain, and calculates a score based
+  # on how many matches, their length, and compare to the length of the
+  # larger of the two words.
+  #
+  # Still a bit rough. Any suggestions for improvement are welcome.
+  #
+  # CREDIT: Derek Lewis
+
+  def similarity(str_in)
+    return 0 if str_in == nil
+    return 1 if self == str_in
+
+    # -- make a graph of each word (okay, its not a true graph, but is similar)
+    graph_A = Array.new
+    graph_B = Array.new
+
+    # -- "graph" self
+    last = self.length
+    (0..last).each do |ff|
+      #loc = self.length
+      break if ff == last - 1
+      wordB = (1..(last-1)).to_a.reverse!
+      if (wordB != nil)
+        wordB.each do |ss|
+          break if ss == ff
+          graph_A.push( "#{self[ff..ss]}" )
+        end
+      end
+    end
+
+    # -- "graph" input string
+    last = str_in.length
+    (0..last).each{ |ff|
+      #loc = str_in.length
+      break if ff == last - 1
+      wordB = (1..(last-1)).to_a.reverse!
+      wordB.each do |ss|
+        break if ss == ff
+        graph_B.push( "#{str_in[ff..ss]}" )
+      end
+    }
+
+    # -- count how many of these "graph edges" we have that are the same
+    matches = graph_A & graph_B
+
+    #--
+    #matches = Array.new
+    #graph_A.each{ |aa| matches.push(aa) if( graph_B.include?(aa) ) }
+    #++
+
+    # -- for eliminating subsets, we want to start with the smallest hits.
+    matches.sort!{|x,y| x.length <=> y.length}
+
+    # -- eliminate any subsets
+    mclone = matches.dup
+    mclone.each_index do |ii|
+      reg = Regexp.compile( Regexp.escape(mclone[ii]) )
+      count = 0.0
+      matches.each{|xx| count += 1 if xx =~ reg}
+      matches.delete(mclone[ii]) if count > 1
+    end
+
+    score = 0.0
+    matches.each{ |mm| score += mm.length }
+    self.length > str_in.length ? largest = self.length : largest = str_in.length
+    return score/(largest+1)
+  end
+
+end
+

data/lib/core/facets/string/snakecase.rb

@@ -0,0 +1,31 @@
+class String
+
+  # Underscore a string such that camelcase, dashes and spaces are
+  # replaced by underscores. This is the reverse of {#camelcase},
+  # albeit not an exact inverse.
+  #
+  #   "SnakeCase".snakecase         #=> "snake_case"
+  #   "Snake-Case".snakecase        #=> "snake_case"
+  #   "Snake Case".snakecase        #=> "snake_case"
+  #   "Snake  -  Case".snakecase    #=> "snake_case"
+  #
+  # Note, this method no longer converts `::` to `/`, in that case
+  # use the {#pathize} method instead.
+
+  def snakecase
+    #gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr('-', '_').
+    gsub(/\s/, '_').
+    gsub(/__+/, '_').
+    downcase
+  end
+
+  #
+  alias_method :underscore, :snakecase
+
+  # TODO: Add *separators to #snakecase, like camelcase.
+
+end
+

data/lib/core/facets/string/splice.rb

@@ -0,0 +1,33 @@
+require 'facets/string/store'
+
+class String
+
+  # String#slice is essentially the same as #store.
+  #
+  #   a = "HELLO"
+  #   a.splice(1, "X")
+  #   a                #=> "HXLLO"
+  #
+  # But it acts like #slice! when given a single argument.
+  #
+  #   a = "HELLO"
+  #   a.splice(1)    #=> "E"
+  #   a              #=> "HLLO"
+  #
+  # CREDIT: Trans
+
+  def splice(idx, sub=nil)
+    if sub
+      store(idx, sub)
+    else
+      case idx
+      when Range
+        slice!(idx)
+      else
+        slice!(idx,1)
+      end
+    end
+  end
+
+end
+

data/lib/core/facets/string/squish.rb

@@ -0,0 +1,22 @@
+class String
+  # Returns the string, first removing all whitespace on both ends of
+  # the string, and then changing remaining consecutive whitespace
+  # groups into one space each.
+  #
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  #
+  def squish
+    dup.squish!
+  end
+
+  # Performs a destructive squish. See String#squish.
+  def squish!
+    strip!
+    gsub!(/\s+/, ' ')
+    self
+  end
+end
+

data/lib/core/facets/string/starts_with.rb

@@ -0,0 +1,5 @@
+class String
+  alias starts_with? start_with?
+  alias ends_with?   end_with?
+end
+

data/lib/core/facets/string/store.rb

@@ -0,0 +1,7 @@
+class String
+
+  # Alias for []=.
+  alias_method :store, :[]=
+
+end
+

data/lib/core/facets/string/subtract.rb

@@ -0,0 +1,4 @@
+# TODO: Deprecate string/subtract file.
+#
+require 'facets/string/op_sub'
+

data/lib/core/facets/string/titlecase.rb

@@ -0,0 +1,27 @@
+class String
+
+  # Transform a string into a form that makes for an acceptable title.
+  #
+  #   "this is a string".titlecase
+  #   #=> "This Is A String"
+  #
+  # @author Eliazar Parra
+  # @author Angelo Lakra (apostrophe fix)
+
+  def titlecase
+    tr('_', ' ').
+    gsub(/\s+/, ' ').
+    gsub(/\b\w/){ $`[-1,1] == "'" ? $& : $&.upcase }
+  end
+
+  # Transform a string into a sentence like form.
+  #
+  #   "This Is A String".briefcase
+  #   #=> "This is a string"
+  #
+  def briefcase
+    titlecase.capitalize
+  end
+
+end
+

data/lib/core/facets/string/to_re.rb

@@ -0,0 +1,26 @@
+class String
+
+  # Turns a string into a regular expression.
+  #
+  #   "a?".to_re  #=> /a?/
+  #
+  # CREDIT: Trans
+
+  def to_re(esc=false)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+  # Turns a string into a regular expression.
+  # By default it will escape all characters.
+  # Use <tt>false</tt> argument to turn off escaping.
+  #
+  #   "[".to_rx  #=> /\[/
+  #
+  # CREDIT: Trans
+
+  def to_rx(esc=true)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+end
+

data/lib/core/facets/string/to_rx.rb

@@ -0,0 +1 @@
+require_relative 'to_re'

data/lib/core/facets/string/trim.rb

@@ -0,0 +1,45 @@
+class String
+
+  # Control the margin of a string using a trim character.
+  #
+  # The first character of the second line of the string
+  # is used as the trim character. This method is useful
+  # when literal multi-line strings are needed in code.
+  # 
+  # num - Number of extra spaces with which to replace the
+  #       trim character. [Integer]
+  #
+  # Examples
+  #
+  #     x = %Q{
+  #           | This
+  #           |   is
+  #           |    trim!
+  #           }.trim
+  #
+  # Returns string with the margin trimed-off.
+  #
+  # Note: This this method used to be called `margin` prior to Facets 3.0.
+  #
+  # Since: 3.0.0
+  # Author: Trans
+
+  def trim(num=0)
+    #d = /\A.*\n\s*(.)/.match( self )[1]
+    #d = /\A\s*(.)/.match( self)[1] unless d
+
+    md = /\A.*\n\s*(.)/.match(self) || /\A\s*(.)/.match(self)
+
+    d = md[1]
+
+    return '' unless d
+
+    if num == 0
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+    else
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * num)
+    end
+  end
+
+end
+

data/lib/core/facets/string/unbracket.rb

@@ -0,0 +1 @@
+require 'facets/string/bracket'

data/lib/core/facets/string/underscore.rb

@@ -0,0 +1 @@
+require 'facets/string/snakecase'

data/lib/core/facets/string/unfold.rb

@@ -0,0 +1,32 @@
+class String
+
+  # Unfold paragraphs such that new lines are removed from between
+  # sentences of the same paragraph.
+  #
+  # Note that #rstrip is called on the final result, but this may
+  # change in the future.
+  #
+  # FIXME: Sometimes adds one too many blank lines, which is why we are
+  #         using rstrip. Fix and probably remove the rstrip.
+  #
+  def unfold
+    blank = false
+    text  = ''
+    split(/\n/).each do |line|
+      if /\S/ !~ line
+        text << "\n\n"
+        blank = true
+      else
+        if /^(\s+|[*])/ =~ line
+          text << (line.rstrip + "\n")
+        else
+          text << (line.rstrip + " ")
+        end
+        blank = false
+      end
+    end
+    text = text.gsub(/(\n){3,}/,"\n\n")
+    text.rstrip
+  end
+
+end

data/lib/core/facets/string/unindent.rb

@@ -0,0 +1 @@
+require 'facets/string/indent'

data/lib/core/facets/string/unquote.rb

@@ -0,0 +1 @@
+require 'facets/string/quote'

data/lib/core/facets/string/uppercase.rb

@@ -0,0 +1,23 @@
+class String
+
+  # Upcase first letter.
+  #
+  # NOTE: One might argue that this method should behave the same as
+  # +#upcase+ and rather this behavior should be in place of +#captialize+.
+  # Probably so, but since Matz has already defined +#captialize+ the way
+  # it is, this name seems most fitting to the missing behavior.
+  #
+  def uppercase
+    str = to_s
+    str[0,1].upcase + str[1..-1]
+  end
+
+  # Downcase first letter.
+  #
+  def lowercase
+    str = to_s
+    str[0,1].downcase + str[1..-1]
+  end
+
+end
+

data/lib/core/facets/string/variablize.rb

@@ -0,0 +1,13 @@
+class String
+
+  # Prepend an "@" to the beginning of a string
+  # to make a instance variable name. This also replaces
+  # non-valid characters with underscores.
+
+  def variablize
+    v = gsub(/\W/, '_')
+    "@#{v}"
+  end
+
+end
+

data/lib/core/facets/string/word_wrap.rb

@@ -0,0 +1,32 @@
+class String
+
+  # Word wrap a string not exceeding max width.
+  #
+  #   "this is a test".word_wrap(4)
+  #
+  # _produces_ ...
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  # This is basic implementation of word wrap, but smart
+  # enough to suffice for most use cases.
+  #
+  # CREDIT: Gavin Kistner, Dayne Broderson
+  #
+  def word_wrap( col_width=80 )
+    self.dup.word_wrap!( col_width )
+  end
+
+  # As with #word_wrap, but modifies the string in place.
+  #
+  # CREDIT: Gavin Kistner, Dayne Broderson
+  #
+  def word_wrap!( col_width=80 )
+    self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+    self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+    self
+  end
+
+end

data/lib/core/facets/string/words.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Returns an array of characters.
+  #
+  #   "abc 123".words  #=> ["abc","123"]
+  #
+  def words
+    self.split(/\s+/)
+  end
+  
+  # Returns an array of words in the commonly-understood sense (not including punctuation).
+  # This takes into account international punctuation characters as well as English ones.
+  # 
+  #     'Slowly, grudgingly he said: "This has to stop."'.words
+  #      => ["Slowly", "grudgingly", "he", "said", "This", "has", "to", "stop"]
+  def words_without_punctuation
+    s = self.dup
+    s.gsub!(/[.?¿¡…!,:：;—"。？！、‘“”„«»〈〉《》，\/\[\]]/, ' ')
+    s.gsub!('- ', ' ')
+    s.squeeze!(" ")
+    s.strip.split(" ")
+  end  
+end
+

data/lib/core/facets/string/xor.rb

@@ -0,0 +1,26 @@
+class String
+
+  # Binary XOR of two strings. 
+  #
+  #   a = "\000\000\001\001" ^ "\000\001\000\001"
+  #   b = "\003\003\003" ^ "\000\001\002"
+  #
+  #   a  #=> "\000\001\001\000"
+  #   b  #=> "\003\002\001"
+  #
+  def ^(aString)
+    a = self.unpack('C'*(self.length))
+    b = aString.unpack('C'*(aString.length))
+    if (b.length < a.length)
+      (a.length - b.length).times { b << 0 }
+    end
+    xor = ""
+    0.upto(a.length-1) { |pos|
+      x = a[pos] ^ b[pos]
+      xor << x.chr()
+    }
+    return(xor)
+  end
+
+end
+

data/lib/core/facets/string.rb

@@ -0,0 +1,67 @@
+require_relative 'string/acronym.rb'
+require_relative 'string/align.rb'
+require_relative 'string/bracket.rb'
+require_relative 'string/camelcase.rb'
+require_relative 'string/capitalized.rb'
+require_relative 'string/cleanlines.rb'
+require_relative 'string/cleave.rb'
+require_relative 'string/cmp.rb'
+require_relative 'string/compress_lines.rb'
+#require_relative 'string/crypt.rb'          # uncommon
+require_relative 'string/divide.rb'
+require_relative 'string/each_word.rb'
+require_relative 'string/edit_distance.rb'
+require_relative 'string/ends_with.rb'
+require_relative 'string/exclude.rb'
+require_relative 'string/expand_tab.rb'
+require_relative 'string/file.rb'
+require_relative 'string/fold.rb'
+require_relative 'string/indent.rb'
+require_relative 'string/index_all.rb'
+require_relative 'string/interpolate.rb'
+require_relative 'string/lchomp.rb'
+require_relative 'string/line_wrap.rb'
+require_relative 'string/linear.rb'
+require_relative 'string/lowercase.rb'
+require_relative 'string/margin.rb'
+require_relative 'string/methodize.rb'
+require_relative 'string/modulize.rb'
+require_relative 'string/mscan.rb'
+require_relative 'string/natcmp.rb'
+require_relative 'string/nchar.rb'
+require_relative 'string/newlines.rb'
+require_relative 'string/number.rb'
+require_relative 'string/op_div.rb'
+require_relative 'string/op_sub.rb'          # included in `remove`.
+require_relative 'string/outdent.rb'
+require_relative 'string/pathize.rb'
+require_relative 'string/quote.rb'
+require_relative 'string/random.rb'
+require_relative 'string/range.rb'
+require_relative 'string/range_all.rb'
+require_relative 'string/range_of_line.rb'
+require_relative 'string/remove.rb'
+require_relative 'string/rewrite.rb'
+#require_relative 'integer/roman.rb'         # uncommon
+require_relative 'string/rotate.rb'
+require_relative 'string/shatter.rb'
+require_relative 'string/similarity.rb'
+require_relative 'string/snakecase.rb'
+require_relative 'string/splice.rb'
+require_relative 'string/squish.rb'
+require_relative 'string/starts_with.rb'
+require_relative 'string/store.rb'
+require_relative 'string/subtract.rb'
+require_relative 'string/titlecase.rb'
+require_relative 'string/to_re.rb'
+require_relative 'string/unbracket.rb'
+require_relative 'string/underscore.rb'
+require_relative 'string/unfold.rb'
+require_relative 'string/unindent.rb'
+require_relative 'string/unquote.rb'
+require_relative 'string/uppercase.rb'
+require_relative 'string/variablize.rb'
+require_relative 'string/words.rb'
+require_relative 'string/word_wrap.rb'
+require_relative 'string/xor.rb'
+

data/lib/core/facets/struct/attributes.rb

@@ -0,0 +1,15 @@
+class Struct
+
+  # Returns a hash containing the names and values
+  # for all instance settings in the Struct.
+  #
+  # This will eventually be deprecated in favor of #to_h.
+
+  def attributes
+    h = {}
+    each_pair { |k,v| h[k] = v }
+    h
+  end
+
+end
+

data/lib/core/facets/struct/replace.rb

@@ -0,0 +1,8 @@
+class Struct
+
+  # Struct#replace can take any +source+ that responds to #each_pair.
+  def replace(source)
+    source.each_pair{ |k,v| send(k.to_s + "=", v) }
+  end
+
+end

data/lib/core/facets/struct.rb

@@ -0,0 +1,3 @@
+require_relative 'struct/attributes.rb'
+require_relative 'struct/replace.rb'
+

data/lib/core/facets/symbol/as_s.rb

@@ -0,0 +1,19 @@
+require 'facets/functor'
+
+class Symbol
+
+  # TODO: Should Symbol#as_s be moved to functor gem?
+
+  # Convert symbol to string, apply string method and convert
+  # back to symbol via a fluent interface.
+  #
+  #   :HELLO.as_s.chomp('O')  #=> :HELL
+  #
+  def as_s
+    Functor.new do |op, *a|
+      to_s.send(op, *a).to_sym
+    end
+  end
+
+end
+

data/lib/core/facets/symbol/bang.rb

@@ -0,0 +1 @@
+require 'facets/symbol/plain'

data/lib/core/facets/symbol/call.rb

@@ -0,0 +1,29 @@
+class Symbol
+
+  # Useful extension for &:symbol which makes it possible
+  # to pass arguments for method in block
+  #
+  #   ['abc','','','def','ghi'].tap(&:delete.(''))
+  #   #=> ['abc','def','ghi']
+  #
+  #   [1,2,3].map(&:to_s.(2))
+  #   #=> ['1','10','11']
+  #
+  #   ['abc','cdef','xy','z','wwww'].select(&:size.() == 4)
+  #   #=> ['cdef', 'wwww']
+  #
+  #   ['abc','aaA','AaA','z'].count(&:upcase.().succ == 'AAB')
+  #   #=> 2
+  #
+  #   [%w{1 2 3 4 5},%w{6 7 8 9}].map(&:join.().length)
+  #   #=> [5,4]
+  #
+  # CREDIT: Ilya Vorontsov, Nobuyoshi Nakada
+
+  def call(*args, &block)
+    proc do |recv|
+      recv.__send__(self, *args, &block)
+    end
+  end
+
+end

data/lib/core/facets/symbol/chomp.rb

@@ -0,0 +1,24 @@
+class Symbol
+
+  # Just like String#chomp.
+  #
+  #   :ab.chomp(:b)  #=> :a
+  #
+  # CREDIT: Trans
+
+  def chomp(seperator)
+    to_s.chomp(seperator.to_s).to_sym
+  end
+
+  # Just like String#lchomp.
+  #
+  #   :ab.lchomp(:a)  #=> :b
+  #
+  # CREDIT: Trans
+
+  def lchomp(seperator)
+    to_s.reverse.chomp(seperator.to_s).reverse.to_sym
+  end
+
+end
+