masterview 0.0.6 → 0.0.7

data/lib/facets/README

@@ -0,0 +1,252 @@
+
+= Ruby Facets
+
+  "ALL BASE COMMON"
+
+
+== Introduction
+
+Ruby Facets
+
+Facets/CORE is a vast collection of methods which extend the core
+capabilities of Ruby's built-in classes and modules.
+
+This collection of extension methods is unique by virtue of its atomicity.
+The methods are stored individually so that each can be required
+independently. This gives developers fine-grain control over which 
+extra methods to bring into his or her code. The collection currently 
+contains over 400 methods spanning 28 classes and modules.
+
+Facets/MORE is a collection of additioanl classes, modules and microframeworks.
+
+The class, module and microframework additions consitute an ever growing
+and improving source of reusable components. Some very nice adsitions
+have recently been added, from an amazing Units system to an elegant 
+annotations systems. And of course there are all the more typical goodies
+like Tuple, Functor and Multiton.
+
+== Mission
+
+Facets holds to the notion that the more we can reasonably integrate into
+a common foundation directed toward general needs, the better that foundation 
+will be able to serve us. There are a number of advantages here:
+
+    * Better Code-reuse
+    * Collaborative Improvements
+    * Greater Name Consistency
+    * One-stop Shop and Installation
+
+
+== Status
+
+The current status is quite good. While various parts are still considered
+Beta, everything is relatively usable.
+
+
+== Installation
+
+
+The easiest way to install is via RubyGems. On the command line enter:
+
+  > gem install facets
+
+To manually install, unpack the .tbz (.tar.bz2) package and use the included
+setup.rb script. For example:
+
+  > tar -xvzf facets,YYYY-MM-DD.tbz
+  > cd facets,YYYY-MM-DD
+  > sudo ruby setup.rb
+
+
+== Usage
+
+For detailed usage of any given method or module please refer to the
+API RDocs. Most are well documented.
+
+To use a single facet you simply require the method by name, for example:
+
+  require 'facet/time/stamp'
+
+Techinally this requires a redirection file to the core method itself.
+You can bypass the redirection:
+
+  require 'facets/core/time/stamp'
+
+Although not at all neccessary, if you are using more then a few facets
+it is recommended that before requiring any of them you first require
+the main facility.
+
+  require 'facets'
+
+This loads all the core facets considered "base" (a couple dozen basic methods)
+and add the facets library directories to the end of Ruby's load path. This
+allows you to require facets without the 'facet/...' prefix. Eg.
+
+  require 'string/blank'
+
+A handful of extension sets are also available. For example,
+
+  require 'facet/string_as_array'
+
+adds some methods to Array that make it behave a little more like
+an array of characters. Other useful sets include, 'random' which 
+loads every facet method related to randomness and 'inflect' which
+loads a number of methods for manipulating strings in high-level
+ways, like #camelize and #pluralize.
+
+Using a module, class or microframework is essentially the same. 
+You can use the redirection path. Eg.
+
+  require 'facet/basicobject'
+
+Or do so directly.
+
+  require 'facets/more/basicobject'
+
+Again, if you load the main facility, you can eliminate the need for the 'facet/' prefix.
+
+  require 'facets'
+  require 'basicobject'
+
+Understand that on the off chance that anoth library you are using has the same name as 
+one of Facets' everything will still work fine. You will not be able to use the
+prefixless shorcut to require the facet.
+
+For details pertaining to the functionality of each feature, please see the API Docs.
+
+
+== Notes
+
+=== Directories
+
+There are presently three two subdirs in Facets: 'core', which stores
+the method extensions and 'more' which store the modules, classes and
+micorframeworks.
+
+The layout of Facets' core method files is straightfoward and well organized.
+All individual methods are stored in subdirectories under their effected 
+downcased class' or module's name.
+
+  '<class|module>/<method-name>'
+
+Class method are stored in the same manner but under a 'self' subdirectory.
+
+  'core/<class|module>/self/<method-name>'
+
+=== Method File Names
+
+Operators are stored in the file system using english names. For instance for
+Proc#* is 'proc/op_mul'.
+
+For reference, here is the chart.
+
+     +@   => op_plus_self
+     -@   => op_minus_self
+     +    => op_plus
+     -    => op_minus
+     **   => op_pow
+     *    => op_mul
+     /    => op_div
+     %    => op_mod
+     ~    => op_tilde
+     <=>  => op_cmp
+     <<   => op_lshift
+     >>   => op_rshift
+     <    => op_lt
+     >    => op_gt
+     ===  => op_case_eq
+     ==   => op_equal
+     =~   => op_apply
+     <=   => op_lt_eq
+     >=   => op_gt_eq
+     |    => op_or
+     &    => op_and
+     ^    => op_xor
+     []=  => op_store
+     []   => op_fetch
+
+Facets simply takes the '*' and translates it into a string acceptable
+to all file systems. Also, if a method ends in '=', '?' or '!' it is 
+simply removed.
+
+
+== Contribute
+
+This project thrives on contribution.
+
+If you have any extension methods, classes, modules or microframeworks
+that you think have general applicability and would like to see them 
+included in this project, don't hesitiate to submit. There's a very good
+chance it will be included.  Also, if you have better versions of any thing
+already included or simply have a patch, they too are more than welcome.
+We want Ruby Facets to be of the highest quality.
+
+
+== Authorship
+
+This collection was put together by, and largely written by Thomas Sawyer
+(aka Trans Onoma). He can be reached via email at transfire at gmail.com.
+
+Some parts of this collection were written and/or inspired by other
+persons. Fortunately nearly all were copyrighted under the same open
+license, the Ruby License. In the few excpetions I have included the
+copyright notice with the source code. 
+
+Any code file not specifically labelled shall fall under the Ruby License.
+
+In all cases, I have made every effort to give credit where credit is due. You will find these copyrights, thanks and acknowledgements embedded in the source code, and an unobtrusive
+"Author(s)" section is given in the RDocs.
+
+Main Developers include:
+
+* Thomas Sawyer
+* George Moschovitis
+* Peter Vanbroekhoven
+* Florian Gross
+
+See the AUTHORS file for a list of all other contributing Rubyists.
+
+If anyone is missing from the list, please let me know and 
+I will correct right away. Thanks.
+
+
+== License
+
+In so far as it matters, the collection PER COLLECTION is licensed
+as follows:
+
+  Ruby Facets
+  Copyright (c) 2004-2006 Thomas Sawyer
+  Ruby License
+
+The Ruby license is a dual license that also provides for use of the GPL.
+A copy of both licenses accompany this document (see COPYING).
+
+Credit and Copyrights for particular borrowed code segments are
+given in their respective source. All licenses are either compatible
+with the Ruby lincense (Ruby or GPL) or the original author has given
+permission for inclusion of their code under this lincense.</p>
+
+Any code file not specifically labeled shall fall under the Ruby License.
+
+
+== Pitch
+
+  ALL YOUR BASE ARE BELONG TO RUBY
+
+
+----
+
+[1] A lot of mental anguish went into finding this good project name Ruby Facets.
+    Of course, in the end only one name can take the honor. Other good names
+    which were considered: Calibre, Florida and California, Warchest w/ Atomix,
+    Downs & Ace, Trix & Atomx and even Pillbox & Pills (a _why suggestion).
+    Then the names that almost won out and were used for a good while:
+    Nano Methods and Mega Modules --great names but a little to "fad".
+    Finally let's not forget even older "working" titles that were used
+    along the way: Raspberry, ABC, Succ and the very original Tomslib.
+
+
+# Copyright (c)2006 Thomas Sawyer
+# facets.rubyforge.com
+# (ruby-lang.org) Do you Ruby?

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

@@ -0,0 +1,36 @@
+
+class String
+
+  # Is this string just whitespace?
+  #
+  #   "abc".blank?  #=> false
+  #   "   ".blank?  #=> true
+  #
+  def blank?
+    self !~ /\S/
+  end
+  alias_method :whitespace?, :blank?
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_blank?
+      assert( ! "xyz".blank? )
+      assert( "     ".blank? )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,68 @@
+
+class String
+
+  # Aligns each line n spaces.
+  # (This used to be #taballto.)
+  #
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_tab
+      a = "xyz".tab(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+    def test_tabto
+      a = "xyz".tabto(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+    def test_indent
+      a = "xyz".indent(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,24 @@
+#--
+# Credit goes to  Lucas Carlson and Blaine Cook.
+#++
+
+class String
+
+  def starts_with?(str)
+    self.index( str ) == 0
+  end
+
+  def ends_with?(str)
+    self.rindex( str ) == self.length - str.length
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/masterview/directive_base.rb

@@ -0,0 +1,163 @@
+module MasterView
+
+  class DirectiveBase
+    include PluginLoadTracking
+    include DirectiveHelpers
+
+    # Register a class manually without regard to whether it inherits from DirectiveBase.
+    # Classes which derive from DirectiveBase will automatically be registered as they are
+    # loaded.
+    def self.register_directive(directive_class)
+      self.register_class(directive_class)
+    end
+
+    def initialize(attribute_value)
+      @attribute_value = attribute_value
+    end
+
+    #if this method exists, it will be called by renderer to save directive_call_stack before each method call
+    def save_directive_call_stack(directive_call_stack)
+      @directive_call_stack = directive_call_stack
+    end
+
+    # returns the full attribute name which is the mv_ns prefix + attr_name if that method has been provided, otherwise
+    # it default to the class name (without any module prefix) and it downcases the first letter
+    def self.full_attr_name(namespace_prefix)
+      namespace_prefix + (self.respond_to?(:attr_name) ? self.attr_name : self.name.split(':').last.downcase_first_letter)
+    end
+    
+    #get the directives attribute value string
+    def attr_value
+      @attribute_value
+    end
+
+    #set the directives attribute value string
+    def attr_value=(attribute_value)
+      @attribute_value = attribute_value
+    end
+
+    #get attribute hash from tag
+    def attrs
+      @directive_call_stack.context[:tag].attributes
+    end
+
+    #set attribute hash for tag
+    def attrs=(attributes)
+      @directive_call_stack.context[:tag].attributes = attributes
+    end
+
+    #get attribute hash with lowercased keys and values, and cache it
+    def attrs_lckv
+      @attrs_lckv ||= lowercase_attribute_keys_and_values(attrs)
+    end
+
+    #get attribute hash with lowercased keys (and original values) and cache it
+    def attrs_lck
+      @attrs_lck ||= lowercase_attribute_keys(attrs)
+    end
+
+    #returns true if the value for lckey of the attribute hash with lowercased keys and values
+    #matches (lowercase) lcmatch string
+    def attr_lckv_matches(lckey, lcmatch)
+      (attrs_lckv[lckey] && attrs_lckv[lckey] == lcmatch.downcase) ? true : false
+    end
+
+    #output '<% '+str+' %>'
+    def erb(str)
+      ERB_START + str + ERB_END
+    end
+
+    #output '<%= '+str+' %>
+    def erb_content(str)
+      ERB_EVAL + str + ERB_END
+    end
+    
+    #get tag_name
+    def tag_name
+      @directive_call_stack.context[:tag].tag_name
+    end
+
+    #set tag_name
+    def tag_name=(tag_name)
+      @directive_call_stack.context[:tag].tag_name = tag_name
+    end
+
+    #inside characters, cdata, or comment you can call this to get the characters passed
+    def data
+      @directive_call_stack.context[:content_part]
+    end
+
+    #set the data that will be passed to characters, cdata, or comment directives
+    def data=(data)
+      @directive_call_stack.context[:content_part]=data
+    end
+
+    # rolled up content from all children of the tag, note this will not be complete until hitting the end tag method :etag
+    def content
+      @directive_call_stack.context[:tag].content
+    end
+
+    #return rolled up content from all children as string, note this will not be complete until hitting the end tag method :etag
+    def content_str
+      content = @directive_call_stack.context[:tag].content
+      content = content.join if content.respond_to? :join
+      content
+    end
+
+    # replace the content from all children with a new value
+    def content=(content)
+      @directive_call_stack.context[:tag].content = content
+    end
+
+    #add single quotes around string
+    def quote(str)
+      '\''+str+'\''
+    end
+
+    def remove_strings_from_attr_value!
+      self.attr_value = remove_prepended_strings(attr_value)
+    end
+
+    #prepend string to attribute value adding a comma if attribute value was not empty
+    def prepend_to_attr_value!(str)
+      return attr_value if str.nil? || str.strip.empty?
+      av = str
+      av << ', ' << attr_value unless attr_value.strip.empty?
+      self.attr_value = av
+    end
+
+    #append string to attribute value adding a comma if attribute value was not empty
+    def append_to_attr_value!(str)
+      return attr_value if str.nil? || str.strip.empty?
+      av = attr_value
+      av << ', ' unless av.strip.empty?
+      av << str
+      self.attr_value = av
+    end
+
+    #merge merge_hash into hashes stored in attribute_value string
+    #hash_index is the zero based index of the hash you want to add to
+    def merge_hash_attr_value!(hash_index, merge_hash)
+      self.attr_value = merge_into_embedded_hash(attr_value, hash_index, merge_hash)
+    end
+
+    #calls non-evaling parse to split into string arguments
+    def parse_attr_value
+      parse(attr_value)
+    end
+
+    # check for common html options and return the hash
+    def common_html_options(attrs_lck)
+      options = {}
+      options[:class] = attrs_lck['class'] if attrs_lck['class']
+      options[:style] = attrs_lck['style'] if attrs_lck['style']
+      options[:tabindex] = attrs_lck['tabindex'] if attrs_lck['tabindex']
+      options[:accesskey] = attrs_lck['accesskey'] if attrs_lck['accesskey']
+      options[:disabled] = true if attrs_lck['disabled']
+      options[:readonly] = true if attrs_lck['readonly']
+      options
+    end
+
+  end
+
+end