iron-web 1.0.0

data/.rspec

@@ -0,0 +1 @@
+--require <%= File.join(File.expand_path(File.dirname(__FILE__)), 'spec', 'spec_helper.rb') %>

data/History.txt

@@ -0,0 +1,8 @@
+== 1.0.0 / 2012-03-02
+
+* Broke out extensions from older irongaze gem
+* Updated Url and Color classes with misc fixes
+* Added Url and Color spec coverage
+* Major Html::Element spec work, basic Html spec coverage
+* Add html_safe support for non-Rails environments
+* Added to GitHub

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Irongaze Consulting LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,91 @@
+= GEM: iron-web
+
+Written by Rob Morris @ Irongaze Consulting LLC (http://irongaze.com)
+
+== DESCRIPTION
+
+A set of classes useful in the generation of HTML content.
+
+== CLASSES
+
+* Url - a url parsing and manipulation class
+
+    >> url = Url.build('/home')
+    >> url.to_s
+    => '/home'
+    >> url.params[:key] = 'some value'
+    >> url.to_s
+    => '/home?key=some+value'
+
+* Color - an RGB/A color manipulation class, useful in generating CSS etc.
+
+    >> rgb('#f00').to_s  # Parse a color string into a Color then render it
+    => '#FF0000'
+    >> rgb('#f00').darken(0.5).to_s  # Darken bright red 50%
+    => '#800000'
+    >> rgb('#f00').blend('#0f0', 0.5).to_s  # Blend pure red and pure green, get medium yellow
+    => "#807F00"
+
+* Html / Html::Element - a builder-syntax HTML generation class set
+
+    >> html = Html.build do |html|
+    >>   html.div(:id => 'primary') {
+    >>     html.h1('Title-town!')
+    >>   }
+    >>   html.div(:id => 'secondary') {|div|
+    >>     div.style = 'text-align: center;'
+    >>     div.text! "My body text..."
+    >>   }
+    >> end
+    >> puts html
+    => <div id="primary">
+    =>   <h1>
+    =>     Title-town!
+    =>   </h1>
+    => </div>
+    => <div id="secondary" style="text-align: center;">
+    =>   My body text...
+    => </div>
+
+== SYNOPSIS
+
+To use:
+
+    require 'iron/web'
+
+Sample usage of all components:
+    
+    Html.build do |html|
+      html.h1('Hello World') {|h1|
+        h1.style = "color: #{rgb('#f00').darken};"
+      }
+      
+      html.hr
+      
+      homepage = Url.parse('http://irongaze.com')
+      homepage.fragment = 'incoming'
+      html.a('Say hello to my log file', :href => homepage)
+    end
+
+Which would result in:
+
+    <h1 style="color: #CC0000;">
+      Hello World
+    </h1>
+    <hr>
+    <a href="http://irongaze.com#incoming">Say hello to my log file</a>
+
+Notice the darkened and correctly formatted CSS color value and the newly fragment-ized url.  
+HTML elements are build by calling their tag name on the Html instance.  Similarly, element
+attributes are added by calling the attribute's name on the element instance, or by simply
+setting them during construction.
+
+== REQUIREMENTS
+
+* iron-extensions gem
+
+== INSTALL
+
+To install, simply run:
+
+    sudo gem install iron-web

data/Version.txt

@@ -0,0 +1 @@
+1.0.0

data/lib/iron/web.rb

@@ -0,0 +1,8 @@
+# Load our dependencies
+require 'iron/extensions'
+
+# Requires all classes
+search_path = File.join(File.expand_path(File.dirname(__FILE__)), '*', '*.rb')
+Dir.glob(search_path) do |path|
+  require path
+end

data/lib/iron/web/color.rb

@@ -0,0 +1,267 @@
+
+# Implements a color (r,g,b + a) with conversion to/from web format (eg #aabbcc), and
+# with a number of utilities to lighten, darken and blend values.
+class Color
+
+  # Basic attributes - holds each channel as 0-255 fixnum
+  attr_reader :r, :g, :b, :a
+
+  # Table for conversion to hex
+  HEXVAL = (('0'..'9').to_a).concat(('A'..'F').to_a).freeze
+  # Default value for #darken, #lighten etc.
+  BRIGHTNESS_DEFAULT = 0.2
+
+  # Construct ourselves from whatever is passed in
+  def initialize(*args)
+    @r = 255
+    @g = 255
+    @b = 255
+    @a = 255
+
+    if args.size.between?(3,4)
+      self.r = args[0]
+      self.g = args[1]
+      self.b = args[2]
+      self.a = args[3] if args[3]
+    else
+      set(*args)
+    end
+  end
+
+  # All-purpose setter - pass in another Color, '#000000', rgb vals... whatever
+  def set(*args)
+    val = Color.parse(*args)
+    unless val.nil?
+      self.r = val.r
+      self.g = val.g
+      self.b = val.b
+      self.a = val.a
+    end
+    self
+  end
+
+  # Test for equality, accepts string vals as well, eg Color.new('aaa') == '#AAAAAA' => true
+  def ==(val)
+    val = Color.parse(val)
+    return false if val.nil?
+    return r == val.r && g == val.g && b == val.b && a == val.a
+  end
+
+  # Setters for individual channels - take 0-255 or '00'-'FF' values
+  def r=(val); @r = from_hex(val); end
+  def g=(val); @g = from_hex(val); end
+  def b=(val); @b = from_hex(val); end
+  def a=(val); @a = from_hex(val); end
+
+  # Assigns a callback lambda to convert symbols into
+  # parse-able values.  Sample usage:
+  #   Color.lookup_callback = lambda {|val| Settings[:site][:colors].get!(val) }
+  #   rgb(:off_white)  # => '#f8f0ee'
+  def self.lookup_callback=(callback)
+    @lookup_callback = callback
+  end
+  
+  # Get the lookup callback, if any
+  def self.lookup_callback
+    @lookup_callback
+  end
+
+  # Attempt to read in a string and parse it into values
+  def self.parse(*args)
+    case args.size
+
+    when 0 then
+      return nil
+
+    when 1 then
+      val = args[0]
+
+      # Trivial parse... :-)
+      return val if val.is_a?(Color)
+
+      # Lookup site settings if symbol
+      if val.is_a?(Symbol)
+        callback = Color.lookup_callback
+        return callback.nil? ? nil : self.parse(callback.call(val))
+      end
+
+      # Single value, assume grayscale
+      return Color.new(val, val, val) if val.is_a?(Fixnum)
+
+      # Assume string
+      str = val.to_s.upcase
+      str = str[/[0-9A-F]{3,8}/] || ''
+      case str.size
+      when 3, 4 then
+        r, g, b, a = str.scan(/[0-9A-F]/)
+      when 6, 8 then
+        r, g, b, a = str.scan(/[0-9A-F]{2}/)
+      else
+        return nil
+      end
+      a = 255 if a.nil?
+
+      return Color.new(r,g,b,a)
+
+    when 3,4 then
+      return Color.new(*args)
+
+    end
+    nil
+  end
+
+  def inspect
+    to_s
+  end
+
+  def to_s(add_hash = true)
+    trans? ? to_rgba(add_hash) : to_rgb(add_hash)
+  end
+
+  def to_rgb(add_hash = true)
+    (add_hash ? '#' : '') + to_hex(r) + to_hex(g) + to_hex(b)
+  end
+
+  def to_rgba(add_hash = true)
+    to_rgb(add_hash) + to_hex(a)
+  end
+
+  def opaque?
+    @a == 255
+  end
+
+  def trans?
+    @a != 255
+  end
+
+  def grayscale?
+    @r == @g && @g == @b
+  end
+
+  # Lighten color by amt
+  def lighten(amt = BRIGHTNESS_DEFAULT)
+    return self if amt <= 0
+    return WHITE if amt >= 1.0
+    val = Color.new(self)
+    val.r += ((255-val.r) * amt).to_i
+    val.g += ((255-val.g) * amt).to_i
+    val.b += ((255-val.b) * amt).to_i
+    val
+  end
+
+  def lighten!(amt = BRIGHTNESS_DEFAULT)
+    set(lighten(amt))
+    self
+  end
+
+  # Darken color by amt
+  def darken(amt = BRIGHTNESS_DEFAULT)
+    return self if amt <= 0
+    return BLACK if amt >= 1.0
+    val = Color.new(self)
+    val.r -= (val.r * amt).to_i
+    val.g -= (val.g * amt).to_i
+    val.b -= (val.b * amt).to_i
+    val
+  end
+
+  def darken!(amt = BRIGHTNESS_DEFAULT)
+    set(darken(amt))
+    self
+  end
+
+  # Go towards middle of brightness scale, based on whether color is dark or light.
+  def contrast(amt = BRIGHTNESS_DEFAULT)
+    dark? ? lighten(amt) : darken(amt)
+  end
+
+  def contrast!(amt = BRIGHTNESS_DEFAULT)
+    set(contrast(amt))
+    self
+  end
+
+  # Convert to grayscale
+  def grayscale
+    Color.new(self.brightness)
+  end
+
+  # Compute our overall brightness, using perception-based weighting, from 0.0 to 1.0
+  def brightness
+    (0.2126 * self.r + 0.7152 * self.g + 0.0722 * self.b)
+  end
+  
+  def dark?
+    brightness < 0.5
+  end
+
+  def light?
+    !dark?
+  end
+
+  def grayscale!
+    set(grayscale)
+    self
+  end
+
+  # Blend to a color amt % towards another color value
+  def blend(other, amt)
+    other = Color.parse(other)
+    return Color.new(self) if amt <= 0 || other.nil?
+    return Color.new(other) if amt >= 1.0
+    val = Color.new(self)
+    val.r += ((other.r - val.r)*amt).to_i
+    val.g += ((other.g - val.g)*amt).to_i
+    val.b += ((other.b - val.b)*amt).to_i
+    val
+  end
+
+  def blend!(other, amt)
+    set(blend(other, amt))
+    self
+  end
+
+  def self.blend(col1, col2, amt)
+    col1 = Color.parse(col1)
+    col2 = Color.parse(col2)
+    col1.blend(col2, amt)
+  end
+
+  def self.average(col1, col2)
+    self.blend(col1, col2, 0.5)
+  end
+
+  protected
+
+  # Convert int to string hex, eg 255 => 'FF'
+  def to_hex(val)
+    HEXVAL[val / 16] + HEXVAL[val % 16]
+  end
+
+  # Convert int or string to int, eg 80 => 80, 'FF' => 255, '7' => 119
+  def from_hex(val)
+    if val.is_a?(String)
+      # Double up if single char form
+      val = val + val if val.size == 1
+      # Convert to integer
+      val = val.hex
+    end
+    # Clamp
+    val = 0 if val < 0
+    val = 255 if val > 255
+    val
+  end
+
+  public
+
+  # Some constants for general use
+  WHITE = Color.new(255,255,255).freeze
+  BLACK = Color.new(0,0,0).freeze
+
+end
+
+# "Global" method for creating Color objects, eg:
+#   new_color = rgb(params[:new_color])
+#   style="border: 1px solid <%= rgb(10,50,80).lighten %>"
+def rgb(*args)
+  Color.parse(*args)
+end

data/lib/iron/web/html.rb

@@ -0,0 +1,150 @@
+require 'iron/web/html/element'
+
+# == Html Creation and Rendering
+#
+# This class, combined with the Html::Element class, provides a DSL for html creation, similar to the XmlBuilder class, but tailored for HTML generation.
+#
+# An Html class instance is an ordered collection of Html::Elements and Strings, that together can be rendered out as HTML.
+#
+# Usage:
+#
+# Html.build do |html|
+#   html.div(:id => 'some-div') {
+#     html.em('HTML is neat!')
+#   }
+# end
+class Html
+
+  # Constants
+  HTML_ESCAPE = {"&"=>"&amp;", ">"=>"&gt;", "<"=>"&lt;", "\""=>"&quot;"}.freeze
+
+  # Remove everything that would normally come from Object and Kernel etc. so our keys can be anything
+  instance_methods.each do |m| 
+    keepers = [] #['inspect']
+    undef_method m if m =~ /^[a-z]+[0-9]?$/ && !keepers.include?(m)
+  end
+
+  # So we can behave as a collection
+  include Enumerable
+  undef_method :select  #This is an HTML tag, dammit
+
+  # Primary entry point for HTML generation using these tools.
+  def self.build
+    builder = Html.new
+    yield builder if block_given?
+    builder.render.html_safe
+  end
+
+  # Ripped from Rails...
+  def self.escape_once(html)
+    return html if html.html_safe?
+    html.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |special| HTML_ESCAPE[special] }.html_safe
+  end
+  
+  # Sets up internal state, natch, and accepts a block that customizes the resulting object.
+  def initialize
+    @items = []
+    @item_stack = []
+    yield self if block_given?
+  end
+  
+  # Inserts an HTML comment (eg <!-- yo -->)
+  def comment!(str)
+    if str.include? "\n"
+      text! "<!--\n#{str}\n-->\n"
+    else
+      text! "<!-- #{str} -->\n"
+    end
+  end
+  
+  # Inserts raw text
+  def text!(str)
+    self << str
+  end
+  
+  # Allow pushing new elements
+  def <<(new_item)
+    if @item_stack.empty?
+      @items << new_item
+    else
+      @item_stack.last.html << new_item
+    end
+    self
+  end
+  
+  # Implement enumerable
+  def each
+    @items.each {|v| yield v} if block_given?
+  end
+  
+  def count
+    @items.count
+  end
+
+  def empty?
+    @items.empty?
+  end
+  
+  def blank?
+    empty?
+  end
+  
+  # Create a new element explicitly
+  def tag(tag, *args, &block)
+    item = Html::Element.new(tag, *args)
+    self << item
+    if block
+      @item_stack.push item
+      block.call(item) 
+      @item_stack.pop
+    end
+    return self
+  end
+
+  # Creates a new element on any method missing calls.
+  # Returns self, so you can chain calls (eg html.div('foo').span('bar') )
+  def method_missing(method, *args, &block)
+    parts = method.to_s.match(/^([a-z]+[0-9]?)$/)
+    if parts
+      # Assume it's a new element, create the tag
+      tag(parts[1], *args, &block)
+    else
+      # There really is no method...
+      super
+    end
+  end
+
+  # Renders out as html - accepts depth param to indicate level of indentation
+  def render(depth = 0, inblock = true)
+    # Convert elements to strings
+    @items.collect do |item|
+      if item.is_a?(String)
+        if inblock
+          inblock = false
+          '  '*depth + item
+        else
+          item
+        end
+      elsif item.nil?
+        ''
+      else
+        item.render(depth,inblock)
+      end
+    end.join('')
+  end
+
+  # Alias for #render
+  def to_s
+    render
+  end
+
+  # Alias for #render
+  def inspect
+    render
+  end
+
+  def is_a?(other)
+    return other == Html
+  end
+
+end