iron-web 1.0.0

data/lib/iron/web/html/element.rb

@@ -0,0 +1,154 @@
+
+# = HTML Element Class
+#
+# Used with the Html class to generate html content for a single tag/element.  Represents
+# a single element with attributes and optional contents (including other elements).  Generally, you
+# won't use this by itself.  Check out Html.build() instead.
+# 
+# Simple useage:
+#   >> Html::Element.new('span','some text', :id => 'title-text').render
+#   => '<span id="title-text">some text</span>'
+#
+# Complex usage:
+#   span = Html::Element.new('span')   # Creates a span element for customization
+#   span.id = 'title-text'       # Set some attributes
+#   span.style = 'color: #f00;'
+#   span.html = 'some text'      # Adds some content
+#   span.render                  # Converts to html string
+#   => '<span id="title-text" style="color: #f00;">some text</span>
+#
+class Html
+  class Element
+    # Add back in our accessors
+    attr_accessor :tag, :attrs
+
+    # Commonly empty tags
+    SINGLETON_SET = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source'].freeze
+    # Inline formatting tags
+    INLINE_SET = ['a','abbr','b','button','em','i','input','img','label','li','option','span','strong','title','textarea','u'].freeze
+    # Attributes that should render even if blank
+    BLANK_ATTRS = ['value','alt'].freeze
+
+    # One-stop shop for building content
+    def self.build(*args)
+      el = self.new(*args)
+      yield el if block_given?
+      el.render
+    end
+
+    def initialize(tag, text=nil, attrs={})
+      @tag = tag.to_s
+      @force_end = !SINGLETON_SET.include?(@tag)
+      @skip_newline = INLINE_SET.include?(@tag)
+
+      if text.is_a?(Hash)
+        @attrs = text
+        text = nil
+      else
+        @attrs = attrs || {}
+      end
+
+      if text.is_a?(String)
+        html << ((!text.respond_to?(:html_safe?) || !text.html_safe?) ? Html.escape_once(text) : text)
+      elsif text.is_a?(Html::Element)
+        html << text
+      elsif text.is_a?(Html)
+        @html = text
+      end
+
+      yield self if block_given?
+    
+      self
+    end
+
+    def force_end!
+      @force_end = true
+    end
+
+    def skip_newline!
+      @skip_newline = true
+    end
+
+    def html
+      @html ||= Html.new
+      @html
+    end
+
+    def html=(arg)
+      if arg.is_a? String
+        @html = Html.new
+        @html.text! arg
+      elsif arg.is_a?(Html)
+        @html = arg
+      elsif arg.is_a?(Array)
+        @html = Html.new
+        arg.each do |el|
+          @html << el
+        end
+      else
+        raise 'Invalid input'
+      end
+    end
+
+    # Set/get attrs on any method missing calls
+    def method_missing(method, *args)
+      parts = method.to_s.match(/^([a-z0-9_]+)(=?)$/i)
+      if parts
+        key = parts[1].to_sym
+        if parts[2] && args.length == 1
+          # We have an attempt to set a missing field...
+          @attrs[key] = args[0]
+          return args[0]
+        else
+          raise "I think you meant <#{@tag}>.html.#{method} instead of <#{@tag}>.#{method}" if block_given?
+          return @attrs[key]
+        end
+      else
+        # There really is no method...
+        super
+      end
+    end
+
+    def to_s
+      render
+    end
+
+    def inspect
+      render
+    end
+
+    def is_a?(other)
+      return other == Html::Element
+    end
+
+    def render(depth = 0, inblock = false)
+      # Convert attrs to strings
+      attrStr = @attrs.collect do |k,v|
+        if v.nil?
+          nil
+        elsif v.blank? && ! BLANK_ATTRS.include?(k.to_s)
+          " #{k}"
+        else
+          v = Html.escape_once(v) unless v.html_safe?
+          " #{k}=\"#{v}\""
+        end
+      end.compact.join('')
+
+      # Build start tag
+      val = ''
+      val += "\n" if !inblock && !@skip_newline
+      val += '  ' * depth unless !inblock && @skip_newline
+      val += "<#{@tag}#{attrStr}>"
+      unless @html.nil?
+        val += "\n" unless @skip_newline
+        val += @html.render(depth+1, !@skip_newline)
+        val += "\n" unless @skip_newline || val.ends_with?("\n")
+        val += '  ' * depth unless @skip_newline
+      end
+      val += "</#{@tag}>" if (@force_end || !@html.blank?)
+      val += "\n" unless @skip_newline
+      val
+    end
+
+  end
+end

data/lib/iron/web/string.rb

@@ -0,0 +1,60 @@
+# Only add these changes if we're NOT running Rails
+unless ''.respond_to?(:html_safe)
+
+# Add Rails-like html safeness awareness to objects
+class Object
+  
+  def html_safe?
+    false
+  end
+
+end
+
+# Add Rails-like html safeness awareness to strings
+class String
+  
+  # Return a copy of the string marked as being html safe (ie not requiring further encoding)
+  def html_safe
+    HtmlSafeString.new(self)
+  end
+  
+end
+
+# Simple class that extends strings to do html escapes on incoming concats, only defined
+# if not running under Rails
+class HtmlSafeString < String
+
+  def initialize(*args)
+    @html_safe = true
+    super
+  end
+  
+  def html_safe?
+    @html_safe
+  end
+  
+  def html_safe
+    self
+  end
+
+  # The magic - escape values that are concatenated onto this string
+  # before concatenation.
+  def concat(value)
+    if !html_safe? || value.html_safe?
+      super(value)
+    else
+      super(Html.escape_once(value))
+    end
+  end
+  
+  def +(other)
+    dup.concat(other)
+  end
+  
+  def <<(value)
+    concat(value)
+  end
+
+end
+
+end

data/lib/iron/web/url.rb

@@ -0,0 +1,228 @@
+require 'cgi'
+
+class Url
+
+  attr_accessor :scheme, :server, :port, :path, :params, :fragment
+
+  SECURE_SCHEMES = ['https', 'sftp', 'ssh'].freeze
+  SECURE_SCHEME_MAPPING = { 'http' => 'https', 'ftp' => 'sftp' }.freeze
+  SCHEME_DEFAULT_PORTS = {
+    'ftp' => 21,
+    'ssh' => 22,
+    'smtp' => 25,
+    'http' => 80,
+    'pop3' => 110,
+    'pop' => 110,
+    'sftp' => 115,
+    'imap' => 143,
+    'https' => 443,
+    'ssl' => 443,
+    'irc' => 531,
+    'imaps' => 993,
+    'pop3s' => 995,
+    'pops' => 995
+  }.freeze
+  
+  # Returns a new Url from the given string
+  def self.parse(str)
+    Url.new(str)
+  end
+
+  # Return default domain for urls, used
+  # to convert relative urls to absolute
+  def self.default_server
+    @default_server
+  end
+  
+  def self.default_server=(server)
+    @default_server = server
+  end
+
+  def self.default_scheme
+    @default_scheme || 'http'
+  end
+  
+  def self.default_scheme=(scheme)
+    @default_scheme = scheme
+  end
+
+  # Construct a full URL from pieces
+  def self.build(base, params = {}, fragment = nil)
+    url = base + to_param_string(params)
+    url += '#' + fragment unless fragment.blank?
+    url
+  end
+
+  # Construct a param string from key/value pairs
+  def self.to_param_string(params)
+    str = ''
+    # Remove blank/nil keys                                                                                                                  
+    params.delete_if {|k,v| v.to_s.blank? || k.to_s.blank?}
+    # Convert to param string                                                                                                                
+    unless params.empty?
+      str += '?'
+      str += params.collect do |k,v|
+        if v.is_a?(Array)
+          v.collect do |vs|
+            val = vs.respond_to?(:to_param) ? vs.to_param : vs
+            val = val.to_s
+            CGI::escape(k.to_s) + '=' + CGI::escape(val)
+          end
+        else
+          val = v.respond_to?(:to_param) ? v.to_param : v
+          val = val.to_s
+          CGI::escape(k.to_s) + '=' + CGI::escape(val)
+        end
+      end.flatten.join('&')
+    end
+    str
+  end
+
+  def initialize(str = nil)
+    @scheme = @port = @server = nil
+    set(str)
+  end
+  
+  # Parse and set internals from given url
+  def set(url)
+    # Decompose into major components
+    url = (url || '').strip
+    base, params, @fragment = url.extract(/^([^\?#]*)\??([^#]*)#?(.*)$/)
+    
+    # Parse out base
+    base ||= ''
+    if base.match(/^[a-z\+]*:\/\//)
+      @scheme, @server, ignore, @port, @path = base.extract(/^([a-z]*):\/\/([a-z0-9\-_\.]+)(:([0-9]+))?(\/.*)?/i)
+      @path ||= ''
+      @port = @port.blank? ? nil : @port.to_i
+    else
+      @path = base
+    end
+    
+    # Parse out params
+    @params = {}
+    params.split('&').each do |p|
+      k, v = p.split('=')
+      add_param(CGI::unescape(k), CGI::unescape(v)) if k && v
+    end
+  end
+
+  # Makee the url
+  def to_s
+    Url::build(base, @params, @fragment)
+  end
+  
+  def to_html
+    to_s
+  end
+
+  def inspect
+    to_s
+  end
+
+  def empty?
+    blank?
+  end
+
+  def blank?
+    self.base.blank?
+  end
+
+  # Returns the full start of the url, minus params and fragment
+  def base
+    val = ''
+    unless @server.blank?
+      val = (@scheme || Url::default_scheme) + '://' + @server
+      val += ':' + @port.to_s unless @port.to_s.blank?
+    end
+    p = (@path || '')
+    p = '/' + p unless p.blank? || p.starts_with?('/')
+    val + p 
+  end
+
+  def append_path(str, escape = false)
+    str = str.to_s
+    @path ||= ''
+    @path += escape ? CGI::escape(str).gsub('+', '%20') : str
+  end
+
+  def +(str)
+    append_path(str)
+    self
+  end
+
+  # Override current param val or set if none
+  def set_param(k, v)
+    @params[k] = v
+  end
+
+  # Add a param value (can be called multiply for the same param key)
+  def add_param(k, v)
+    oldval = @params[k]
+    if oldval
+      @params[k] = oldval.is_a?(Array) ? oldval + [v] :  [oldval, v]
+    else
+      @params[k] = v
+    end
+  end
+
+  # Wipe out keyed value by string match or regex match
+  def remove_param(key_or_regex)
+    @params.delete_if do |k, v|
+      if key_or_regex.is_a?(Regexp)
+        k.match(key_or_regex)
+      else
+        k == key_or_regex
+      end
+    end
+  end
+
+  # Reset params
+  def clear_params
+    @params = {}
+  end
+  def reset_params ; clear_params ; end
+  
+  def has_params?
+    @params && !@params.empty?
+  end
+
+  def secure?
+    SECURE_SCHEMES.include?(scheme)
+  end
+  
+  def relative?
+    @server.blank?
+  end
+
+  def absolute?
+    !relative?
+  end
+
+  # Ensure url contains a server + scheme section, eg converts '/foo' into 'http://example.com/foo'.
+  def make_absolute(secure = false)
+    unless absolute? && secure? == secure
+      raise 'No default server in Url#make_absolute' unless @server || Url.default_server
+      @server = Url.default_server unless @server
+      unless @scheme
+        @scheme = Url.default_scheme 
+        @port = nil
+      end
+      if secure
+        raise "No secure scheme for scheme #{@scheme} in Url#make_absolute" unless SECURE_SCHEME_MAPPING[@scheme]
+        @scheme = SECURE_SCHEME_MAPPING[@scheme]
+      end
+    end
+    to_s
+  end
+
+  def make_relative
+    unless relative?
+      @server = nil
+      @scheme = nil
+      @port = nil
+    end
+    to_s
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# Require our library
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'iron', 'web'))
+
+RSpec.configure do |config|
+  #config.add_formatter 'documentation'
+  config.color = true
+  config.backtrace_clean_patterns = [/rspec/]
+end
+