mack-facets 0.8.2 → 0.8.3

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

@@ -1,24 +0,0 @@
-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

@@ -1,221 +0,0 @@
-# = 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

@@ -1,66 +0,0 @@
-#!/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

@@ -1,344 +0,0 @@
-# = 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
-