mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/coroutine.rb

@@ -0,0 +1,159 @@
+# = Coroutine
+#
+# Coroutines are program components like subroutines. Coroutines are more
+# generic and flexible than subroutines, but are less widely used in
+# practice. Coroutines were first introduced natively in Simula.
+# Coroutines are well suited for implementing more familiar program
+# components such as cooperative tasks, iterators, infinite lists, and pipes.
+#
+# This mixin solely depends on method read(n), which must be
+# defined in the class/module where you mix in this module.
+#
+# == Usage
+#
+#   count = (ARGV.shift || 1000).to_i
+#   input = (1..count).map { (rand * 10000).round.to_f / 100}
+#
+#   Producer = Coroutine.new do |me|
+#     loop do
+#       1.upto(6) do
+#         me[:last_input] = input.shift
+#         me.resume(Printer)
+#       end
+#       input.shift # discard every seventh input number
+#     end
+#   end
+#   Printer = Coroutine.new do |me|
+#     loop do
+#       1.upto(8) do
+#         me.resume(Producer)
+#         if Producer[:last_input]
+#           print Producer[:last_input], "\t"
+#           Producer[:last_input] = nil
+#         end
+#         me.resume(Controller)
+#       end
+#       puts
+#     end
+#   end
+#
+#   Controller = Coroutine.new do |me|
+#     until input.empty? do
+#       me.resume(Printer)
+#     end
+#   end
+#
+#   Controller.run
+#
+# == Authors
+#
+# * Florian Frank
+#
+# == Copying
+#
+# Copyright (c) 2005 Florian Frank
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+
+# = Coroutine
+#
+# Coroutines are program components like subroutines. Coroutines are more
+# generic and flexible than subroutines, but are less widely used in
+# practice. Coroutines were first introduced natively in Simula.
+# Coroutines are well suited for implementing more familiar program
+# components such as cooperative tasks, iterators, infinite lists, and pipes.
+#
+# This mixin solely depends on method read(n), which must be
+# defined in the class/module where you mix in this module.
+#
+# == Usage
+#
+#   count = (ARGV.shift || 1000).to_i
+#   input = (1..count).map { (rand * 10000).round.to_f / 100}
+#
+#   Producer = Coroutine.new do |me|
+#     loop do
+#       1.upto(6) do
+#         me[:last_input] = input.shift
+#         me.resume(Printer)
+#       end
+#       input.shift # discard every seventh input number
+#     end
+#   end
+#   Printer = Coroutine.new do |me|
+#     loop do
+#       1.upto(8) do
+#         me.resume(Producer)
+#         if Producer[:last_input]
+#           print Producer[:last_input], "\t"
+#           Producer[:last_input] = nil
+#         end
+#         me.resume(Controller)
+#       end
+#       puts
+#     end
+#   end
+#
+#   Controller = Coroutine.new do |me|
+#     until input.empty? do
+#       me.resume(Printer)
+#     end
+#   end
+#
+#   Controller.run
+#
+class Coroutine
+
+  def initialize(data = {})
+    @stopped = nil
+    @data = data
+    callcc do |@continue|
+      return
+    end
+    yield self
+    stop
+  end
+
+  attr_reader :stopped
+
+  def run
+    callcc do |@stopped|
+      continue
+    end
+  end
+
+  def stop
+    @stopped.call
+  end
+
+  def resume(other)
+    callcc do |@continue|
+      other.continue(self)
+    end
+  end
+
+  def continue(from = nil)
+    @stopped = from.stopped if not @stopped and from
+    @continue.call
+  end
+
+  def [](name)
+    @data[name]
+  end
+
+  def []=(name, value)
+    @data[name] = value
+  end
+
+  protected :stopped, :continue
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/crypt.rb

@@ -0,0 +1,166 @@
+# = Crypt
+#
+# A pure ruby version of crypt(3), a salted one-way hashing of a password.
+#
+# == History
+#
+#   Adapted by guillaume__dot__pierronnet_at__laposte__dot_net based on
+#   * http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/325204/index_txt
+#   which is based on FreeBSD src/lib/libcrypt/crypt.c 1.2
+#   * http://www.freebsd.org/cgi/cvsweb.cgi/~checkout~/src/lib/libcrypt/crypt.c?rev=1.2&content-type=text/plain
+#
+#   [Original License]
+#
+#   "THE BEER-WARE LICENSE" (Revision 42):
+#   <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+#   can do whatever you want with this stuff. If we meet some day, and you think
+#   this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+#
+# == Authors
+#
+# * Poul-Henning Kamp
+#
+# == Copying
+#
+# Copyright (c) 2002 Poul-Henning Kamp
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'facets/string/xor.rb'
+
+# = Crypt
+#
+# A pure ruby version of crypt(3), a salted one-way hashing of a password.
+#
+module Crypt
+
+  ITOA64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+  # A pure ruby version of crypt(3), a salted one-way hashing of a password.
+  #
+  # Supported hashing algorithms are: md5, sha1, sha256, sha384, sha512, rmd160.
+  #
+  # Only the md5 hashing algorithm is standard and compatible with crypt(3), the others
+  # are not standard.
+  #
+  # Automatically generate a 8-bytes salt if nil.
+  #
+  # Output a length hashed and salted string with size of
+  # magic.size + salt.size + 23.
+
+  def self.crypt(password, algo = :md5, salt = nil, magic='$1$')
+
+    salt ||= generate_salt(8)
+
+    case algo
+      when :md5
+        require "digest/md5"
+      when :sha1
+        require "digest/sha1"
+      when :rmd160
+        require "digest/rmd160"
+      when :sha256, :sha384, :sha512
+        require "digest/sha2"
+    else
+      raise(ArgumentError, "unknown algorithm")
+    end
+    digest_class = Digest.const_get(algo.to_s.upcase)
+
+    # The password first, since that is what is most unknown. Then our magic string. Then the raw salt.
+    m = digest_class.new
+    m.update(password + magic + salt)
+
+    # Then just as many characters of the MD5(pw,salt,pw)
+    mixin = digest_class.new.update(password + salt + password).digest
+    password.length.times do |i|
+      m.update(mixin[i % 16].chr)
+    end
+
+    # Then something really weird...
+    # Also really broken, as far as I can tell.  -m
+    i = password.length
+    while i != 0
+      if (i & 1) != 0
+        m.update("\x00")
+      else
+        m.update(password[0].chr)
+      end
+      i >>= 1
+    end
+
+    final = m.digest
+
+    # and now, just to make sure things don't run too fast
+    1000.times do |i|
+      m2 = digest_class.new
+
+      if (i & 1) != 0
+        m2.update(password)
+      else
+        m2.update(final)
+      end
+
+      if (i % 3) != 0
+        m2.update(salt)
+      end
+      if (i % 7) != 0
+        m2.update(password)
+      end
+
+      if (i & 1) != 0
+        m2.update(final)
+      else
+        m2.update(password)
+      end
+
+      final = m2.digest
+    end
+
+    # This is the bit that uses to64() in the original code.
+
+    rearranged = ""
+
+    [ [0, 6, 12], [1, 7, 13], [2, 8, 14], [3, 9, 15], [4, 10, 5] ].each do |a, b, c|
+
+      v = final[a] << 16 | final[b] << 8 | final[c]
+
+      4.times do
+        rearranged += ITOA64[v & 0x3f].chr
+        v >>= 6
+      end
+    end
+
+    v = final[11]
+
+    2.times do
+      rearranged += ITOA64[v & 0x3f].chr
+      v >>= 6
+    end
+
+    magic + salt + '$' + rearranged
+  end
+
+
+  # check the validity of a password against an hashed string
+
+  def self.check(password, hash, algo = :md5)
+    magic, salt = hash.split('$')[1,2]
+    magic = '$' + magic + '$'
+    self.crypt(password, algo, salt, magic) == hash
+  end
+
+
+  # generate a +size+ length random salt
+
+  def self.generate_salt(size)
+    (1..size).collect { ITOA64[rand(ITOA64.size)].chr }.join("")
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/cssfilter.rb

@@ -0,0 +1,254 @@
+# = CSS Filter
+#
+# The CssFilter class will clean up a cascading style sheet.
+# It can be used to remove whitespace and most importantly
+# remove urls.
+#
+# == Authors
+#
+# * Trans
+#
+# == Todo
+#
+# * Allow urls to be specified per attribute type.
+#
+# == Copying
+#
+#   Copyright (c) 2007 7rans
+
+require 'facets/uri'
+
+# = CSS Filter
+#
+# The CssFilter class will clean up a cascading style sheet.
+# It can be used to remove whitespace and most importantly
+# remove urls.
+#
+class CssFilter
+
+  # should we remove comments? (true, false)
+  attr_accessor :strip_comments
+
+  # should we remove urls? (true, false)
+  attr_accessor :strip_urls
+
+  # url schemes which will be allowed (http, ftp, mailto)
+  attr_accessor :allowed_scheme
+
+  # alias for allowed_scheme
+  alias_method :allowed_protocols, :allowed_scheme
+  alias_method :allowed_protocols=, :allowed_scheme=
+
+  # url hosts which will be allowed.
+  attr_accessor :allowed_hosts
+
+  # urls which will be allowed. (NOT YET USED)
+  attr_accessor :allowed_urls
+
+  # substitue urls  (NOT YET USED)
+  attr_accessor :substitute_urls
+
+  # remove blank lines.
+  attr_accessor :strip_whitespace
+
+  # remove blank lines.
+  attr_accessor :strip_blanklines
+
+  # Complete parse and rewrite of CSS document.
+  # This does a complete "cleaning" but note that
+  # is not yet a perfect parser.
+  attr_accessor :rewrite
+
+  # CssFilter option defaults.
+
+  DEFAULT = {
+    'strip_comments' => true,
+    'strip_urls' => true,
+    'allowed_urls' => [],
+    'allowed_hosts' => [],
+    'allowed_scheme' => [],
+    'strip_whitespace' => false,
+    'strip_blanklines' => true,
+    'rewrite' => false,
+    'substitute_urls' => {}
+  }
+
+  #
+
+  def initialize(options=nil)
+    if options
+      h = DEFAULT.dup
+      options.each do |k,v|
+        h[k.to_s] = v
+      end
+      options = h
+    else
+      options = DEFAULT.dup
+    end
+
+    options.each{ |k,v| send("#{k}=",v) }
+  end
+
+  #
+
+  def accept_host(host)
+    @hosts << host
+  end
+
+  #
+
+  def filter(css)
+    css = remove_comments(css)    if strip_comments
+    css = remove_urls(css)        if strip_urls
+
+    css = remove_nullvalues(css)
+
+    css = remove_whitespace(css)  if strip_whitespace
+    css = remove_blanklines(css)  if strip_blanklines
+
+    css = parse(css).to_css       if rewrite
+    css
+  end
+
+  #
+
+  def remove_comments(data)
+    data.gsub(/\/\*(.8?)\*\//,'')
+  end
+
+  # TODO: allowed_urls
+
+  def remove_urls(data)
+    urls = data.scan(/url\((.*?)\)/).flatten
+    uris = urls.collect{ |u| URI.extract(u) }.flatten
+    uris.each do |u|
+      uri = URI.parse(u)
+      unless allowed_hosts.include?(uri.host) or
+             allowed_scheme.include?(uri.scheme)
+        data.sub!(u.to_s, '')
+      end
+    end
+    data.gsub(/url\(\s*\)/, '')
+  end
+
+  #
+
+  def remove_whitespace(data)
+    data = data.gsub(/^\s*/,'')
+    data = data.gsub(/\s*$/,'')
+  end
+
+  #
+
+  def remove_blanklines(data)
+    data = data.gsub(/^\s*\n/,'')
+  end
+
+  #
+
+  def remove_nullvalues(data);
+    data = data.gsub(/\w+[:](\s+)[;]/,'')
+  end
+
+  # Breaks a css document up into a hash. This can be used
+  # completely rewritting the css.
+  #
+  # TODO: Not complete, does not work with "@xxx foo;" for example.
+
+  def parse(css)
+    tree = CssTree.new
+    entries = css.scan(/^(.*?)\{(.*?)\}/m)
+    entries.each do |ref, props|
+      tree[ref.strip] ||= {}
+      props = clean_properties(props)
+      props = props.scan(/(.*?)[:](.*?)([;]|\s*\Z)/)
+      props.each do |(key,val)|
+        tree[ref.strip][key.strip] = clean_value(val)
+      end
+    end
+    return tree
+  end
+
+  # Takes a css entry and ensures it is valid (as best it can).
+  # It will fix trival mistakes, and raise an error when it is
+  # beyond repair.
+  #
+  # TODO: So far this does absolutely nothing!
+
+  def clean_properties(atts)
+    atts
+  end
+
+  #
+
+  def clean_value(val)
+    val = val.strip
+
+    if urls
+      uris = URI.extract(val)
+      uris.each do |u|
+        val.sub!(u.to_s, urls)
+      end
+    end
+
+    return val
+  end
+
+end
+
+
+# CSS parse tree. This is for a "deep filtering".
+
+class CssTree < Hash
+
+  def initialize(options=nil)
+    @options = options || {}
+    super()
+  end
+
+  # Re-output the CSS, all tidy ;)
+
+  def to_css
+    css = ""
+    each do |selector, entries|
+      css << "#{selector}{"
+      entries.each do |key, value|
+        css << "#{key}:#{value};"
+      end
+      css << "}\n"
+    end
+    return css
+  end
+
+end
+
+
+
+if $0 == __FILE__
+
+  require 'yaml'
+
+  css = <<-END
+    * {
+      margin: 0;
+      height: 0;
+    }
+
+    body {
+      margin: 0;
+      height: 0;
+      background: url(http://xzy.org);
+    }
+
+    h1 {
+      trythis: url(http://here.org/fun.js);
+      font-size: 12pt;
+    }
+  END
+
+  cssfilter = Blow::CssFilter.new(:allowed_hosts=>["here.org"])
+  csstree   = cssfilter.filter(css)
+  #y csstree
+  puts csstree
+
+end