core_ex 0.4.0 → 0.5.1.1

data/lib/core_ex/require.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: require.rb 334 2005-09-04 14:29:40Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/core_ex/require.rb 7939 2005-09-04T14:29:40.923141Z ertai  $
 
 # FIXME This autoload didn't work for these reasons:
 # - |

data/lib/core_ex/string.rb

@@ -26,14 +26,23 @@ module CoreEx
       self
     end
 
-    def import
-      to_path.import
+    def import!
+      to_path.import!
     end
 
     def to_path
       ::Pathname.new(self)
     end
 
+    def to_uri
+      URI.parse(self)
+    end
+    alias_method :to_url, :to_uri
+
+    def to_proc
+      DumpableProc.new(self)
+    end
+
     def rec_fold ( init, &block )
       if include? "\n"
         super

data/lib/core_ex/time.rb

@@ -1,7 +1,7 @@
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
 # License::   GNU General Public License (GPL).
-# Revision::  $Id: time.rb 336 2005-09-06 20:32:49Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/core_ex/time.rb 7941 2005-09-06T20:32:49.915023Z ertai  $
 
 
 module CoreEx

data/lib/core_ex/try_dup.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: try_dup.rb 334 2005-09-04 14:29:40Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/core_ex/try_dup.rb 7939 2005-09-04T14:29:40.923141Z ertai  $
 
 
 module CoreEx

data/lib/core_ex/yaml.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: yaml.rb 383 2005-10-02 16:48:09Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/core_ex/yaml.rb 21944 2006-02-19T17:32:33.171560Z pouillar  $
 
 
 module CoreEx
@@ -11,6 +11,75 @@ module CoreEx
 
 end # module CoreEx
 
+
+module YAML
+
+  module_function
+
+  def load_from_io ( io, &block )
+    buffer = ''
+    io.each_line do |line|
+      if not buffer.empty? and line =~ /^---/
+        block[YAML.load(buffer)]
+        buffer = ''
+      else
+        buffer += line
+      end
+    end
+  end
+
+  def have_option? ( opts, opt_name )
+    if opts.respond_to? :[]
+      opts[opt_name] || have_option?(opts[:Emitter], opt_name)
+    elsif opts.respond_to? :options
+      have_option? opts.options, opt_name
+    end
+  end
+
+
+  module BaseNode
+
+    def symbol_safe_key_transform ( t, k, v )
+      k = k.symbol_safe_transform if k.is_a? BaseNode
+      case k
+        when /^:"(.*)"/ then k = $1.to_sym
+        when /^:(.*)/   then k = $1.to_sym
+      end 
+      if v.is_a? BaseNode
+        t[k] = v.symbol_safe_transform
+      else
+        t[k] = v
+      end
+    end
+    private :symbol_safe_key_transform
+
+    def symbol_safe_transform
+      @type_id = nil unless defined? @type_id
+      t = nil
+      case @value
+      when Hash
+        t = {}
+        @value.each do |k, v|
+          symbol_safe_key_transform(t, k, v)
+        end
+      when Array
+        t = []
+        @value.each do |v|
+          t.push v.symbol_safe_transform
+        end
+      when /^:"(.*)"/, /^:(.*)/
+        return $1.to_sym
+      else
+        return transform
+      end
+      YAML.transfer(@type_id, t)
+    end
+
+  end # module BaseNode
+
+end # module YAML
+
+
 class Regexp
   have YamlExtension, :re
 
@@ -41,17 +110,20 @@ end # class Regexp
 
 
 
-class Range
-  have YamlExtension
-
-  def to_yaml_string
-    to_s
-  end
+class Range # FIXME
+  yaml_as 'tag:yaml.org,2002:range'
 
-  def self.yaml_load ( val )
-    range = eval(val.to_s)
-    raise ArgumentError, "need a range not #{val}" unless range.is_a? Range
-    range
+  class << self
+    alias_method :yaml_new_no_eval, :yaml_new
+    def yaml_new( klass, tag, val )
+      begin
+        yaml_new_no_eval klass, tag, val
+      rescue YAML::TypeError
+        range = eval val.to_s
+        raise unless range.is_a? Range
+        range
+      end
+    end
   end
 
 end # class Range
@@ -62,42 +134,18 @@ class Array
 
   alias_method :old_to_yaml, :to_yaml
 
-  if HAVE_YAML_TAGURI
-    def to_yaml ( opts={} )
-      inline = nil
-      if not opts.is_a?(YAML::Syck::Emitter) and opts[:Inline] and not is_complex_yaml?
-        inline = :inline
-      end
-      YAML::quick_emit(object_id, opts) do |out|
-        out.seq( taguri, to_yaml_style || inline ) do |seq|
-          each { |x| seq.add x }
-        end
-      end
+  def to_yaml ( opts={} )
+    inline = nil
+    if YAML.have_option? opts, :Inline and not is_complex_yaml?
+      inline = :inline
     end
-  else
-    def to_yaml ( opts={} )
-      em = (opts.is_a? YAML::Syck::Emitter)? opts : opts[:Emitter]
-      if (opts[:Inline] or (em and em.options[:Inline])) and not is_complex_yaml?
-        YAML::quick_emit(self.object_id, opts) do |out|
-          out << '['
-          first = true
-          each do |x|
-            if first
-              first = false
-            else
-              out << ', '
-            end
-            x.to_yaml(:Emitter => out)
-          end
-          out << ']'
-        end
-      else
-        old_to_yaml(opts)
+    YAML::quick_emit(object_id, opts) do |out|
+      out.seq( taguri, to_yaml_style || inline ) do |seq|
+        each { |x| seq.add x }
       end
     end
   end
 
-
   suppress(NoMethodError, NameError) { undef_method :is_complex_yaml? }
 
   def is_complex_yaml?
@@ -112,44 +160,18 @@ class Hash
 
   alias_method :old_to_yaml, :to_yaml
 
-  if HAVE_YAML_TAGURI
-    def to_yaml ( opts={} )
-      inline = nil
-      if not opts.is_a?(YAML::Syck::Emitter) and opts[:Inline] and not is_complex_yaml?
-        inline = :inline
-      end
-      YAML::quick_emit(object_id, opts) do |out|
-        out.map(taguri, to_yaml_style || inline) do |map|
-          each { |k, v| map.add k, v }
-        end
-      end
+  def to_yaml ( opts={} )
+    inline = nil
+    if YAML.have_option? opts, :Inline and not is_complex_yaml?
+      inline = :inline
     end
-  else
-    def to_yaml ( opts={} )
-      em = (opts.is_a? YAML::Syck::Emitter)? opts : opts[:Emitter]
-      if (opts[:Inline] or (em and em.options[:Inline])) and not is_complex_yaml?
-        YAML::quick_emit(self.object_id, opts) do |out|
-          out << '{'
-          first = true
-          each do |k, v|
-            if first
-              first = false
-            else
-              out << ', '
-            end
-            k.to_yaml(:Emitter => out)
-            out << ': '
-            v.to_yaml(:Emitter => out)
-          end
-          out << '}'
-        end
-      else
-        old_to_yaml(opts)
+    YAML::quick_emit(object_id, opts) do |out|
+      out.map(taguri, to_yaml_style || inline) do |map|
+        each { |k, v| map.add k, v }
       end
     end
   end
 
-
   suppress(NoMethodError, NameError) { undef_method :is_complex_yaml? }
 
   def is_complex_yaml?
@@ -189,10 +211,10 @@ test_section __FILE__ do
     end
 
     def test_range
-      assert_yaml_load "!range 0..10", Range, 0..10
-      assert_yaml_dump @val, @ref
-      assert_yaml_load "!range 0...10", Range, 0...10
-      assert_yaml_dump @val, @ref
+      assert_yaml_load '!range "0..10"', Range, 0..10
+      assert_yaml_dump @val, "!range \nbegin: 0\nend: 10\nexcl: false"
+      assert_yaml_load '!range "0...10"', Range, 0...10
+      assert_yaml_dump @val, "!range \nbegin: 0\nend: 10\nexcl: true"
     end
 
     def test_ruby

data/lib/core_ex.rb

@@ -1,10 +1,17 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: core_ex.rb 386 2005-10-03 00:02:16Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/core_ex.rb 22188 2006-02-23T16:26:24.490864Z pouillar  $
 
 unless defined? CORE_EX_LOADED and CORE_EX_LOADED
   CORE_EX_LOADED = true
+
+  # Nothing before me !!!
+  class Module
+    alias_method :original_core_ex_const_missing, :const_missing
+    alias_method :the_standard_name, :name
+  end # module Module
+
   require 'English'
   $LOADED_FEATURES << 'core_ex.rb' unless $LOADED_FEATURES.include? 'core_ex.rb'
 
@@ -46,7 +53,7 @@ unless defined? CORE_EX_LOADED and CORE_EX_LOADED
   end
 
   begin
-    require 'rubygems'
+    require 'rubygems' unless ENV['NO_GEM']
     raise LoadError, 'RubyGems not loaded' unless defined? RubyGems
     def core_ex_gem_require ( gem_name, gem_version='> 0' )
       require_gem gem_name, gem_version
@@ -73,45 +80,123 @@ unless defined? CORE_EX_LOADED and CORE_EX_LOADED
   verbose = $VERBOSE
   $VERBOSE = false
 
-  # <<< Dynamic fix: bug: Ruby 1.8.3 vs active_support 1.1.1
-  require 'logger'
-  class Logger
-    Format = 42 unless defined? Format
+  core_ex_require 'active_support', 'activesupport', 'activesupport', '~> 1.2.5'
+
+  $VERBOSE = verbose
+
+  # <<< little active_support patch
+  silence_warnings do
+    module Inflector
+      class Inflections
+        # <<<
+        attr_reader :underscore_rules, :camelize_rules
+        # >>>
+        def initialize
+          # <<<
+          clear_all
+          # >>>
+        end
+        # <<<
+        def clear_all
+          @plurals, @singulars, @uncountables, @underscore_rules, @camelize_rules = [], [], [], [], []
+        end
+        # >>>
+        def clear ( scope=:all )
+          case scope
+            when :all
+              # <<<
+              clear_all
+              # >>>
+            else
+              instance_variable_set "@#{scope}", []
+          end
+        end
+        def mk_regexp ( anObject )
+          case anObject
+          when Regexp then anObject
+          else
+            str = Regexp.quote anObject.to_s
+            /\b#{str}\b/
+          end
+        end
+        private :mk_regexp
+        def underscore(rule, replacement)
+          @underscore_rules.unshift [mk_regexp(rule), replacement]
+        end
+        def camelize(rule, replacement)
+          @camelize_rules.unshift [mk_regexp(rule), replacement]
+        end
+        def fixed_case ( camel_cased_word,
+                         lower_case_and_underscored_word=camel_cased_word.downcase )
+          camelize(lower_case_and_underscored_word, camel_cased_word)
+          underscore(camel_cased_word, lower_case_and_underscored_word)
+        end
+        def fixed_cases ( *words )
+          for word in words
+            if word.is_a? Array
+              fixed_case(*word)
+            else
+              fixed_case word
+            end
+          end
+        end
+      end
+      # Since Inflections is already loaded and is a Singleton we need to initialize
+      # our variables by hand:
+      Inflections.instance.instance_eval { @underscore_rules, @camelize_rules = [], [] }
+
+      def underscore(camel_cased_word)
+        # <<<
+        result = camel_cased_word.to_s.split '::'
+        result.map! do |word|
+          inflections.underscore_rules.each { |(rule, replacement)| break if word.gsub!(rule, replacement) }
+          word.gsub!(/([A-Z])/, '_\1')
+          word.gsub!(/^_/, '')
+          word.downcase!
+          word
+        end
+        result.join '/'
+        # >>>
+      end
+      def camelize(lower_case_and_underscored_word)
+        # <<<
+        result = lower_case_and_underscored_word.to_s.split '/'
+        result.map! do |word|
+          inflections.camelize_rules.each { |(rule, replacement)| break if word.gsub!(rule, replacement) }
+          word.gsub!(/(^|_)(.)/) { $2.upcase }
+          word
+        end
+        result.join '::'
+        # >>>
+      end
+    end # module Inflector
   end
+  module Dependencies
+    def self.change_mechanism ( arg, &block )
+      save = mechanism
+      begin
+        self.mechanism = arg
+        block[]
+      ensure
+        self.mechanism = save
+      end
+    end
+  end # module Dependencies
   # >>>
 
-  core_ex_require 'active_support', 'activesupport', 'activesupport', '~> 1.1.1'
-
   # <<< Dynamic patch: Yaml warnings in ruby 1.8.3
   begin
-    silence_warnings { require 'yaml/tag' }
+    Dependencies.change_mechanism(:require) { silence_warnings { require_dependency 'yaml' } }
     class Module
-      alias yaml_as_bugged yaml_as
+      alias_method :yaml_as_bugged, :yaml_as
       def yaml_as( tag, sc = true )
-        class_eval <<-"end;", __FILE__, __LINE__
-          attr_writer :taguri
-          def taguri
-            if respond_to? :to_yaml_type
-              YAML::tagurize( to_yaml_type[1..-1] )
-            else
-              return @taguri if defined? @taguri
-              tag = #{ tag.dump }
-              if self.class.yaml_tag_subclasses? and self.class != YAML::tagged_classes[tag]
-                tag = "\#{ tag }:\#{ self.class.yaml_tag_class_name }"
-              end
-              tag
-            end
-          end
-          def self.yaml_tag_subclasses?; #{ sc ? 'true' : 'false' }; end
-        end;
-        YAML::tag_class tag, self
+        silence_warnings { yaml_as_bugged(tag, sc) }
       end
     end
-    silence_warnings { require 'yaml' }
     module YAML
       module Syck
         class Parser
-          alias initialize_bugged initialize
+          alias_method :initialize_bugged, :initialize
           def initialize ( *a, &b )
             @input = nil
             initialize_bugged(*a, &b)
@@ -131,74 +216,6 @@ unless defined? CORE_EX_LOADED and CORE_EX_LOADED
   # >>>
 
 
-# <<< little active_support patch
-module Inflector
-  def underscore(camel_cased_word)
-    camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z])/,'_\1').gsub(/(^|\/)_/, '\1').downcase
-  end
-  def constantize(camel_cased_word, start=Object)
-    camel_cased_word.split("::").inject(start) do |final_type, part|
-      return nil unless final_type.const_defined? part
-      final_type.const_get(part)
-    end
-  end
-end # module Inflector
-module Dependencies
-  class LoadingModule
-    def const_load!(name, file_name = nil)
-      file_name ||= 'application' if root? && name.to_s == 'ApplicationController'
-      path = self.path + [file_name || name]
-
-      load_paths.each do |load_path|
-        fs_path = load_path.filesystem_path(path)
-        next unless fs_path
-
-        case
-        when File.directory?(fs_path)
-          new_module = LoadingModule.new(self.root, self.path + [name])
-          self.const_set name, new_module
-          if self.root?
-            if Object.const_defined?(name)
-              msg = "Cannot load module #{name}: Object::#{name} is set to #{Object.const_get(name).inspect}"
-              raise NameError, msg
-            end
-            Object.const_set(name, new_module)
-          end
-          # <<<
-          module_fs_path = fs_path + '.rb'
-          self.root.load_file!(module_fs_path) if File.exist?(module_fs_path)
-          # >>>
-          break
-        when File.file?(fs_path)
-          self.root.load_file!(fs_path)
-
-          # Import the loaded constant from Object provided we are the root node.
-          self.const_set(name, Object.const_get(name)) if self.root? && Object.const_defined?(name)
-          break
-        end
-      end
-
-      self.const_defined?(name)
-    end
-  end # class LoadingModule
-end # module Dependencies
-# >>>
-
-$VERBOSE = verbose
-
-DEPENDENCIES_MECHANISM = :require unless defined? DEPENDENCIES_MECHANISM
-Dependencies.mechanism = DEPENDENCIES_MECHANISM
-
-if Object.const_defined? :Controllers
-  # Perhaps a rails environement
-  raise 'bad Controllers' unless Controllers.is_a? Dependencies::RootLoadingModule
-  Controllers.load_paths << Dependencies::ConstantLoadPath.new(CORE_EX_DIR.to_s)
-else
-  Controllers = Dependencies::LoadingModule.root(CORE_EX_DIR.to_s)
-end
-Controllers::CoreEx.name # .import! is not yet defined
-Controllers::Test::Unit::UI::Yaml.name
-
 module CoreEx
 
   module_function
@@ -211,8 +228,20 @@ module CoreEx
     dir + 'core_ex'
   end
 
+  def test_dir
+    dir.parent + 'test'
+  end
+
+  def fixtures_dir
+    test_dir + 'fixtures'
+  end
+
 end # module CoreEx
 
+$LOAD_PATH << CoreEx.dir
+
+require 'core_ex/embedded_tests'
+
 class Object
   include CoreEx::EmbeddedTests
 end # class Object
@@ -220,6 +249,8 @@ if defined? EMBEDDED_TEST_MODE
   embedded_test_mode EMBEDDED_TEST_MODE
 end
 
+require 'core_ex/lazy_loading'
+
 class String
   include CoreEx::String
 end # class String
@@ -251,34 +282,6 @@ class Pathname
   include CoreEx::Pathname
 end # class Pathname
 
-$LOADED_FEATURES.dup.each do |feature|
-  if (path = Pathname.new(feature)).absolute?
-    load_path, base_path = path.split_with_load_path($LOAD_PATH)
-    unless load_path.nil?
-      new_feature = base_path.to_s
-      next if $LOADED_FEATURES.include? new_feature
-      $LOADED_FEATURES << new_feature
-    end
-  end
-end
-
-module Kernel
-
-  alias_method :require_without_unification, :require
-  def require ( file, *a )
-    if (path = Pathname.new(file)).absolute?
-      load_path, base_path = path.split_with_load_path
-      unless load_path.nil?
-        feature = base_path.to_s
-        return false if $LOADED_FEATURES.include? feature
-        $LOADED_FEATURES << feature
-      end
-    end
-    require_without_unification(file, *a)
-  end
-
-end # module Kernel
-
 module Enumerable
   include CoreEx::Enumerable
 end # module Enumerable
@@ -303,9 +306,7 @@ CoreEx.dir.load_path!
 CoreEx::Yaml.import!
 CoreEx::TryDup.import!
 
-
 require 'pp'
-silence_warnings { require 'active_support/breakpoint' }
 
 test_section __FILE__ do
 
@@ -318,7 +319,7 @@ test_section __FILE__ do
     end
 
     def test_simple
-      assert_kind_of Dependencies::LoadingModule, Controllers::CoreEx
+      assert_kind_of Module, CoreEx
       assert_raise(NameError) { EmbeddedTests }
       assert_kind_of Module, CoreEx::EmbeddedTests
     end