facets-glimmer 3.2.0

data/lib/standard/facets/uri/parameters.rb

@@ -0,0 +1,63 @@
+require 'uri'
+
+module URI
+
+  # Allows for taking a hash and turning it into URI/CGI params
+  # Since 1.8.x does not have ordered hashes the params might not
+  # be ordered.
+  #
+  # @todo URI.parameters needs URI escaping.
+  #
+  # @author Matt Kirk
+
+  def self.parameters(hash)
+    hash.map do |k,v|
+      if v.respond_to?(:join)
+        "#{k}=#{v.join(",")}"
+      else
+        "#{k}=#{v}"
+      end
+    end.join("&")
+  end
+
+  # We cannot send nested hash as a param in HTTP requests. For example,
+  # when we would like to send something like this:
+  #
+  #     {:key => "value", :nested => {:nest => "value"}}
+  #
+  # It would be (or should be) mapped like this:
+  #
+  #     /url/?key=value&nested=%7B%3Anest%3D%3E%5C%22value%5C%22%7D 
+  #
+  # Doesn’t look to good ;) However there is a simple way to convert a nested
+  # hash into a params acceptable form. We can convert it to a form, that can
+  # be mapped into params like this:
+  #
+  #     /url/?key=value&nested[nest]=value 
+  #
+  # Here is method to convert any nested hash to a “one level” equivalent:
+  #
+  # @author Maciej Mensfeld
+
+  def self.nested_parameters(value, key=nil, hash={})
+    case value
+    when Hash
+      value.each do |k,v|
+        akey = key.nil? ? :"#{k}" : :"#{key}[#{k}]"
+        nested_parameters(v, akey, hash) 
+      end
+      out_hash
+    when Array
+      value.each do |v|
+        nested_parameters(v, "#{key}[]", hash)
+      end
+      hash
+    when nil then ''
+    else
+      hash[key] = value
+      hash
+    end
+    parameters(hash)
+  end
+ 
+end

data/lib/standard/facets/uri/query.rb

@@ -0,0 +1,148 @@
+# TODO: URI query methods need work and new consideration.
+
+require 'uri'
+require 'facets/uri/cgi_escape'
+require 'facets/module/alias_module_function'
+
+module URI
+
+  module_function
+
+  #
+  #
+  #
+  KEY_VALUE_SEPARATOR = ";"  # "&"
+
+  #
+  # Given a hash with parameter/value pairs construct a
+  # standard query string.
+  #
+  #   URI.hash_to_query(:a => 1, :b => 2)
+  #   #=> "a=1;b=2"
+  #
+  def query(parameters)
+    return '' unless parameters
+    pairs = []
+    parameters.each do |param, value|
+      pairs << "#{param}=#{cgi_escape(value.to_s)}"
+    end
+    return pairs.join(KEY_VALUE_SEPARATOR)
+  end
+
+  alias_module_function :hash_to_query, :query
+  alias_module_function :hash_to_query_string, :query
+
+  #
+  # Extend the basic query string parser provided by the cgi module.
+  # converts single valued params (the most common case) to
+  # objects instead of arrays
+  #
+  # Returns hash of parameters, contains arrays for multivalued parameters
+  # (multiselect, checkboxes , etc).
+  #
+  # If no query string is provided (nil or "") returns an empty hash.
+  #
+  def query_hash(query_string)
+    return {} unless query_string
+
+    query_parameters = cgi_parse(query_string)
+
+    query_parameters.each { |key, val|
+      ## replace the array with an object
+      query_parameters[key] = val[0] if 1 == val.length
+    }
+
+    ## set default value to nil! cgi sets this to []
+    query_parameters.default = nil
+
+    return query_parameters
+  end
+
+  alias_module_function :query_to_hash, :query_hash
+  alias_module_function :query_string_to_hash, :query_hash
+
+  #
+  # This method returns the query string of a uri.
+  #
+  # @param [String] uri
+  #   The uri string.
+  #
+  # @return [String] 
+  #   The query string, or `nil` if no query string.
+  #
+  def query_get(uri)
+    return nil unless uri
+    # gmosx: INVESTIGATE ruby's URI seems to differently handle
+    # abs and rel uris.
+    if md = URI::REGEXP::ABS_URI.match(uri)
+      return md[8]
+    elsif md = URI::REGEXP::REL_URI.match(uri)
+      return md[7]
+    end
+    return nil
+  end
+
+  alias_method :get_query_string, :query_get
+
+  #
+  # Removes the query string from a +uri+.
+  #
+  # Returns the chomped uri.
+  #
+  def query_chomp(uri)
+    return nil unless uri
+    query_string = self.get_query_string(uri)
+    return uri.dup.chomp("?#{query_string}")
+  end
+
+  alias_module_function :chomp_query_string, :query_chomp
+
+  #
+  # Get a uri and a hash of parameters. Inject the hash values
+  # as parameters in the query sting path. Returns the full uri.
+  #
+  # uri       - the uri to filter (String)
+  # parameter - hash of parameters to update
+  #
+  # Returns the full updated query string.
+  #
+  # @todo Optimize this method.
+  #
+  def query_update(uri, parameters)
+    query_string = self.query_get(uri)
+    rest = uri.dup.gsub(/\?#{query_string}/, "")
+
+    hash = self.query_string_to_hash(query_string)
+    hash.update(parameters)
+    query_string = self.hash_to_query_string(hash)
+
+    unless query_string.strip.empty?
+      return "#{rest}?#{query_string}"
+    else
+      return rest
+    end
+  end
+
+  alias_module_function :update_query_string, :query_update
+
+  #
+  # Gets the request uri, injects extra parameters in the query string
+  # and returns a new uri. The request object is not modified.
+  # There is always a qs string so an extra test is skipped.
+  #
+  # TODO: find a better name?
+  #
+  def update_request_uri(request, parameters)
+    hash = request.parameters.dup()
+    hash.update(parameters)
+
+    ## use this in hash_to_query
+    query_string = hash.collect { |k, v|
+      "#{k}=#{v}"
+    }.join(";")
+
+    ## return "#{request.translated_uri}?#{query_string}"
+    return "#{request.path}?#{query_string}"
+  end
+
+end

data/lib/standard/facets/uri.rb

@@ -0,0 +1,40 @@
+require 'uri'
+
+require 'facets/uri/cgi_escape.rb'
+require 'facets/uri/cgi_unescape.rb'
+require 'facets/uri/cgi_parse.rb'
+require 'facets/uri/decode.rb'
+require 'facets/uri/parameters.rb'
+require 'facets/uri/query.rb'
+
+module URI
+
+  module Kernel
+    #
+    def uri(s, w=%r{[^a-zA-Z_0-9./-]})
+      URI.escape(s, w)
+    end
+
+    #
+    def unuri(s)
+      URI.unescape(s)
+    end
+  end
+
+  module Hash
+    #
+    def to_uri
+      URI.hash_to_query(self)
+    end
+  end
+
+end
+
+class Object #:nodoc:
+  include URI::Kernel
+end
+
+class Hash #:nodoc:
+  include URI::Hash
+end
+

data/lib/standard/facets/yaml/file.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module YAML
+
+  # Provides a simplistic way to check if a file is a YAML formatted
+  # file:
+  #
+  #   YAML.file?('project.yaml')  #=> true
+  #   YAML.file?('project.xml')   #=> false
+  #
+  # Note this isn't perfect. At present it depends on the use
+  # use of an initial document separator (eg. '---'). With
+  # YAML 1.1 the %YAML delaration is supposed to be manditory,
+  # so in the future this can be adapted to fit that standard.
+
+  def self.file?(file)
+    File.open(file) do |f|
+      until f.eof?
+        line = f.gets
+        break true if line =~ /^---/
+        break false unless line =~ /^(\s*#.*?|\s*)$/
+      end
+    end
+  end
+
+end
+
+
+class File
+
+  # Same as `YAML.file?(file)`.
+  #
+  #   File.yaml?('project.yaml')  #=> true
+  #   File.yaml?('project.xml')   #=> false
+  #
+  def self.yaml?(file)
+    YAML.file?(file)
+  end
+
+end
+

data/lib/standard/facets/yaml/kernel.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Kernel
+
+  # The Kernel method #yaml is a shortcut to YAML::load.
+  #
+  #   data = yaml %{
+  #     a: 1
+  #     b: 2
+  #   }  
+  #   data #=> {"a"=>1, "b"=>2}
+  #
+  def yaml(*args,&blk)
+    YAML.load(*args,&blk)
+  end
+
+  # As with #to_yaml but removes the header line (i.e. '---') to create
+  # a "YAML fragment".
+  #
+  # @author Trans
+  #
+  def to_yamlfrag
+    y = to_yaml
+    y.sub!(/---\ */, '')
+    y
+  end
+
+end
+

data/lib/standard/facets/yaml/read.rb

@@ -0,0 +1,12 @@
+module YAML
+
+  # Alias for `YAML.load_file` and the same as:
+  #
+  #   YAML.load(File.new(file))
+  #
+  def self.read(file)
+    load(File.new(file))
+  end
+
+end
+

data/lib/standard/facets/yaml.rb

@@ -0,0 +1,6 @@
+require 'yaml'
+
+require 'facets/yaml/file'
+require 'facets/yaml/read'
+require 'facets/yaml/kernel'
+

data/lib/standard/facets/zlib.rb

@@ -0,0 +1,38 @@
+# A convenient wrapper for the zlib standard library that allows
+# compression/decompression of strings with gzip.
+
+module Zlib
+
+  ##class Stream < StringIO
+  ##  def close; rewind; end
+  ##end
+
+  # Decompresses a gzipped string.
+  def self.decompress(source)
+    GzipReader.new(StringIO.new(source)).read
+  end
+
+  # Compresses a string using gzip.
+  def self.compress(source)
+    output = StringIO.new
+    class << output
+      def close; rewind; end
+    end
+    gz = GzipWriter.new(output)
+    gz.write(source)
+    gz.close
+    output.string
+  end
+
+  # Inflate a deflated sting.
+  def self.inflate(string)
+    Inflate.inflate(string)
+  end
+
+  # Deflate a string.
+  def self.deflate(string, level=DEFAULT_COMPRESSION)
+    Deflate.deflate(string, level)
+  end
+
+end
+

data/test/core/array/test_arrange.rb

@@ -0,0 +1,37 @@
+require 'facets/array/arrange'
+
+test_case Array do
+
+	method :rangify do
+		test 'Array of consecutive integers should return an array made up of a single range.' do
+			[1,2,3,4,5].rangify.assert == [1..5]
+		end
+		
+		test 'Array of non-consecutive integers should return the original array.' do
+			[1,3,5,7].rangify.assert == [1,3,5,7]
+		end
+
+		test 'Array of ranges should return the correct ranges.' do
+			arr = [40..45, 1..3, 4..10, 20..30, 24..28, 42..50, 1..6, 1..3, 1..1]
+			arr.rangify.assert == [1..10, 20..30, 40..50]
+		end
+		
+		test 'Array of ranges and integers should return the correct ranges.' do
+			arr = [99, 100, 1..3, 101, 4..5, 103, 10..19, 99, 20..20, 31, 32..33, 98, 97]
+			arr.rangify.assert == [1..5, 10..20, 31..33, 97..101, 103]
+		end	
+
+		test 'Array of non-consecutive integers should return the correct ranges.' do
+			[1,2,3,6,7,8,10,15].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+	
+		test 'Element order should not affect the result.' do
+			[8, 1, 15, 2, 6, 3, 7, 10].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+		
+		test 'Duplicate elements should not affect the result.' do
+			[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.assert == [1..3, 6..8, 10, 15] 
+		end
+	end
+
+end

data/test/core/array/test_average.rb

@@ -0,0 +1,16 @@
+require 'facets/array/average'
+
+test_case Array do
+  method :average do
+    test 'Empty array returns nil' do
+      [].average.assert == nil
+    end
+
+    test 'Calculate average of array of numerical values' do
+      [1, 2, 3].average.assert == 2
+      [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].average.assert == 54.2
+      [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].average.assert == -6.7
+      [60.7829, 31.2622, 20.626, 78.8907, 61.5328].average.assert == 50.61892
+    end
+  end
+end

data/test/core/array/test_before.rb

@@ -0,0 +1,48 @@
+covers 'facets/array/before'
+
+test_case Array do
+
+  method :before do
+
+    setup do
+      @sequence = ['a', 'b', 'c']
+    end
+
+    test "returns the previous element" do
+      @sequence.before('b').assert == 'a'
+      @sequence.before('c').assert == 'b'
+    end
+
+    test "loops around from back to front" do
+      @sequence.before('a').assert == 'c'
+    end
+
+    test "non-member elements return nil" do
+      @sequence.before('d').assert == nil
+    end
+
+  end
+
+  method :after do
+
+    setup do
+      @sequence = ['a', 'b', 'c']
+    end
+
+    test "returns the following element" do
+      @sequence.after('a').assert == 'b'
+      @sequence.after('b').assert == 'c'
+    end
+
+    test "loops around from back to front" do
+      @sequence.after('c').assert == 'a'
+    end
+
+    test "non-member elements return nil" do
+      @sequence.after('d').assert == nil
+    end
+
+  end
+
+end
+

data/test/core/array/test_collapse.rb

@@ -0,0 +1,23 @@
+covers 'facets/array/collapse'
+
+test_case Array do
+
+  method :collapse do
+
+    test do
+      [1, nil, [1, 2], nil, [[3]]].collapse.assert == [1, 1, 2, 3]
+    end
+
+  end
+
+  method :collapse! do
+
+    test do
+      a = [1, nil, [1, 2], nil, [[3]]]
+      a.collapse!
+      a.assert == [1, 1, 2, 3]
+
+    end
+  end
+end
+

data/test/core/array/test_commonality.rb

@@ -0,0 +1,35 @@
+covers 'facets/array/commonality'
+
+test_case Array do
+
+  method :commonality do
+
+    test do
+      a = [1,2,2,3,3,3]
+      e = { 2 => [2,2], 3 => [3,3,3] }
+      r = a.commonality
+      r.assert == e
+    end
+
+    test "with block" do
+      a = [1,2,2,3,3,3]
+      e = {false=>[1, 2, 2], true=>[3, 3, 3]}
+      r = a.commonality{ |x| x > 2 }
+      r.assert == e
+    end
+
+  end
+
+  method :collisions do
+
+    test "alias for commonality" do
+      a = [1,2,2,3,3,3]
+      e = { 2 => [2,2], 3 => [3,3,3] }
+      r = a.collisions
+      r.assert == e
+    end
+
+  end
+
+end
+

data/test/core/array/test_conjoin.rb

@@ -0,0 +1,50 @@
+covers 'facets/array/conjoin'
+
+test_case Array do
+
+  method :conjoin do
+
+    setup "any array" do
+      @a = [1,2,3,4]
+    end
+
+    test "like join but spaced" do
+      @a.conjoin.assert == "1 2 3 4"
+    end
+
+    test "comma+space and 'and' on tail" do
+      @a.conjoin(', ', ' and ').assert = "1, 2, 3 and 4"
+    end
+
+    test "comma+space and 'or' on tail using :last option" do
+      @a.conjoin(', ', :last => ' or ').assert == "1, 2, 3 or 4"
+    end
+
+    test "semicolon+space and ampersand on tail using index" do
+      @a.conjoin('; ', -1 => ' & ').assert == "1; 2; 3 & 4"
+    end
+
+    test "with block to determine separator" do
+      r = @a.conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
+      r.assert == "1.2-3.4"
+    end
+
+    test "very esoteric transformation" do
+      r = @a.conjoin{ |i, x, y| "<#{i} #{x} #{y}>" }
+      r.assert == "1<0 1 2>2<1 2 3>3<2 3 4>4"
+    end
+
+    test "with :space option" do
+      r = @a.conjoin(',', '&', :space=>2)
+      r.assert == "1  ,  2  ,  3  &  4"
+    end
+
+    test ":spacer option can set an alternate spacing string" do
+      r = @a.conjoin('|', '>', :space=>2, :spacer=>'-')
+      r.assert == "1--|--2--|--3-->--4"
+    end
+
+  end
+
+end
+

data/test/core/array/test_contains.rb

@@ -0,0 +1,14 @@
+covers 'facets/array/contains'
+
+test_case Array do
+
+  method :contains? do
+
+    test do
+      [1,2,3,4].assert.contains?(2)
+      [1,2,3,4].refute.contains?(9)
+    end
+
+  end
+
+end

data/test/core/array/test_delete.rb

@@ -0,0 +1,42 @@
+covers 'facets/array/delete'
+
+test_case Array do
+
+  method :delete_unless do
+
+    test do
+      a = [1,2,3]
+      a.delete_unless{ |e| e == 2 }
+      a.assert == [2]
+    end
+
+  end
+
+  method :delete_values do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values(1,2).assert == [1,2]
+      a.assert == [3,4]
+    end
+
+  end
+
+  method :delete_values_at do
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(1,2).assert == [2,3]
+      a.assert == [1,4]
+    end
+
+    test do
+      a = [1,2,3,4]
+      a.delete_values_at(0..2).assert == [1,2,3]
+      a.assert == [4]
+    end
+
+  end
+
+end
+

data/test/core/array/test_delete_unless.rb

@@ -0,0 +1,17 @@
+covers 'facets/array/delete_unless'
+
+test_case Array do
+
+  method :delete_unless do
+
+    test 'with an explicit block' do
+      [1,2,3].delete_unless{ |x| x < 2 }.assert == [1]
+    end
+
+    test 'with an implicit block' do
+      [1,2,3].delete_unless(&:even?).assert == [2]
+    end
+
+  end
+
+end