main 2.6.0 → 2.7.0

data/README

@@ -372,6 +372,11 @@ DOCS
   API section below
 
 HISTORY
+  2.7.0
+    - removed bundled arrayfields and attributes.  these are now dependancies
+      mananged by rubygems.  a.k.a. you must have rubygems installed for main
+      to work.
+
   2.6.0
     - added 'mixin' feaature for storing, and later evaluating a block of
       code.  the purpose of this is for use with modes where you want to keep

data/gemspec.rb

@@ -26,7 +26,7 @@ Gem::Specification::new do |spec|
   spec.has_rdoc = File::exist? "doc" 
   spec.test_suite_file = "test/#{ lib }.rb" if File::directory? "test"
   spec.add_dependency 'attributes', '>= 5.0.0'
-  spec.add_dependency 'arrayfields', '>= 4.3.0'
+  spec.add_dependency 'arrayfields', '>= 4.5.0'
 
   spec.extensions << "extconf.rb" if File::exists? "extconf.rb"
 

data/lib/main.rb

@@ -2,7 +2,7 @@ module Main
 #
 # top level constants
 #
-  Main::VERSION = '2.6.0' unless
+  Main::VERSION = '2.7.0' unless
     defined? Main::VERSION
   def self.version() Main::VERSION end
 
@@ -20,25 +20,13 @@ module Main
   require 'enumerator'
   require 'set'
 #
-# we try to use gems to pick up dependancies
-#
-  begin
-    require 'rubygems'
-  rescue LoadError
-    42
-  end
-  begin
-    gem 'attributes', '~> 5.0.0'
-    require 'attributes'
-  rescue Exception 
-    require libdir + 'attributes'
-  end
-  begin
-    gem 'arrayfields', '~> 4.3.0'
-    require 'arrayfields'
-  rescue Exception 
-    require libdir + 'arrayfields'
-  end
+# use gems to pick up dependancies
+#
+  require 'rubygems'
+  gem 'attributes', '~> 5.0.0'
+  require 'attributes'
+  gem 'arrayfields', '~> 4.5.0'
+  require 'arrayfields'
 #
 # main's own libs
 #

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: main
 version: !ruby/object:Gem::Version 
-  version: 2.6.0
-date: 2007-12-06 00:00:00 -07:00
+  version: 2.7.0
+date: 2007-12-18 00:00:00 -07:00
 summary: main
 require_paths: 
 - lib
@@ -35,8 +35,6 @@ files:
 - install.rb
 - lib
 - lib/main
-- lib/main/arrayfields.rb
-- lib/main/attributes.rb
 - lib/main/base.rb
 - lib/main/cast.rb
 - lib/main/factories.rb
@@ -44,7 +42,6 @@ files:
 - lib/main/logger.rb
 - lib/main/mode.rb
 - lib/main/parameter.rb
-- lib/main/pervasives.rb
 - lib/main/softspoken.rb
 - lib/main/stdext.rb
 - lib/main/usage.rb
@@ -91,5 +88,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 4.3.0
+        version: 4.5.0
     version: 

data/lib/main/arrayfields.rb

@@ -1,434 +0,0 @@
-#
-# The ArrayFields module implements methods which allow an Array to be indexed
-# by String or Symbol. It is not required to manually use this module to
-# extend Arrays - they are auto-extended on a per-object basis when
-# Array#fields= is called
-#
-  module ArrayFields 
-    self::VERSION = '4.5.0' unless defined? self::VERSION
-    def self.version() VERSION end
-  #
-  # multiton cache of fields - wraps fields and fieldpos map to save memory
-  #
-    class FieldSet
-      class << self
-        def new fields
-          @sets[fields] ||= super
-        end
-        def init_sets
-          @sets = {}
-        end
-      end
-
-      init_sets
-
-      attr :fields
-      attr :fieldpos
-      def initialize fields
-        raise ArgumentError, "<#{ fields.inspect }> not inject-able" unless
-          fields.respond_to? :inject
-
-        @fieldpos =
-          fields.inject({}) do |h, f|
-            unless String === f or Symbol === f
-              raise ArgumentError, "<#{ f.inspect }> neither String nor Symbol"
-            end
-            h[f] = h.size
-            h
-          end
-
-        @fields = fields
-      end
-      def pos f
-        return @fieldpos[f] if @fieldpos.has_key? f 
-        f = f.to_s
-        return @fieldpos[f] if @fieldpos.has_key? f 
-        f = f.intern
-        return @fieldpos[f] if @fieldpos.has_key? f 
-        nil
-      end
-    end
-  #
-  # methods redefined to work with fields as well as numeric indexes
-  #
-    def [] idx, *args
-      if @fieldset and (String === idx or Symbol === idx)
-        pos = @fieldset.pos idx
-        return nil unless pos
-        super(pos, *args)
-      else
-        super
-      end
-    end
-    def slice idx, *args
-      if @fieldset and (String === idx or Symbol === idx)
-        pos = @fieldset.pos idx
-        return nil unless pos
-        super(pos, *args)
-      else
-        super
-      end
-    end
-
-    def []=(idx, *args) 
-      if @fieldset and (String === idx or Symbol === idx) 
-        pos = @fieldset.pos idx
-        unless pos
-          @fieldset.fields << idx
-          @fieldset.fieldpos[idx] = pos = size
-        end
-        super(pos, *args)
-      else
-        super
-      end
-    end
-    def at idx
-      if @fieldset and (String === idx or Symbol === idx)
-        pos = @fieldset.pos idx
-        return nil unless pos
-        super pos
-      else
-        super
-      end
-    end
-    def delete_at idx
-      if @fieldset and (String === idx or Symbol === idx)
-        pos = @fieldset.pos idx
-        return nil unless pos
-        super pos
-      else
-        super
-      end
-    end
-    def fill(obj, *args)
-      idx = args.first
-      if idx and @fieldset and (String === idx or Symbol === idx)
-        idx = args.shift
-        pos = @fieldset.pos idx
-        super(obj, pos, *args)
-      else
-        super
-      end
-    end
-
-    def values_at(*idxs)
-      idxs.flatten!
-      if @fieldset
-        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
-      end
-      super(*idxs)
-    end
-    def indices(*idxs)
-      idxs.flatten!
-      if @fieldset
-        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
-      end
-      super(*idxs)
-    end
-    def indexes(*idxs)
-      idxs.flatten!
-      if @fieldset
-        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
-      end
-      super(*idxs)
-    end
-
-    def slice!(*args)
-      ret = self[*args]
-      self[*args] = nil
-      ret
-    end
-    def each_with_field
-      each_with_index do |elem, i|
-        yield elem, @fieldset.fields[i]
-      end
-    end
-  #
-  # methods which give a hash-like interface 
-  #
-    def each_pair
-      each_with_index do |elem, i|
-        yield @fieldset.fields[i], elem
-      end
-    end
-    def each_key
-      @fieldset.each{|field| yield field}
-    end
-    def each_value *args, &block
-      each *args, &block
-    end
-    def fetch key
-      self[key] or raise IndexError, 'key not found'
-    end
-
-    def has_key? key
-      @fieldset.fields.include? key
-    end
-    def member? key
-      @fieldset.fields.include? key
-    end
-    def key? key
-      @fieldset.fields.include? key
-    end
-
-    def has_value? value
-      if respond_to? 'include?'
-        self.include? value
-      else
-        a = []
-        each{|val| a << val}
-        a.include? value
-      end
-    end
-    def value? value
-      if respond_to? 'include?'
-        self.include? value
-      else
-        a = []
-        each{|val| a << val}
-        a.include? value
-      end
-    end
-
-    def keys
-      fields
-    end
-    def store key, value
-      self[key] = value
-    end
-    def values
-      if respond_to? 'to_ary'
-        self.to_ary
-      else
-        a = []
-        each{|val| a << val}
-        a
-      end
-    end
-
-    def to_hash
-      if respond_to? 'to_ary'
-        h = {}
-        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
-        h
-      else
-        a = []
-        each{|val| a << val}
-        h = {}
-        @fieldset.fields.zip(a){|f,e| h[f] = e}
-        h
-      end
-    end
-    def to_h
-      if respond_to? 'to_ary'
-        h = {}
-        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
-        h
-      else
-        a = []
-        each{|val| a << val}
-        h = {}
-        @fieldset.fields.zip(a){|f,e| h[f] = e}
-        h
-      end
-    end
-
-    def update other
-      other.each{|k,v| self[k] = v}
-      to_hash
-    end
-    def replace other
-      Hash === other ? update(other) : super
-    end
-    def invert
-      to_hash.invert
-    end
-
-    def to_pairs
-      fields.zip values
-    end
-    alias_method 'pairs', 'to_pairs'
-
-    def copy 
-      cp = clone
-      cp.fields = fields.clone
-      cp 
-    end
-
-    alias_method 'dup', 'copy'
-    alias_method 'clone', 'copy'
-
-    def deepcopy 
-      cp = Marshal.load(Marshal.dump(self))
-      cp.fields = Marshal.load(Marshal.dump(self.fields))
-      cp 
-    end
-  end
-  Arrayfields = ArrayFields
-
-  module Arrayfields
-    def self.new *pairs
-      pairs = pairs.map{|pair| Enumerable === pair ? pair.to_a : pair}.flatten
-      raise ArgumentError, "pairs must be evenly sized" unless(pairs.size % 2 == 0)
-      (( array = [] )).fields = []
-      0.step(pairs.size - 2, 2) do |a|
-        b = a + 1
-        array[ pairs[a] ] = pairs[b]
-      end
-      array
-    end
-    def self.[] *pairs
-      new *pairs
-    end
-  end
-  def Arrayfields(*a, &b) Arrayfields.new(*a, &b) end
-#
-# Fieldable encapsulates methods in common for classes which may have their
-# fields set and subsequently be auto-extended by ArrayFields
-#
-  module Fieldable
-  #
-  # sets fields an dynamically extends this Array instance with methods for
-  # keyword access
-  #
-    def fields= fields
-      extend ArrayFields unless ArrayFields === self
-
-      @fieldset = 
-        if ArrayFields::FieldSet === fields
-          fields
-        else
-          ArrayFields::FieldSet.new fields
-        end
-    end
-  #
-  # access to fieldset
-  #
-    attr_reader :fieldset
-  #
-  # access to field list
-  #
-    def fields
-      @fieldset and @fieldset.fields
-    end
-  end
-#
-# Array instances are extened with two methods only: Fieldable#fields= and
-# Fieldable#fields.  only when Fieldable#fields= is called will the full set
-# of ArrayFields methods auto-extend the Array instance.  the Array class also
-# has added a class generator when the fields are known apriori.
-#
-  class Array
-    include Fieldable
-
-    class << self
-      def struct *fields
-        fields = fields.flatten
-        Class.new(self) do
-          include ArrayFields
-          const_set :FIELDS, ArrayFields::FieldSet.new(fields)
-          fields.each do |field|
-            field = field.to_s
-            if field =~ %r/^[a-zA-Z_][a-zA-Z0-9_]*$/
-              begin
-                module_eval <<-code
-                  def #{ field } *a
-                    a.size == 0 ? self['#{ field }'] : (self.#{ field } = a.shift) 
-                  end
-                  def #{ field }= value
-                    self['#{ field }'] = value
-                  end
-                code
-              rescue SyntaxError
-                :by_ignoring_it
-              end
-            end
-          end
-          def initialize *a, &b
-            super
-          ensure
-            @fieldset = self.class.const_get :FIELDS
-          end
-          def self.[] *elements
-            array = new
-            array.replace elements
-            array
-          end
-        end
-      end
-      def fields *fields, &block
-        (( array = new(&block) )).fields = fields.map{|x| Enumerable === x ? x.to_a : x}.flatten
-        array
-      end
-    end
-  end
-#
-# proxy class that allows an array to be wrapped in a way that still allows #
-# keyword access.  also facilitate usage of ArrayFields with arraylike objects.
-# thnx to Sean O'Dell for the suggestion.
-#
-# sample usage
-#
-# fa = FieldedArray.new %w(zero one two), [0,1,2]
-# p fa['zero']   #=> 0
-#
-#
-  class FieldedArray
-    include Fieldable
-    class << self
-      def [](*pairs)
-        pairs.flatten!
-        raise ArgumentError, "argument must be key/val pairs" unless 
-          (pairs.size % 2 == 0)
-        fields, elements = [], []
-        while((f = pairs.shift) and (e = pairs.shift)) 
-          fields << f and elements << e
-        end
-        new fields, elements
-      end
-    end
-    def initialize fields = [], array = []
-      @a = array
-      self.fields = fields
-    end
-    def method_missing(meth, *args, &block)
-      @a.send(meth, *args, &block)
-    end
-    delegates =
-      %w(
-        to_s
-        to_str
-        inspect
-      )
-    delegates.each do |meth| 
-      class_eval "def #{ meth }(*a,&b); @a.#{ meth }(*a,&b);end"
-    end
-  end
-  Fieldedarray = FieldedArray
-
-  class PseudoHash < ::Array
-    class << self
-      def [](*pairs)
-        pairs.flatten!
-        raise ArgumentError, "argument must be key/val pairs" unless 
-          (pairs.size % 2 == 0 and pairs.size >= 2)
-        keys, values = [], []
-        while((k = pairs.shift) and (v = pairs.shift)) 
-          keys << k and values << v
-        end
-        new keys, values
-      end
-    end
-    def initialize keys = [], values = []
-      self.fields = keys
-      self.replace values
-    end
-    def to_yaml opts = {}
-      YAML::quick_emit object_id, opts do |out|
-        out.map taguri, to_yaml_style do |map|
-          each_pair{|f,v| map.add f,v}
-        end
-      end
-   end 
-  end
-  Pseudohash = PseudoHash

data/lib/main/attributes.rb

@@ -1,113 +0,0 @@
-module Attributes
-  Attributes::VERSION = '4.0.0' unless defined? Attributes::VERSION
-  def self.version() Attributes::VERSION end
-
-  class List < ::Array
-    def << element
-      super
-      self
-    ensure
-      uniq!
-      index!
-    end
-    def index!
-      @index ||= Hash.new
-      each{|element| @index[element] = true}
-    end
-    def include? element
-      @index ||= Hash.new
-      @index[element] ? true : false
-    end
-    def initializers
-      @initializers ||= Hash.new
-    end
-  end
-
-  def attributes *a, &b
-    unless a.empty?
-      returned = Hash.new
-
-      hashes, names = a.partition{|x| Hash === x}
-      names_and_defaults = {}
-      hashes.each{|h| names_and_defaults.update h}
-      names.flatten.compact.each{|name| names_and_defaults.update name => nil}
-
-      initializers = __attributes__.initializers
-
-      names_and_defaults.each do |name, default|
-        raise NameError, "bad instance variable name '@#{ name }'" if "@#{ name }" =~ %r/[!?=]$/o
-        name = name.to_s
-
-        initialize = b || lambda { default }
-        initializer = lambda do |this|
-          Object.instance_method('instance_eval').bind(this).call &initialize
-        end
-        initializer_id = initializer.object_id
-        __attributes__.initializers[name] = initializer
-
-        module_eval <<-code
-          def #{ name }=(value)
-            @#{ name } = value
-          end
-        code
-        module_eval <<-code
-          def #{ name }(*value)
-            return self.#{ name } = value.first unless value.empty?
-            #{ name }! unless defined? @#{ name }
-            @#{ name }
-          end
-        code
-        module_eval <<-code
-          def #{ name }!
-            initializer = ObjectSpace._id2ref #{ initializer_id }
-            self.#{ name } = initializer.call(self)
-            @#{ name }
-          end
-        code
-        module_eval <<-code
-          def #{ name }?
-            #{ name }
-          end
-        code
-
-        attributes << name
-        returned[name] = initializer 
-      end
-
-      returned
-    else
-      begin
-        __attribute_list__
-      rescue NameError
-        singleton_class =
-          class << self
-            self
-          end
-        klass = self
-        singleton_class.module_eval do
-          attribute_list = List.new 
-          define_method('attribute_list'){ klass == self ? attribute_list : raise(NameError) }
-          alias_method '__attribute_list__', 'attribute_list'
-        end
-        __attribute_list__
-      end
-    end
-  end
-
-  %w( __attributes__ __attribute__ attribute ).each{|dst| alias_method dst, 'attributes'}
-end
-
-class Object
-  def attributes *a, &b
-    sc = 
-      class << self
-        self
-      end
-    sc.attributes *a, &b
-  end
-  %w( __attributes__ __attribute__ attribute ).each{|dst| alias_method dst, 'attributes'}
-end
-
-class Module
-  include Attributes
-end

data/lib/main/pervasives.rb

@@ -1,52 +0,0 @@
-module Pervasives
-  VERSION = "1.1.0"
-  def self.version() VERSION end
-
-  Methods = Hash.new{|h,k| h[k] = {}}
-
-  [Class, Module, Object].each do |type|
-    type.instance_methods.each do |m|
-      Methods[type]["#{ m }"] = type.instance_method m
-    end
-  end
-
-  def self.call o, m, *a, &b
-    list = 
-      case o
-        when Class then [Class, Module, Object]
-        when Module then [Module, Object]
-        when Object then [Object]
-      end
-    type = list.detect{|type| Methods[type]["#{ m }"]} 
-    m = Methods[type]["#{ m }"]
-    ( m ).bind( o ).call( *a, &b )
-  end
-
-  class ::Object
-    def __pervasive__ m, *a, &b
-      Pervasives.call self, m, *a, &b
-    end
-  end
-
-  class Proxy
-    instance_methods.each{|m| undef_method m unless m[%r/__/]}
-
-    def initialize obj
-      @obj = obj
-    end
-
-    def method_missing m, *a, &b
-      Pervasives.call @obj, m, *a, &b
-    end
-  end
-
-  def self.new *a, &b
-    Proxy.new *a, &b
-  end
-
-  class ::Object
-    def Pervasives *a, &b
-      Proxy.new *a, &b
-    end
-  end
-end