facets 2.9.3 → 3.0.0

data/lib/core/facets/string/unfold.rb

@@ -1,8 +1,13 @@
 class String
 
-  # Unfold paragrpahs.
+  # Unfold paragraphs such that new lines are removed from between
+  # sentences of the same paragraph.
   #
-  # FIXME: Sometimes adds one too many blank lines. TEST!!!
+  # Note that #rstrip is called on the final result, but this may
+  # change in the future.
+  #
+  # FIXME: Sometimes adds one too many blank lines, which is why we are
+  #         using rstrip. Fix and probably remove the rstrip.
   #
   def unfold
     blank = false

data/lib/core/facets/struct.rb

@@ -1,4 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'struct/attributes.rb'
+require_relative 'struct/replace.rb'
 

data/lib/core/facets/struct/replace.rb

@@ -0,0 +1,8 @@
+class Struct
+
+  # Struct#replace can take any +source+ that responds to #each_pair.
+  def replace(source)
+    source.each_pair{ |k,v| send(k.to_s + "=", v) }
+  end
+
+end

data/lib/core/facets/symbol.rb

@@ -1,7 +1,6 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'symbol/as_s.rb'
 require_relative 'symbol/bang.rb'
+require_relative 'symbol/call.rb'
 require_relative 'symbol/chomp.rb'
 require_relative 'symbol/generate.rb'
 require_relative 'symbol/not.rb'
@@ -11,6 +10,5 @@ require_relative 'symbol/query.rb'
 require_relative 'symbol/setter.rb'
 require_relative 'symbol/succ.rb'
 require_relative 'symbol/thrown.rb'
-require_relative 'symbol/to_proc.rb'
 require_relative 'symbol/variablize.rb'
 

data/lib/core/facets/symbol/as_s.rb

@@ -2,10 +2,12 @@ require 'facets/functor'
 
 class Symbol
 
+  # TODO: Should Symbol#as_s be moved to functor gem?
+
   # Convert symbol to string, apply string method and convert
   # back to symbol via a fluent interface.
   #
-  #   :HELLO.as_s.downcase  #=> :hello
+  #   :HELLO.as_s.chomp('O')  #=> :HELL
   #
   def as_s
     Functor.new do |op, *a|

data/lib/core/facets/symbol/call.rb

@@ -0,0 +1,29 @@
+class Symbol
+
+  # Useful extension for &:symbol which makes it possible
+  # to pass arguments for method in block
+  #
+  #   ['abc','','','def','ghi'].tap(&:delete.(''))
+  #   #=> ['abc','def','ghi']
+  #
+  #   [1,2,3].map(&:to_s.(2))
+  #   #=> ['1','10','11']
+  #
+  #   ['abc','cdef','xy','z','wwww'].select(&:size.() == 4)
+  #   #=> ['cdef', 'wwww']
+  #
+  #   ['abc','aaA','AaA','z'].count(&:upcase.().succ == 'AAB')
+  #   #=> 2
+  #
+  #   [%w{1 2 3 4 5},%w{6 7 8 9}].map(&:join.().length)
+  #   #=> [5,4]
+  #
+  # CREDIT: Ilya Vorontsov, Nobuyoshi Nakada
+
+  def call(*args, &block)
+    proc do |recv|
+      recv.__send__(self, *args, &block)
+    end
+  end
+
+end

data/lib/core/facets/symbol/thrown.rb

@@ -1,18 +1,22 @@
 class Symbol
 
-  # Does the block throw the symbol?
-  # 
+  # Returns truew if the given block throws the symbol, otherwise false.
+  # Note that +throw+ inside the block must be used in one-argument form.
+  #
+  # @return [true,false]
   def thrown?
+    thrown = true
     catch(self) do
       begin
         yield
-        true
+        thrown = false
       rescue ArgumentError => err     # 1.9 exception
-        false  #msg += ", not #{err.message.split(/ /).last}"
+        thrown = false if err.message.index('uncaught throw')
       rescue NameError => err         # 1.8 exception
-        false  #msg += ", not #{err.name.inspect}"
+        thrown = false if err.message.index('uncaught throw')
       end
     end
+    thrown
   end
 
 end

data/lib/core/facets/time.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'time/ago.rb'
 require_relative 'time/change.rb'
 require_relative 'time/dst_adjustment.rb'

data/lib/core/facets/time/future.rb

@@ -1,13 +1,15 @@
 class Time
 
-  #
+  def self.current
+    now
+  end
+
   def past?(other=nil)
-    self < (other || ::Time.now)
+    self < (other || self.class.current)
   end
 
-  #
   def future?(other=nil)
-    self > (other || ::Time.now)
+    self > (other || self.class.current)
   end
 
 end

data/lib/core/facets/unboundmethod.rb

@@ -1,5 +1,2 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'unboundmethod/arguments.rb'
-require_relative 'unboundmethod/name.rb'
 

data/lib/core/facets/version.rb

@@ -1,7 +1,7 @@
 module Facets
   #
-  def self.profile
-    @profile ||= (
+  def self.index
+    @index ||= (
       require 'yaml'
       YAML.load(File.new(File.dirname(__FILE__) + '/facets.yml'))
     )
@@ -10,10 +10,10 @@ module Facets
   #
   def self.const_missing(name)
     key = name.to_s.downcase
-    profile[key] || super(name)
+    index[key] || super(name)
   end
 
-  #
-  VERSION = '2.9.3'  # profile['version']
+  # deprecate
+  VERSION = '3.0.0'
 end
 

data/lib/standard/facets/against.rb

@@ -0,0 +1,53 @@
+require 'facets/functor'
+
+class Object
+
+  # Objectified message or block application. Only a message
+  # or a block can be given, not both.
+  #
+  # msg - method and arguments [Array]
+  # blk - procedure block [Proc]
+  #
+  # Examples
+  #
+  #   a = [1,2,3,4,5]
+  #   c = a.against(:>, 2)
+  #   c.select  #=> [3,4,5]
+  #
+  #   a = [1,2,3,4,5]
+  #   c = a.against(:>)
+  #   c.select(2)  #=> [3,4,5]
+  #
+  # Returns [Functor]
+  #
+  # TODO: Better name for this method?
+
+  def against(*msg, &blk)
+    raise ArgumentError, "too many arguments" if blk && !msg.empty?
+
+	  this = self
+
+    blk = ::Proc.new{ |x,*a| x.__send__(*msg, *a) } unless blk
+
+    #if blk
+		  Functor.new do |m, *a, &b|
+			  if b
+			    b2 = ::Proc.new{ |*x| blk.call(*b.call(*x), *a) }
+        else
+          b2 = blk
+			  end
+			  this.__send__(m, &b2)
+		  end
+    #else
+	  #	Functor.new do |m, *a, &b|
+	  #		if b
+	  #		  b2 = ::Proc.new{ |*x| b.call(*x).__send__(*msg, *a) }
+	  #		else
+	  #		  b2 = ::Proc.new{ |x| x.__send__(*msg, *a) }
+	  #		end
+	  #		this.__send__(m, &b2)
+	  #	end
+    #end
+  end
+
+end

data/lib/standard/facets/binding/block_exec.rb

@@ -0,0 +1,44 @@
+class Binding
+
+  # Allows the evaluation of blocks by a Binding in the same way that strings
+  # can be evaluated.
+  #
+  #   x = 5
+  #   $my_binding = binding
+  #
+  #   class Test  # just here to provide a scope gate
+  #     $my_binding.block_exec { x }
+  #   end
+  #
+  #   # => 5
+  #
+  # NOTE: The implementation of this method uses a method_missing trick.
+  #       Consequently it is a bit of a hack.
+  #
+  def block_exec(*args, &block)
+    BlockEnvironment.new(self, *args, &block).call
+  end
+
+  # This class is used for evaluating blocks in a particular context. 
+  # It is not really meant to be used independently; instead it is used
+  # with Binding#block_exec method.
+
+  class BlockEnvironment < BasicObject
+
+    def initialize(context, *args, &block)
+      @context = context
+      @args = args
+      @block = block
+    end
+
+    def call
+      instance_exec(*@args, &@block)
+    end
+
+    def method_missing(name)
+      eval(name.to_s, @context) rescue super
+    end
+
+  end
+
+end

data/lib/standard/facets/cgi.rb

@@ -1,44 +1,6 @@
 require 'cgi'
 
-class CGI
+require 'facets/cgi/marshal'
+require 'facets/cgi/escape_html'
 
-  # Create an hidden input field through which an object can can be marshalled.
-  # This makes it very easy to pass from data betwenn requests.
-  def marshal_to_cgi(name, iobj)
-    data = CGI.escape(Marshal.dump(iobj))
-    return %Q{<input type="hidden" name="__#{name}__" value="#{data}"/>\n}
-  end
 
-  # Create an hidden input field through which an object can can be marshalled.
-  # This makes it very easy to pass from data between requests.
-  def marshal_from_cgi(name)
-    if self.params.has_key?("__#{name}__")
-      return Marshal.load(CGI.unescape(self["__#{name}__"][0]))
-    end
-  end
-
-  # TODO: Rename CGI#esc ?
-
-  # TODO: Are these two good enough to replace CGI.escape?
-
-  # Return an html "safe" version of the string,
-  # where every &, < and > are replaced with appropriate entities.
-  def esc(str)
-    str.gsub(/&/,'&amp;').gsub(/</,'&lt;').gsub(/>/,'&gt;')
-  end
-
-  # Calls #esc, and then further replaces carriage returns and quote characters with entities.
-  def escformat(str)
-    esc(str).gsub(/[\r\n]+/,'&#13;&#10;').gsub(%r|"|,'&quot;').gsub(%r|'|,'&#39;')
-  end
-
-  class << self
-    alias :escape_html :escapeHTML
-    alias :unescape_html :unescapeHTML
-    alias :escape_element :escapeElement
-    alias :unescape_element :unescapeElement
-  end
-
-end
-
-# Copyright (c) 2005 Thomas Sawyer (Ruby License)

data/lib/standard/facets/cgi/esc.rb

@@ -0,0 +1,11 @@
+require 'facets/cgi/escape_html'
+
+class CGI
+
+  # Instance level method for {CGI::escape_html}.
+
+  def esc(string, *modes)
+    self.class.escape_html(string, *modes)
+  end
+
+end

data/lib/standard/facets/cgi/escape_html.rb

@@ -0,0 +1,63 @@
+require 'cgi'
+
+class CGI
+
+  # Extends `#escape_html` to support escape modes. By default all strings
+  # are escaped on `&`, `>` and `<`. Add the `:nonstandard` mode to omit
+  # this conversion.
+  #
+  # If no mode is given then the `:default` mode is used.
+  #
+  # Available modes include:
+  # * `:quote`     - escapes single and double quotes
+  # * `:newlines`  - escapes newline characters (\r and \n)
+  # * `:ampersand` - escapes the ampersand sign
+  # * `:brackets`  - escapes less-than and greater-than signs
+  # * `:default`   - escapes double quotes
+  #
+  # @example
+  #   escape_html("<tag>")  #=> "&lt;tag&gt;"
+  #   escape_html("Example\nString", :newlines)  #=> "Example&#13;&#10;String"
+  #   escape_html("\"QUOTE\"", false)  #=> "\"QUOTE\""
+  #
+  def self.escape_html(string, *modes)
+    modes << :defualt if modes.empty?
+
+    unless modes.include?(:nonstandard)
+      string = string.gsub(/&/, '&amp;').gsub(/>/, '&gt;').gsub(/</, '&lt;')
+    end
+
+    modes.each do |mode|
+      string = \
+        case mode
+        when :quote, :quotes
+          string.gsub(%r|"|,'&quot;').gsub(%r|'|,'&#39;')
+        when :newlines, :newlines
+          string.gsub(/[\r\n]+/,'&#13;&#10;')
+        when :ampersand
+          string.gsub(/&/, '&amp;')
+        when :bracket, :brackets
+          string.gsub(/>/, '&gt;').gsub(/</, '&lt;')
+        when :default, true
+          string.gsub(/\"/, '&quot;')
+        when false
+        else
+          raise ArgumentError, "unrecognized HTML escape mode -- #{node}"
+        end
+    end
+  end
+
+  class << self
+    # @deprecated
+    alias :escapeHTML :escape_html
+  end
+
+  if RUBY_VERSION < '1.9'
+    class << self
+      alias :unescape_html :unescapeHTML
+      alias :escape_element :escapeElement
+      alias :unescape_element :unescapeElement
+    end
+  end
+
+end

data/lib/standard/facets/cgi/marshal.rb

@@ -0,0 +1,20 @@
+require 'cgi'
+
+class CGI
+
+  # Create an hidden input field through which an object can can be marshalled.
+  # This makes it very easy to pass form data betwenn requests.
+  def marshal_to_cgi(name, iobj)
+    data = CGI.escape(Marshal.dump(iobj))
+    return %Q{<input type="hidden" name="__#{name}__" value="#{data}"/>\n}
+  end
+
+  # Create an hidden input field through which an object can can be marshalled.
+  # This makes it very easy to pass form data between requests.
+  def marshal_from_cgi(name)
+    if self.params.has_key?("__#{name}__")
+      return Marshal.load(CGI.unescape(self["__#{name}__"][0]))
+    end
+  end
+
+end

data/lib/standard/facets/cli.rb

@@ -0,0 +1,54 @@
+module Kernel
+  private
+  #
+  # CLI is based on Clap library
+  # Copyright (c) 2010 Michel Martens
+  #
+  def cli(*args)
+    opts = args.pop
+    argv = (args.first || ARGV).dup
+    args = []
+
+    # Split option aliases.
+    opts = opts.inject({}) do |h,(k,v)|
+      k.to_s.split(/\s+/).each{|o| h[o]=v}; h
+    end
+
+    # Convert single dash flags into multiple flags.
+    argv = argv.inject([]) do |a, v|
+      if v[0,1] == '-' && v[1,1] != '-'
+        a.concat(v[1..-1].chars.map{|c| "-#{c}"})
+      else
+        a << v
+      end
+      a
+    end
+
+    while argv.any?
+      item = argv.shift
+      flag = opts[item]
+
+      if flag
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+
+    args
+  end
+end