facets 1.7.46 → 1.8.0

data/work/yore/openobject.rb

@@ -0,0 +1,298 @@
+# = openobject.rb
+#
+# == Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+#   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.
+#
+# == Authors and Contributors
+#
+# * Thomas Sawyer
+# * George Moschovitis
+
+# Author::    Thomas Sawyer, George Moschovitis
+# Copyright:: Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+# License::   Ruby License
+
+require 'facets/core/kernel/as'
+require 'facets/core/kernel/object_class'
+require 'facets/core/hash/keys_to_sym'
+require 'facets/core/hash/to_proc'
+#require 'facets/more/nullclass'
+
+# = OpenObject
+#
+# OpenObject is similar to OpenStruct, but differs in a couple ways.
+#
+# OpenObject privatizes a few Kernel methods so there are fewer
+# reserved Kernel methods in the object's namespace, reducing
+# potential for name clashes.
+#
+# Also it does not create any methods for the added entries and instead
+# uses a hash ONLY. OpenStruct OTOH creates methods, but is actaully
+# inconsitant in their use --try #dup on an OpenStruct and
+# all the methods disappear. Morevoer, I beleive this feature was
+# added to OpenStruct for speed, but I have not been able to find
+# this advantage in benchmark tests.
+#
+#--
+# Third, when an entry is not found 'null' is returned rather then 'nil'.
+# This allows for run-on entries withuot error. Eg.
+#
+#   OpenObject.new.a.b.c  #=> null
+#++
+
+class OpenObject
+
+  # Privatize a few Kernel methods that are most likely to clash,
+  # but arn't essential here.
+
+  private :class, :clone, :display, :type, :method, :to_a, :to_s
+
+  def initialize( init=nil )
+    case init
+    when Array
+      @table = Hash[*init].keys_to_sym
+    when Hash
+      @table = init.keys_to_sym
+    when NilClass
+      @table = {}
+    when OpenObject
+      @table = init.send(:table).dup
+    else
+      @table = init.to_h.keys_to_sym
+    end
+  end
+
+  def to_openobject ; self    ; end
+
+  def to_a    ; @table.values ; end
+  def to_h    ; @table.dup    ; end
+  def to_hash ; @table.dup    ; end
+
+  # OpenObejct can be converted to an assignment Proc.
+  #
+  #   o = OpenObject.new( :a=>1 )
+  #   p = o.to_proc
+  #   x = OpenObject.new
+  #   p[x]
+  #   x.a #=> 1
+  #
+
+  def to_proc
+    @table.to_proc
+  end
+
+  # How to duplicate.
+
+  def initialize_copy( orig )
+    super
+    @table = @table.dup
+  end
+
+  def inspect
+    s = "<#{object_class}"
+    s << " " << @table.collect{|k,v| "#{k}=#{v.inspect}"}.join(' ') unless @table.empty?
+    s << ">"
+  end
+
+  def marshal_dump
+    @table
+  end
+
+  def marshal_load( tbl )
+    @table = tbl
+  end
+
+  # Compare this object and +other+ for equality.
+
+  def ==(other)
+    return false unless other.kind_of?( object_class )
+    return @table == other.send(:table)  # TODO funcall in future?
+  end
+
+  def method_missing( sym, *args )
+    type = sym.to_s[-1,1]
+    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+
+    if type == '='
+      self[name] = args[0]
+    elsif type == '!' and args.size > 0
+      self[name] = args[0]
+      self
+    else
+      if @table.key?(name)
+        self[name]
+      #elsif @parent
+      #  @parent.__send__(name)
+      else
+        nil
+      end
+    end
+  end
+
+  def [](name)
+    name = name.to_sym
+    #if @table.key?(name)
+      @table[name]
+    #else
+    #  Kernel.null
+    #end
+  end
+
+  def []=(name,val)
+    @table[name.to_sym] = val
+  end
+
+  # For compatibility with other types of hash-like objects.
+  # Also make OpenObject usable via Enumerator.
+
+  def each(&yld)
+    @table.each( &yld )
+  end
+
+private
+
+  # Access to internal table.
+
+  def table ; @table ; end
+
+  #--
+  # TODO Parent feature? Or better only for OpenCascade?
+  #++
+  #def __parent__ ; @parent ; end
+  #def __parent__=(x) ; @parent = x ; end
+
+  def fetch(k)  ; @table[k.to_sym] ; end
+  #def __fetch__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
+
+  def store(k)  ; @table[k.to_sym]=v ; end
+
+  def key?(k) ; @table.key?(k.to_sym) ; end
+
+  def keys    ; @table.keys ; end
+
+  def update( other )
+    other = Hash[*other] if other.is_a?(Array)
+    other.each{ |k, v| @table[k.to_sym] = v }
+  end
+
+  def merge( other )
+    o = dup
+    o.send(:update, other)
+    o
+  end
+
+  # Core Extensions
+
+  class ::Hash
+    # Convert a Hash into an OpenObject.
+
+    def to_openobject
+      OpenObject.new( self )
+    end
+  end
+
+  class ::Proc
+    # Translates a Proc into an OpenObject. By droping an OpenObject into
+    # the Proc, the resulting assignments incured as the procedure is
+    # evaluated produce the OpenObject. This technique is simlar to that
+    # of MethodProbe.
+    #
+    #   p = lambda { |x|
+    #     x.word = "Hello"
+    #   }
+    #   o = p.to_openobject
+    #   o.word #=> "Hello"
+    #
+    # NOTE The Proc must have an arity of one --no more and no less.
+
+    def to_openobject
+      raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
+      o = OpenObject.new
+      self.call( o )
+      o
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_01_001
+      f0 = OpenObject.new
+      f0[:a] = 1
+      assert_equal( [1], f0.to_a )
+      assert_equal( {:a=>1}, f0.to_h )
+    end
+
+    def test_01_002
+      f0 = OpenObject.new( {:a=>1} )
+      f0[:b] = 2
+      assert_equal( {:a=>1,:b=>2}, f0.to_h )
+    end
+  end
+
+  class TC02 < Test::Unit::TestCase
+
+    def test_02_001
+      f0 = OpenObject.new( :f0=>"f0" )
+      h0 = { :h0=>"h0" }
+      assert_equal( OpenObject.new( :f0=>"f0", :h0=>"h0" ), f0.send(:merge,h0) )
+      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
+    end
+
+    def test_02_002
+      f1 = OpenObject.new( :f1=>"f1" )
+      h1 = { :h1=>"h1" }
+      f1.send(:update,h1)
+      h1.update( f1 )
+      assert_equal( OpenObject.new( :f1=>"f1", :h1=>"h1" ), f1 )
+      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
+    end
+
+  end
+
+  class TC03 < Test::Unit::TestCase
+
+    def test_03_001
+      fo = OpenObject.new
+      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
+      99.times{ |i|
+        assert_equal( 1, fo.__send__( "n#{i}" ) )
+      }
+    end
+
+  end
+
+  class TC04 < Test::Unit::TestCase
+
+    def test_04_001
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = p.to_openobject
+      assert_equal( "Hello", o.word )
+    end
+
+  end
+
+=end

data/work/yore/reap.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+#require './lib/facets/core/file/self/read_list'
+
+#DATPATH = "data/facets"
+#ETCPATH = "conf/facets"
+#REQPATH = "facets/core"
+#GENPATH = "lib/facets/core"
+
+# REAP doesn't accept a default. Should it?
+#task :default => [ :tasks ]  # THIS IS WHAT IT DOES BY DEFAULT.
+
+#
+# Three stages to release.
+#
+
+desc %{First stage (redirect,extest,test)}
+task '1stage' => [ :redirect, :extest, :test ]
+
+desc %{Second stage (rdoc-core,rdoc-more,package)}
+task '2stage' => [ :'rdoc-core', :'rdoc-more', :package ]
+
+desc %{Final stage (publish,release)}
+task '3stage' => [ :publish, :release ]
+
+#
+# Generate facet/ redirection folder.
+#
+
+LIBDIR = 'lib'
+REDIR = 'facet'
+SRCDIR = 'facets'
+
+desc %{Build facet redirect directory}
+task :redirect do
+  #puts "Creating redirection folder #{REDIR}/ ..."
+  count = 0
+  dest = File.join( LIBDIR, REDIR )
+  FileUtils.rm_r(dest) if File.directory?(dest)
+  Dir.chdir( LIBDIR ) do
+    ['core','more'].each{ |d|
+      from = File.join( SRCDIR, d )
+      files = Dir.glob( File.join( from, '**/*.rb' ) )
+      files.each { |e|
+        re = Regexp.new( Regexp.escape( from + '/' ) )
+        link = e.sub( re, 'facet/')
+        FileUtils.mkdir_p( File.dirname( link ) )
+        File.open( link, "w+" ) { |w| w << "require '#{e}'" }
+        count += 1
+      }
+    }
+  end
+  puts "Created #{count} redirection files in #{REDIR}/ folder."
+end
+
+#
+# Read in the facets directory and sort-out per class
+#
+
+Methods = {}
+MTHPATH = "lib/facets/core"
+
+task :index_methods do
+  Dir.chdir(MTHPATH) do
+    dg = Dir.glob('*/**/*.rb')
+    dg.each { |f|
+      klass, *meth= f.split('/')
+      Methods[ klass ] ||= []
+      Methods[ klass ] << "#{meth.join('/').chomp('.rb')}"
+    }
+    Methods.keys.each { |k| Methods[k].sort! }
+  end
+end
+
+#
+# List Methods
+#
+
+desc %{Output a list of all methods}
+task :list => [ :index_methods ] do
+  puts method_list_outline
+end
+
+#
+# Make sure there are no remarked test comments.
+#
+
+#desc "Check for open comment tests"
+#task :testchk do
+#  system %q{grep -r ^#=begin\ test ./lib}
+#end
+
+# # Save method index to file in yaml format
+#
+# desc %{Generate method index file}
+# task :index => [ :methods ] do
+#   print "Creating method index... "
+#   loc = File.join( DATPATH, 'index.yml' )
+#   File.open( loc, 'w' ) { |f|
+#     f << Methods.to_yaml
+#   }
+#   puts "[done]"
+# end
+
+# # Create per class feature files
+#
+# desc %Q{Generate per-class feature files}
+# task :class => [:methods ] do
+#   print "Creating per class files... "
+#
+#   index  = Methods
+#   noauto = File.read_list( File.join( ETCPATH, 'noauto' ) )
+#   allfiles = index.collect{ |k,ms| ms.collect{ |m| "#{k}/#{m}" } }.flatten
+#   full = calc_full(allfiles, noauto)
+#
+#   index.each { |classname, method_files|
+#     File.open( "#{GENPATH}/#{classname.downcase}.rb", 'w' ) { |f|
+#       method_files.each { |rf|
+#         mfn = "#{classname.downcase}/#{rf}"
+#         if full.include?(mfn)
+#           f << %Q{require '#{REQPATH}/#{mfn}'\n}
+#         end
+#       }
+#     }
+#   }
+#   puts "[done]"
+# end
+
+# # HTML List MethodsFile.new(
+#
+# HEAD = <<-HERE
+# <html>
+# <head>
+#   <style>
+#     pre#methods {
+#       font-size: .8em;
+#       line-height: 1em;
+#     }
+#   </style>
+# </head>
+# <body>
+# <pre id="methods">
+# HERE
+#
+# FOOT=<<-HERE
+# </pre>
+# </body>
+# </html>
+# HERE
+#
+# desc %{generate method list html file}
+# task 'listHtml' => [ :scrape_methods ] do
+#   s = HEAD + method_list_outline + FOOT
+#   File.open('pub/www/methods.html', 'w') { |f| f << s }
+# end
+
+private  # Support Methods
+
+  # Create a nice text outline of the core methods.
+
+  def method_list_outline
+    s = ''
+    Methods.keys.sort.each { |k|
+      ms = Methods[k].collect{|m| m.gsub(%r{^self\/},'::')}.sort
+      s << "#{k}:\n"
+      ms.each { |m| s << "  #{m}\n" }
+    }
+    s
+  end
+
+#   # Full set of require files (all files minus noauto and unsafe)
+#
+#   def calc_full( allfiles, noauto )
+#     sf = allfiles.dup
+#     noauto.each do |f|
+#       if f.include?('*')
+#         re = %r"#{f.gsub('*','.*')}"
+#         sf.reject!{ |x| x =~ re }
+#       elsif sf.include?(f)
+#         sf.delete f
+#       end
+#     end
+#     sf.sort
+#   end