mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/matchdata.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/matchdata/match.rb

@@ -0,0 +1,15 @@
+class MatchData
+
+  # Return the primary match string. This is equivalent to +md[0]+.
+  #
+  #   md = /123/.match "123456"
+  #   md.match  #=> "123"
+  #
+  #  CREDIT: Martin DeMello
+
+  def match(index=0)
+    self[index]
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/matchdata/matchset.rb

@@ -0,0 +1,44 @@
+class MatchData
+
+  # Returns [ pre_match, matchtree, post_match ]. (see matchtree)
+  #
+  #   md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+  #   md.to_a      #=> ["XXaabbccddeeffXX", "bb", "ccdd", "dd", "ee"]
+  #   md.matchset  #=> ["XXaa", [["bb"], ["cc", ["dd"]], "ee"], "ffXX"]
+  #
+  #   CREDIT: Trans
+
+  def matchset
+     [pre_match, matchtree, post_match]
+  end
+
+  # An alternate to #to_a which returns the matches in
+  # order corresponding with the regular expression.
+  #
+  #   md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+  #   md.to_a       #=> ["XXaabbccddeeffXX", "bb", "ccdd", "dd", "ee"]
+  #   md.matchtree  #=> [["bb"], ["cc", ["dd"]], "ee"]
+  #
+  #  CREDIT: Trans
+
+  def matchtree(index=0)
+    ret=[]
+    b, e=self.begin(index), self.end(index)
+    while (index+=1)<=length
+      if index==length || (bi=self.begin(index))>=e
+        # we are finished, if something is left, then add it
+        ret << string[b, e-b] if e>b
+        break
+      else
+        if bi>=b
+          ret << string[b, bi-b] if bi>b
+          ret << matchtree(index)
+          b=self.end(index)
+        end
+      end
+    end
+    return ret
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/metaid.rb

@@ -0,0 +1,94 @@
+module Kernel
+
+  # Alias a method defined in the metaclass (ie. singleton class).
+  #
+  #   def X.y?; "y?" ; end
+  #   X.meta_alias "ynot?", "y?"
+  #   X.ynot?  #=> y?
+  #
+  #  CREDIT: Trans
+
+  def meta_alias(*args)
+    meta_class do
+      alias_method(*args)
+    end
+  end
+
+  # Evaluate code in a metaclass. This is equivalent to
+  # 'meta_class.instance_eval'.
+  #
+  #  CREDIT: WhyTheLuckyStiff
+
+  def meta_eval(str=nil, &blk)
+    if str
+      meta_class.instance_eval(str)
+    else
+      meta_class.instance_eval(&blk)
+    end
+  end
+
+  # Add method to a meta-class --i.e. a singleton method.
+  #
+  #   class X; end
+  #   X.meta_def(:x){"x"}
+  #   X.x  #=> "x"
+  #
+  #  CREDIT: WhyTheLuckyStiff
+
+  def meta_def( name, &block )
+    meta_class do
+      define_method( name, &block )
+    end
+  end
+
+  # Easy access to an object's "special" class,
+  # otherwise known as it's metaclass or singleton class.
+
+  def meta_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+  alias_method :metaclass, :meta_class
+
+  # During this trying time when no one can get their
+  # techie catchwords to stick to the refrigerator no
+  # matter how hard they slap it # with the enchanted
+  # magnetic spatula, it’s good to know that the
+  # contrived phrases really do fly, graceful and
+  # unclasped and bearing north toward chilled shrimp.
+  # I know what my Hallowe’en pumpkin is going to say.
+  #
+  #                       -- why the lucky stiff
+  #
+  #   CREDIT: WhyTheLuckyStiff
+
+  def eigenclass
+    (class << self; self; end)
+  end
+
+end
+
+
+class Module
+
+  # Defines an instance method within a class.
+  #
+  #   CREDIT: WhyTheLuckyStiff
+
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  protected :attr
+  protected :attr_reader
+  protected :attr_writer
+  protected :attr_accessor
+  protected :remove_method
+  protected :undef_method
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/abstract.rb

@@ -0,0 +1,21 @@
+class Module
+
+  # Create an abstract method. If it is not overridden, it will
+  # raise a TypeError when called.
+  #
+  #   class C
+  #     abstract :a
+  #   end
+  #
+  #   c = C.new
+  #   c.a  #=> Error: undefined abstraction #a
+  #
+  #  CREDIT: Trans
+
+  def abstract( *sym )
+    sym.each { |s|
+      define_method( s ) { raise TypeError, "undefined abstraction ##{s}" }
+    }
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/module/alias_accessor.rb

@@ -0,0 +1,45 @@
+class Module
+
+  private
+
+  # As with alias_method, but alias both reader and writer.
+  #
+  #   attr_accessor :x
+  #   self.x = 1
+  #   alias_accessor :y, :x
+  #   y #=> 1
+  #   self.y = 2
+  #   x #=> 2
+
+  def alias_accessor(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+      alias_method("#{name}=", "#{orig}=")
+    end
+  end
+
+  # As with alias_accessor, but just for the reader.
+  # This is basically the same as alias_method.
+
+  def alias_reader(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+    end
+  end
+
+  # As with alias_method but does the writer instead.
+
+  def alias_writer(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}=", "#{orig}=")
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/alias_method_chain.rb

@@ -0,0 +1,50 @@
+class Module
+
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  #
+  # Query and bang methods (foo?, foo!) keep the same punctuation:
+  #
+  #   alias_method_chain :foo?, :feature
+  #
+  # is equivalent to
+  #
+  #   alias_method :foo_without_feature?, :foo?
+  #   alias_method :foo?, :foo_with_feature?
+  #
+  # so you can safely chain foo, foo?, and foo! with the same feature.
+  #
+  #  CREDIT: Bitsweat
+  #  CREDIT: Rails Team
+
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/alias_module_function.rb

@@ -0,0 +1,30 @@
+class Module
+
+  private
+
+  # Alias a module function so that the alias is also
+  # a module function. The typical #alias_method
+  # does not do this.
+  #
+  #   module Demo
+  #     module_function
+  #     def hello
+  #       "Hello"
+  #     end
+  #   end
+  #
+  #   Demo.hello    #=> Hello
+  #
+  #   module Demo
+  #     alias_module_function( :hi , :hello )
+  #   end
+  #
+  #   Demo.hi       #=> Hello
+
+  def alias_module_function(new, old)
+    alias_method(new, old)
+    module_function(new)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/ancestor.rb

@@ -0,0 +1,16 @@
+class Module
+
+  # Is a given class or module an ancestor of
+  # this class or module?
+  #
+  #  class X ; end
+  #  class Y < X ; end
+  #
+  #   X.ancestor?(Y)
+
+  def ancestor?( mod )
+    ancestors.include? mod
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/basename.rb

@@ -0,0 +1,31 @@
+class Module
+
+  # Returns the root name of the module/class.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Demo.name       #=> "Example::Demo"
+  #   Demo.basename   #=> "Demo"
+  #
+  # For anonymous modules this will provide a basename
+  # based on Module#inspect.
+  #
+  #   m = Module.new
+  #   m.inspect       #=> "#<Module:0xb7bb0434>"
+  #   m.basename      #=> "Module_0xb7bb0434"
+  #
+  #   CREDIT: Trans
+
+  def basename
+    if name and not name.empty?
+      name.gsub(/^.*::/, '')
+    else
+      nil #inspect.gsub('#<','').gsub('>','').sub(':', '_')
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/can.rb

@@ -0,0 +1,14 @@
+class Module
+
+  # An alias for #extend.
+  #
+  #   class X
+  #     can Forwardable
+  #   end
+  #
+  # BTW, why is Forwardable an -able? It's not a mixin!
+
+  alias_method :can, :extend
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/class.rb

@@ -0,0 +1,12 @@
+class Module
+
+  # Alias for #===. This provides a verbal method
+  # for inquery.
+  #
+  #   s = "HELLO"
+  #   String.class?(s)  #=> true
+
+  alias_method :class?, :===
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/conflict.rb

@@ -0,0 +1,63 @@
+class Module
+
+  # Detect conflicts.
+  #
+  #   module A
+  #     def c; end
+  #   end
+  #
+  #   module B
+  #     def c; end
+  #   end
+  #
+  #   A.conflict?(B)  #=> ["c"]
+  #
+  #
+  #   TODO: All instance methods, or just public?
+  #
+  #  CREDIT: Thomas Sawyer
+  #  CREDIT: Robert Dober
+
+  def conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
+    c = []
+    c += (public_instance_methods(true) & other.public_instance_methods(true))
+    c += (private_instance_methods(true) & other.private_instance_methods(true))
+    c += (protected_instance_methods(true) & other.protected_instance_methods(true))
+    c -= common_ancestor.public_instance_methods(true)
+    c -= common_ancestor.private_instance_methods(true)
+    c -= common_ancestor.protected_instance_methods(true)
+    c.empty? ? false : c
+  end
+
+  #def conflict?(other)
+  #  c = instance_methods & other.instance_methods
+  #  c.empty ? false : c
+  #end
+
+  # Like #conflict?, but checks only public methods.
+  def public_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
+    c = public_instance_methods(true) & other.public_instance_methods(true)
+    c -= common_ancestor.public_instance_methods(true)
+    c.empty? ? false : c
+  end
+
+  # Like #conflict?, but checks only private methods.
+  def private_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
+    c = private_instance_methods(true) & other.private_instance_methods(true)
+    c -= common_ancestor.private_instance_methods(true)
+    c.empty? ? false : c
+  end
+
+  # Like #conflict?, but checks only protected methods.
+  def protected_conflict?(other)
+    common_ancestor = (ancestors & other.ancestors).first
+    c = protected_instance_methods(true) & other.protected_instance_methods(true)
+    c -= common_ancestor.protected_instance_methods(true)
+    c.empty? ? false : c
+  end
+
+end
+