mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/binding/opvars.rb

@@ -0,0 +1,24 @@
+require 'facets/binding/eval'
+
+class Binding
+
+  # Returns the value of some variable.
+  #
+  #   a = 2
+  #   binding["a"]  #=> 2
+  #
+  def []( x )
+    eval( x.to_s )
+  end
+
+  # Set the value of a local variable.
+  #
+  #   binding["a"] = 4
+  #   a  #=> 4
+  #
+  def []=( l, v )
+    eval( "lambda {|v| #{l} = v}").call( v )
+  end
+
+end
+

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

@@ -0,0 +1,221 @@
+# = BinReadable
+#
+# This mixin solely depends on method read(n), which must be
+# defined in the class/module where you mix in this module.
+#
+# == Todo
+#
+# * The name of this module sucks.
+#
+# == Authors
+#
+# * Michael Neumann
+#
+# == Copying
+#
+# Copyright (c) 2003 Michael Neumann
+#
+# 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.
+
+# = BinReadable
+#
+# This mixin solely depends on method read(n), which must be
+# defined in the class/module where you mix in this module.
+
+module BinReadable
+
+  #--
+  # TODO Would like to get the core functionality this provides into the
+  # System module and then change BinaryReader to depend on that instead.
+  #++
+  module ByteOrder
+
+    Native = :Native
+    BigEndian = Big = Network = :BigEndian
+    LittleEndian = Little = :LittleEndian
+
+    # examines the byte order of the underlying machine
+    def byte_order
+      if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+        BigEndian
+      else
+        LittleEndian
+      end
+    end
+
+    alias_method :byteorder, :byte_order
+
+    def little_endian?
+      byte_order == LittleEndian
+    end
+
+    def big_endian?
+      byte_order == BigEndian
+    end
+
+    alias_method :little?, :little_endian?
+    alias_method :big?, :big_endian?
+    alias_method :network?, :big_endian?
+
+    module_function :byte_order, :byteorder
+    module_function :little_endian?, :little?
+    module_function :big_endian?, :big?, :network?
+
+  end
+
+  # default is native byte-order
+  def byte_order
+    @byte_order || ByteOrder::Native
+  end
+
+  def byte_order=(new_byteorder)
+    @byte_order = new_byteorder
+  end
+
+  alias byteorder byte_order
+  alias byteorder= byte_order=
+
+  # == 8 bit
+
+  # no byteorder for 8 bit!
+
+  def read_word8
+    ru(1, 'C')
+  end
+
+  def read_int8
+    ru(1, 'c')
+  end
+
+  # == 16 bit
+
+  # === Unsigned
+
+  def read_word16_native
+    ru(2, 'S')
+  end
+
+  def read_word16_little
+    ru(2, 'v')
+  end
+
+  def read_word16_big
+    ru(2, 'n')
+  end
+
+  # === Signed
+
+  def read_int16_native
+    ru(2, 's')
+  end
+
+  def read_int16_little
+    # swap bytes if native=big (but we want little)
+    ru_swap(2, 's', ByteOrder::Big)
+  end
+
+  def read_int16_big
+    # swap bytes if native=little (but we want big)
+    ru_swap(2, 's', ByteOrder::Little)
+  end
+
+  # == 32 bit
+
+  # === Unsigned
+
+  def read_word32_native
+    ru(4, 'L')
+  end
+
+  def read_word32_little
+    ru(4, 'V')
+  end
+
+  def read_word32_big
+    ru(4, 'N')
+  end
+
+  # === Signed
+
+  def read_int32_native
+    ru(4, 'l')
+  end
+
+  def read_int32_little
+    # swap bytes if native=big (but we want little)
+    ru_swap(4, 'l', ByteOrder::Big)
+  end
+
+  def read_int32_big
+    # swap bytes if native=little (but we want big)
+    ru_swap(4, 'l', ByteOrder::Little)
+  end
+
+  # == Aliases
+
+  alias read_uint8 read_word8
+
+  # add some short-cut functions
+  %w(word16 int16 word32 int32).each do |typ|
+    eval %{
+      alias read_#{typ}_network read_#{typ}_big
+      def read_#{typ}(byte_order = nil)
+        case byte_order || @byte_order
+        when ByteOrder::Native  then read_#{typ}_native
+        when ByteOrder::Little  then read_#{typ}_little
+        when ByteOrder::Network then read_#{typ}_network
+        else raise ArgumentError
+        end
+      end
+    }
+  end
+
+  {:word16 => :uint16, :word32 => :uint32}.each do |old, new|
+    ['', '_native', '_little', '_big', '_network'].each do |bo|
+      eval %{
+        alias read_#{new}#{bo} read_#{old}#{bo}
+      }
+    end
+  end
+
+  def read_cstring
+    str = ""
+    while (c=readn(1)) != "\0"
+      str << c
+    end
+    str
+  end
+
+  # read exactly n characters, otherwise raise an exception.
+  def readn(n)
+    str = read(n)
+    raise "couldn't read #{n} characters" if str.nil? or str.size != n
+    str
+  end
+
+  private
+
+  # shortcut method for readn+unpack
+  def ru(size, template)
+    readn(size).unpack(template).first
+  end
+
+  # same as method +ru+, but swap bytes if native byteorder == _byteorder_
+  def ru_swap(size, template, byteorder)
+    str = readn(size)
+    str.reverse! if ByteOrder.byteorder == byteorder
+    str.unpack(template).first
+  end
+
+end
+
+# Compatability with old version.
+BinaryReader = BinReadable
+

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

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+unless defined? BlankSlate
+
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BlankSlate
+    class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+        undef_method name if
+        instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+
+
+  # Since Ruby is very dynamic, methods added to the ancestors of
+  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
+  # list of available BlankSlate methods.  We handle this by defining a
+  # hook in the Object and Kernel classes that will hide any defined
+  module Kernel #:nodoc:
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Kernel and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        blank_slate_method_added(name)
+        return if self != Kernel
+        BlankSlate.hide(name)
+      end
+    end
+  end
+
+  class Object #:nodoc:
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Object and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        blank_slate_method_added(name)
+        return if self != Object
+        BlankSlate.hide(name)
+      end
+    end
+  end
+
+end
+

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

@@ -0,0 +1,344 @@
+# = Buildable / BuildingBlock
+#
+# Build content programatically with Ruby and Ruby's blocks.
+#
+#   require 'facets'
+#   require 'xmlhelper'
+#
+#   builder = BuildingBlock.new(XMLHelper, :element)
+#
+#   doc = builder.html do
+#
+#     head do
+#       title "Test"
+#     end
+#
+#     body do
+#       i "Hello"
+#       br
+#       text "Test"
+#       text "Hey"
+#     end
+#
+#   end
+#
+# _produces_
+#
+#   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
+#
+# All calls within the block are routed via the Helper Module's constructor method
+# (#element in the above example) unless they are defined by the helper module, in which
+# case they are sent to the helper module directly. The results of these invocations are
+# appended to the output buffer. To prevent this, prefix the method with 'call_'.
+#
+# Sometimes keywords can get in the way of a construction. In these cases you can
+# ensure use of constructor method by calling the special #build! command. You can
+# also add verbatium text to the output via the #<< operator. Some common Ruby's built-in
+# methods treated as keywords:
+#
+#      inspect
+#      instance_eval
+#      respond_to?
+#      singleton_method_undefined
+#      initialize
+#      method_missing
+#      to_str
+#      to_s
+#
+# And a few other speciality methods besides:
+#
+#      to_buffer
+#      build!
+#      <<
+#
+# This work was of course inspired by many great minds, and represents a concise and simple
+# means of accomplishing this pattern of design, which is unique to Ruby.
+#
+# Buildable is mixin variation of BuildingBlock.
+#
+#   require 'facets/buildable'
+#   require 'xmlmarkup'  # hypothetical library
+#
+#   module XMLMarkup
+#     include Buildable
+#     alias :build :element
+#   end
+#
+#   doc = XMLMarkup.build do
+#     html do
+#       head do
+#         title "Test"
+#       end
+#       body do
+#         i "Hello"
+#         br
+#         text "Test"
+#         text "Hey"
+#       end
+#     end
+#   end
+#
+# _produces_
+#
+#   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
+#
+# This is based on BuildingBlock. Refer to it for more information.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Todo
+#
+# * Change name of BuildingBlock to BlockUp ?
+#
+# == Copying
+#
+# Copyright (c) 2006 Thomas Sawyer
+#
+# 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/buildingblock'
+
+# = Buildable
+#
+# Buildable is mixin variation of BuildingBlock.
+#
+#   require 'facets/buildable'
+#   require 'xmlmarkup'  # hypothetical library
+#
+#   module XMLMarkup
+#     include Buildable
+#     alias :build :element
+#   end
+#
+#   doc = XMLMarkup.build do
+#     html do
+#       head do
+#         title "Test"
+#       end
+#       body do
+#         i "Hello"
+#         br
+#         text "Test"
+#         text "Hey"
+#       end
+#     end
+#   end
+#
+# _produces_
+#
+#   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
+#
+# This is based on BuildingBlock. Refer to it for more information.
+
+module Buildable
+
+  def self.included(base)
+    singleton = (class << base; self; end)
+    singleton.send(:define_method, :builder) do
+      @builder ||= BuildingBlock.new(base, :build)
+    end
+    base.module_eval %{
+      def self.build(&block)
+        builder.instance_eval(&block)
+      end
+    }
+  end
+
+end
+
+# = BuildingBlock
+#
+# Build content programatically with Ruby and Ruby's blocks.
+#
+#   require 'facets'
+#   require 'xmlhelper'
+#
+#   builder = BuildingBlock.new(XMLHelper, :element)
+#
+#   doc = builder.html do
+#
+#     head do
+#       title "Test"
+#     end
+#
+#     body do
+#       i "Hello"
+#       br
+#       text "Test"
+#       text "Hey"
+#     end
+#
+#   end
+#
+# _produces_
+#
+#   <html><head><title>Test</title><body><i>Hello</i><br />TestHey</body></html>
+#
+# All calls within the block are routed via the Helper Module's constructor method
+# (#element in the above example) unless they are defined by the helper module, in which
+# case they are sent to the helper module directly. The results of these invocations are
+# appended to the output buffer. To prevent this, prefix the method with 'call_'.
+#
+# Sometimes keywords can get in the way of a construction. In these cases you can
+# ensure use of constructor method by calling the special #build! command. You can
+# also add verbatium text to the output via the #<< operator. Some common Ruby's built-in
+# methods treated as keywords:
+#
+#      inspect
+#      instance_eval
+#      respond_to?
+#      singleton_method_undefined
+#      initialize
+#      method_missing
+#      to_str
+#      to_s
+#
+# And a few other speciality methods besides:
+#
+#      to_buffer
+#      build!
+#      <<
+#
+# This work was of course inspired by many great minds, and represents a concise and simple
+# means of accomplishing this pattern of design, which is unique to Ruby.
+
+class BuildingBlock
+
+  alias __p__ p
+
+  # NOTE: When debugging, you may want to add the 'p' entry.
+  # TODO: There may be other methods that need to be in this exception list.
+
+  ESCAPE = [
+    'singleton_method_undefined',
+    'respond_to?',
+    'instance_eval',
+    'inspect',
+    'initialize'
+  ] # 'to_ary', 'p' ]
+
+  methods = instance_methods | public_instance_methods | private_instance_methods | protected_instance_methods
+  methods.each{|m| undef_method m unless m=~/^__/ or ESCAPE.include?(m)}
+
+  #
+
+  def initialize(dslModule, constructor, output_buffer=nil)
+    @buffer = output_buffer || ''
+    @stack  = []
+
+    @dsl = Class.new{
+      include dslModule
+    }.new
+
+    @constructor = constructor
+  end
+
+  #
+
+  def build!(s, *a, &b)
+    s = s.to_s
+
+    if b
+      @stack << @buffer
+      @buffer = ''
+      instance_eval(&b)
+      out = @buffer
+      @buffer = @stack.pop
+      a.unshift(out)
+    end
+
+    if s =~ /^call_/
+      m = s[5..-1].to_sym
+      @dsl.send(m, *a, &b).to_s
+    elsif @dsl.respond_to?(s) #o =~ /^build_/
+      @buffer << @dsl.send(s, *a, &b).to_s
+    else
+      s = s.chomp('?') if s[-1,1] == '?'
+      @buffer << @dsl.send(@constructor, s, *a).to_s
+    end
+  end
+
+  #
+
+  def method_missing(s, *a, &b)
+    build!(s, *a, &b)
+  end
+
+  # Return buffer
+
+  def to_buffer()
+    @buffer
+  end
+
+  # Return buffer as string.
+
+  def to_s()   @buffer.to_s   end
+  def to_str() @buffer.to_str end
+
+  # Add directly to buffer.
+
+  def <<(s)
+    @buffer << s.to_s
+  end
+
+  # If creating and XML/HTML builder, you'll want to alias this to tag!.
+  #def build!(m, *a)
+  #  @buffer << @dsl.send(@constructor, m, *a).to_s
+  #end
+
+  # Could improve.
+
+  def inspect
+    r = super
+    i = r.index(',')
+    return r[0...i] + ">"
+  end
+
+end
+
+
+
+
+=begin
+    @module        = dslModule
+    @constructor   = constructor
+    @instance_eval = method(:instance_eval)
+@module
+    @method = {}
+
+    @stack = []
+    @out   = output_buffer || ''
+
+
+    meths = []
+    #meths.concat singleton_methods
+    meths.concat public_methods
+    meths.concat protected_methods
+    meths.concat private_methods
+    meths.each do |m|
+      @method[m.to_sym] = method(m)
+    end
+
+    class << self
+      escape = ESCAPE
+      meths = []
+      #meths.concat singleton_methods
+      meths.concat public_instance_methods
+      meths.concat protected_instance_methods
+      meths.concat private_instance_methods
+      meths.each do |m|
+        undef_method(m) unless m =~ /^__/ or escape.include?(m)
+      end
+    end
+  end
+=end
+