jig 0.1.0

data/lib/jig/css.rb

@@ -0,0 +1,307 @@
+
+require 'jig'
+
+class Jig
+  # Jig::CSS is a subclass of Jig designed to facilitate the 
+  # construction of CSS rule sets. This class should be considered 
+  # experimental.  The documentation uses C instead Jig::CSS to
+  # simplify the examples.
+  #
+  # An instance of Jig::CSS represents a CSS rule consisting of 
+  # a selector list and an associated declaration block.  The 
+  # selector list or the delcaration block or both may be empty. 
+  # Declarations are specified via a hash.
+  #
+  #   C.new                         # => {}
+  #   C.new('h1')                   # => h1 {}
+  #   C.new(nil, 'color' => 'red')  # => {color: red; }
+  #
+  # A simple CSS type selector with an empty declaration is the 
+  # default construction:
+  #
+  #   C.div                         # => div {}
+  #   C.li                          # => li {}
+  #
+  # Rules can be combined with each other or with a hash via the 
+  # 'pipe' operator.
+  #
+  #   big = { 'font-size' => '24pt' }
+  #   bold = { 'font-weight' => 'bold' }
+  #   big_div = C.div | big                 # => div {font-size: 24pt; }
+  #   big_bold_div = bigger | bold          # => div {font-size: 24pt; font-weight: bold; }
+  #   C.h1 | C.h2                           # => h1, h2 { }
+  #   C.h1 | big | C.h2 | bold              # => h1, h2 { font-size: 24pt; font-weight: bold; }
+  class CSS < Jig
+    module IntegerHelper
+      def in; "#{self}in"; end
+      def cm; "#{self}cm"; end
+      def mm; "#{self}mm"; end
+      def pt; "#{self}pt"; end
+      def pc; "#{self}pc"; end
+      def em; "#{self}em"; end
+      def ex; "#{self}ex"; end
+      def px; "#{self}px"; end
+      def pct; "#{self}%"; end
+    end
+
+    module FloatHelper
+      def pct; "%.2f%%" % (self*100); end
+    end
+
+    Integer.class_eval { include IntegerHelper }
+    Float.class_eval { include FloatHelper }
+
+    Newlines = [:html, :head, :body, :title, :div, :p, :table, :script, :form]
+    Encode = Hash[*%w{& amp " quot > gt < lt}]
+
+    class <<self
+      # Construct a simple type selector based on the method name.
+      #   C.new('div')    # => div {}
+      #   C.div           # => div {}
+      def method_missing(sym, *args)
+        new(sym.to_s, *args)
+      end
+
+      def media(*types)
+        indent = Gap.new(:___) { |text| Jig.new { text.to_s.split("\n").map { |line| "  #{line}" }.join("\n")}  }
+        Jig.new("@media #{types.join(', ')} {\n", indent, "\n}\n")
+      end
+
+      def import(url, *types)
+        Jig.new("@import url(\"#{url}\") #{types.join(', ')}")
+      end
+    end
+
+    # Construct a CSS rule.
+    def initialize(selector='*', declarations=nil)
+      super(selector, :__s, " {", :__ds, to_declarations(declarations),  :__de, "}").freeze
+    end
+
+    def to_declarations(hash)
+      return nil unless hash
+      hash.inject(Jig.null) do |djig, (property, value)| 
+        djig.push(
+          case value
+            when Gap
+              value
+            when Symbol
+              Gap.new(value) { |fill| declaration(property, fill) }
+            else
+              declaration(property, value)
+          end
+        )
+      end
+    end
+
+    # Convert property/value pair for use in a CSS rule jig.
+    # Any underscores in the property are converted to hyphens.
+    # If the property ends in '!', the '!' is stripped and the
+    # declaration is marked with the CSS keyword '!important'.
+    # * If +value+ is nil or false, the empty string is returned.
+    # * If +value+ is a symbol, a declaration gap is returned.
+    # * If +value+ is a gap, the gap is returned.
+    # * If +value+ is a proc, method, or jig, a deferred 
+    #   declaration gap is returned by wrapping the construction 
+    #   in a lambda in a jig.
+    # * If the +value+ is an array, it is converted to a string
+    #   via #join.  If the property is 'font-family', the values
+    #   are joined with a comma, otherwise a space is used.
+    # * Otherwise property and value are converted to strings and
+    #   a CSS declaration string is returned.
+    def declaration(property, value)
+      case value
+      when nil, false
+        ""
+      when Symbol
+        Gap.new(value) { |fill| declaration(property, fill) }
+      when Gap
+        value
+      when Jig
+        Jig.new { declaration(property, value.to_s) }
+      when Proc, Method
+        Jig.new { declaration(property, value.call) }
+      when Array
+        seperator = (property == 'font[-_]family' ? ", " : " ")
+        declaration(property, value.join(seperator))
+      else
+        property.to_s =~ /\A(.*[^!])(!?)\z/
+        property = $1.to_s.tr('_','-')
+        "#{property}: #{value}#{" !important" unless $2.empty?}; "
+      end
+    end
+
+    # Construct a child selector.  The parent is the lhs selector and
+    # the child is the rhs selector.
+    #   div > p     # => "div > p {}"
+    def >(other)
+      before(:__s, " > ", other.selector).before(:__de, other.declarations)
+    end
+
+    # Construct an adjacent sibling selector.  The first sibling is 
+    # the lhs selector and the other sibling is rhs selector.
+    #   h1 + p     # => "h1 + p {}"
+    def +(other)
+      before(:__s, " + ", other.selector).before(:__de, other.declarations)
+    end
+
+    # Construct a general sibling selector.  The first sibling is 
+    # the lhs selector and the other sibling is rhs selector.
+    #   div ~ p     # => "div ~ p {}"
+    def ~(other)
+      before(:__s, "~", other.selector).before(:__de, other.declarations)
+    end
+
+    # Construct an id selector.  The id is the rhs value.
+    #   h1 * 'chapter-one'     # => "h1#chapter-one {}"
+    def *(id)
+      before(:__s, "#", id.to_s)
+    end
+
+    # Construct a pseudo-selector.
+    #   h1/:first_letter      # => "h1:first-letter {}"
+    #   a/:active             # => "a:active {}"
+    def /(pseudo)
+      before(:__s, ":", pseudo.to_s)
+    end
+
+    # Construct a descendent selector.  The parent is the lhs selector and
+    # the descendent is the rhs selector.
+    #   div >> p     # => "div p {}"
+    def >>(other)
+      before(:__s, " ", other.selector).before(:__de, other.declarations)
+    end
+
+    # Construct a negation pseudo class.  The delcarations associated
+    # with the other selector are discarded.
+    #   div - p     # => "div:not(p) {}"
+    def -(other)
+      before(:__s, ":not(", other.selector, ")")
+    end
+
+    # Construct a nth_child pseudo class.
+    def nth_child(a=0,b=0)
+      before(:__s, ":nth-child(#{a}n+#{b})")
+    end
+
+    # Construct a nth_last_child pseudo class.
+    def nth_last_child(a=0,b=0)
+      before(:__s, ":nth-last-child(#{a}n+#{b})")
+    end
+
+    # Construct a nth-of-type pseudo class.
+    def nth_of_type(a=0,b=0)
+      before(:__s, ":nth-of-type(#{a}n+#{b})")
+    end
+
+    # Construct a nth-last-of-type pseudo class.
+    def nth_last_of_type(a=0,b=0)
+      before(:__s, ":nth-last-of-type(#{a}n+#{b})")
+    end
+
+    # Construct a lang pseudo class.
+    def lang(lang)
+      before(:__s, ":lang(#{lang})")
+    end
+
+    # Merge this rule with another object. 
+    # * If the other object is a hash, the hash is converted 
+    #   to a CSS declaration list and merged with the current list. 
+    # * If the other object is a rule, the other selectors and 
+    #   declarations are merged with the current selectors and 
+    #   declarations. 
+    # * Any other object is assumed to be a selector string 
+    #   and is merged with the current selectors.
+    #
+    # C.div.merge(:color => 'red')            # => div { color: red; }
+    # C.div.merge(C.h1)                       # => div, h1 {}
+    # C.div(:color => 'blue').merge(C.h1(:font_size => '10pt'))
+    #                                         # => div, h1 { color: blue; font-size: 10pt }
+    # C.div.merge('h1, h2, h3')               # => div, h1, h2, h3 {}
+    def merge(other)
+      return self unless other
+      case other
+      when Hash
+        before(:__de, to_declarations(other)) 
+      when self.class
+        before(:__s, ", ", other.selector).before(:__de, other.declarations)
+      else
+        before(:__s, ", ", other)
+      end
+    end
+
+    # Returns a standard jig representation of the CSS jig.  Gaps that are
+    # used internally by the CSS class are closed.  #to_jig should be used before
+    # combining one or more CSS jigs.
+    def to_jig
+      Jig.new(plug( :__s => nil, :__de => nil, :__ds => nil ))
+    end
+
+    alias | :merge
+
+    # Extract the selector list from the rule as a jig.
+    #   (div | h1).selector     # => Jig["div, h1"]
+    def selector
+      slice(0...index(:__s))
+    end
+
+    # Extract the declaration list from the rule.  The list is returned as
+    # a jig and not as a hash.
+    #   div(:color => 'red').declarations   # => Jig["color: red; ", :__de]
+    def declarations
+      slice(index(:__ds)+1..index(:__de)-1)
+    end
+
+    # Missing methods are rewritten as calls to #class_, which
+    # constructs class selectors.
+    #   C.div.class_('urgent')        # => div.urgent {}
+    #   C.div.urgent                  # => div.urgent {}
+    #   C.div.note.caution            # => div.note.caution {}
+    def method_missing(sym, declarations=nil)
+      class_(sym, declarations)
+    end
+
+    # Add a class selector to pending selector.  Usually
+    # this method is called indirectly via method_missing.
+    #   C.div.class_('urgent')        # => div.urgent {}
+    #   C.div.urgent                  # => div.urgent {}
+    def class_(klass, declarations=nil)
+      before(:__s, ".#{klass}") | declarations
+    end
+
+    # Construct an attribute selector. If the argument is a
+    # simple string a simple attribute selector is constructed. If
+    # the argument is a hash with a string as the value, an exact
+    # attribute selector is constructed.  If the value is a regular 
+    # expression, a partial attribute selector is constructed. If 
+    # the key is the literal string 'lang', a language attribute 
+    # selector is constructed.
+    #
+    #   input[:type]                # => input[type] {}
+    #   input[:type => 'password']  # => input[type="password"] {}
+    #   input[:lang => 'en']        # => input[lang|="en"] {}
+    #   input[:class => /heading/]  # => input[class=~"heading"] {}
+    def [](*args)
+      if args.size == 1 && args.first.respond_to?(:to_hash) && args.first.size == 1
+        k,v = *args.first.to_a.first
+        case v
+        when String
+          before(:__s, %Q{[#{k}="#{v}"]})
+        when Regexp
+          v = v.to_s.split(':').last.chop    # strip out the processing flags
+          if k.to_s == 'lang'
+            before(:__s, %Q{[lang|="#{v}"]})
+          else
+            before(:__s, %Q{[#{k}~="#{v}"]})
+          end
+        else
+          self
+        end
+      elsif args.size == 1 && args.first.respond_to?(:to_s)
+        before(:__s, "[#{args.first}]")
+      else
+        self
+      end
+    end
+
+  end
+end

data/lib/jig/xhtml.rb

@@ -0,0 +1,283 @@
+require 'jig'
+require 'jig/xml'
+
+class Jig
+  # Jig::XHTML is a subclass of Jig::XML and is designed to assist in the
+  # construction of XHTML documents.
+  class XHTML < XML
+    attr_accessor :extra
+    protected :extra
+
+    def initialize(*args)
+      super
+      @extra = {}
+    end
+
+    def initialize_copy(other)
+      super
+      @extra = other.extra.dup
+    end
+
+    def freeze
+      @extra.freeze
+      super
+    end
+
+    def eid
+      extra[:eid]
+    end
+
+    def eid=(eid)
+      raise RuntimeError, "no eid reassignment permitted" if extra[:eid]
+      extra[:eid] = eid 
+    end
+
+    class <<self
+      # Construct a jig for an XHTML element with _tag as the tag and include
+      # an ID attribute with a guaranteed unique value.
+      # Example:
+      #      puts Jig::XHTML.element_with_id('div')    # <div id="x2354322">\n</div> 
+      def element_with_id(tag, *args)
+        attrs = { 'id' => :id }
+        attrs = attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
+        args.push(Proc.new) if block_given?
+        args.push attrs
+        newjig = element(tag, *args)
+        newjig.eid = "x#{newjig.object_id}"
+        newjig.plug!(:id, newjig.eid )
+      end
+
+      # Construct a jig for an emtpy XHTML element with _tag as the tag and include
+      # an ID attribute with a guaranteed unique value.  The selected id is
+      # accessible via the eid attribute.
+      # Example:
+      #      j = Jig::XHTML.element_with_id('input', :name=>'login')
+      #      puts j          # <input name="login" id="x2354328"/>
+      #      puts j.eid      # x2354328
+      def element_with_id!(tag, *args)
+        attrs = { 'id' => :id }
+        attrs = attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
+        args.push(Proc.new) if block_given?
+        args.push attrs
+        jig = element!(tag, *args)
+        jig.eid = "x#{newjig.object_id}"
+        jig.plug!(:id, jig.eid)
+      end
+
+      # Construct an element based on the method name.  If the method name
+      # ends in '_with_id' or '_with_id!', the element is constructed with
+      # a unique XML id attribute otherwise the Jig::XML element construction
+      # rules apply.
+      def method_missing(sym, *args, &block)
+        text = sym.to_s
+        if text.to_s =~ /_with_id!*$/
+          element_with_id(text.sub(/_with_id!*$/,'').to_sym, *args, &block)
+        else
+          super
+        end
+      end
+
+      DOCTYPES = {
+        :strict, %{"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"},
+        :transitional, %{"-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"},
+        :frameset, %{"-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"}
+      }
+
+      # Construct an XHTML DOCTYPE declaration. The first argument, _dtype_, specifies
+      # the type of document: :strict, :transitional, or :frameset.  Any additional
+      # arguments are rendered after the DOCTYPE declaration.  A default gap is *not*
+      # inserted if their are no arguments. Examples:
+      #
+      #  puts X.doctype(:strict)  
+      #    # => <!DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
+      #  puts X.doctype(:strict).gaps.size    # 0
+      def doctype(dtype, *args, &block)
+        new(%{<!DOCTYPE html PUBLIC #{DOCTYPES.fetch(dtype)}>\n}, *args, &block)
+      end
+
+      # call-seq:
+      #   xhtml([attributes]) -> a_jig
+      #   xhtml(doctype, [attributes]) -> a_jig
+      #   xhtml(doctype, *items, [attributes]) -> a_jig
+      #   xhtml(*items, [attributes]) -> a_jig
+      # Construct a generic XHTML document.  With no arguments, a transitional
+      # document with three gaps, <tt>:title</tt>, <tt>:head</tt>, and <tt>:___</tt>
+      # is generated.  The default gap represents the contents of the body element.
+      #
+      # With a single symbol argument, <i>doctype</i>, an XHTMl document is generated
+      # with a corresponding DOCTYPE declaration (see #doctype).
+      #
+      # If any arguments are provided other than a doctype, the additional arguments
+      # are used as the contents of the HTML element.
+      #
+      # A trailing hash argument is assumed to represent additional XML attributes for
+      # the html element.
+      #   X.xhtml                 # transitional document with :title, :head, and :___
+      #   X.xhtml :strict         # strict document with :title, :head, and :___
+      #   X.xhtml(:strict, head, body)  # strict document with explicit head & body
+      #   X.xhtml(head, body)     # transitional document with explicit head & body
+      #   X.xhtml :lang => 'jp'   # transition document with HTML attributes merged
+      def xhtml(dtype=:transitional, *args, &block)
+         unless Symbol === dtype
+          dtype,args = :transitional,args.unshift(dtype)
+        end
+        attrs = {:lang=>'en', "xml:lang"=>'en', :xmlns=>'http://www.w3.org/1999/xhtml'}
+        attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 
+        args.push(Proc.new) if block_given?
+        args.push(head(title(:title),:head),body) if args.empty?
+        args.push(attrs)
+        doctype(dtype,html(*args))
+      end
+
+      # A convenience method for constructing an XHTML element with a named
+      # CSS class and an unique XHTML element ID.
+      # 
+      #   X.container('span', 'urgent', 'This is urgent!')
+      #      => <span class="urgent" id="x2337852"></span>
+      def container(tag, css, *args)
+        args.push(Proc.new) if block_given?
+        args.push(:class => css)
+        jig = element_with_id(tag, *args)
+        jig.send(:extra)[:css] = css
+        jig
+      end
+
+      # An even shorter way to construct a div container
+      #
+      #   X.divc('urgent', 'This is urgent!')
+      #      => <div class="urgent" id="x2337852"></div>
+      def divc(css_class, *args, &block)
+        container(:div, css_class, *args, &block)
+      end
+
+      # Generate a link element for a favicon. Extra attributes
+      # may be specified via the optional argument, _extra_.
+      #
+      #   X.link_favicon
+      #      => <link src="/favicon.ico" type="image/x-icon" rel="icon"/>
+      def link_favicon(extra={})
+        attrs = {:type=>"image/x-icon", :rel=>"icon", :src=>'/favicon.ico'}
+        attrs.merge! extra
+        link!(attrs)
+      end
+
+      # XXX: is this no longer needed?
+      def normalize_args(args, attrs={}) # :nodoc"
+        attrs.merge!(args.pop) if args.last.respond_to?(:fetch)
+        args.push(Proc.new) if block_given?
+        args.push INNER if args.empty?
+        return args, attrs
+      end
+
+      # Generate a CSS style sheet element. If a 'src' attribute
+      # is provided the contents is empty.  Without a 'src' attribute
+      # a CDATA block wraps the contents of the element.
+      #
+      #   j = Jig::XHTML.style
+      #   puts j.plug('/* CSS style sheet */')
+      #
+      #   <style media="all" type="text/css">
+      #   <![CDATA[
+      #   /* CSS style sheet */
+      #    ]]>
+      #   </style>
+      def style(*args, &block)
+        attrs = {:type=>"text/css", :media=>"all"}
+        attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 
+        args.push(Proc.new) if block_given?
+        if attrs.has_key?(:src)
+          args = [attrs]
+        else
+          args = ["\n", cdata(*args.push("\n")), attrs]
+        end
+        element(:style, *args)
+      end
+
+      def style_link(src)
+        link!('rel' => 'stylesheet', 'type' => 'text/css', 'href' => src)
+      end
+
+      # Generate a script element.  XXX
+      #
+      #   j = Jig::XHTML.script
+      #   puts j.plug(cdata("# the script"))
+      #
+      #   <script type=">
+      #   <![CDATA[
+      #   # the script
+      #    ]]>
+      #   </script>
+      def script(*args, &block)
+        attrs = args.pop if args.last.respond_to?(:fetch) 
+        args.push(Proc.new) if block_given?
+        if attrs.has_key?(:fetch)
+          args = [attrs]
+        else
+          args.push(attrs)
+        end
+        element(:script, *args)
+      end
+
+      def input(*args, &block)
+        element_with_id!(:input, *args, &block)
+      end
+      def textarea(*args, &block)
+        element_with_id(:textarea, *args, &block)
+      end
+      def select(*args, &block)
+        element_with_id(:select, *args, &block)
+      end
+
+      def more(ajig, bjig)
+        body = div_with_id({:style => 'display: none'}, bjig)
+        new(a({:href=>"#", :onclick => "toggle(#{body.eid})"}, '(details)'), body)
+      end
+
+      # Generate a Javascript comment.
+      #
+      #   j = Jig::XHTML.js_comment
+      #   puts j.plug("comment")
+      #
+      #    /* comment */
+      def js_comment(*args, &block)
+        gap = Jig::Gap.new(:comment) { |*filling| 
+          filling.map {|item| 
+            item.to_s.split("\n").map {|line| "// #{line}" }
+          }.join("\n")
+        }
+        new(gap, "\n").plug(:comment, *args)
+      end
+
+      # Generate a multiline Javascript comment.
+      #
+      #   j = Jig::XHTML.js_comments
+      #   puts j.plug("line 1\nline 2")
+      #
+      #    /*
+      #   line 1
+      #   line 2
+      #    */
+      def js_mlcomment(*args, &block)
+        new("/*\n", new(*args, &block), "\n */\n")
+      end
+
+      # Generate an inline script element for javascript.
+      # The body of the script is wrapped in a CDATA block.
+      #
+      #   j = Jig::XHTML.javascript
+      #   puts j.plug("// the script")
+      #
+      #   <script type="text/javascript" language="JavaScript">
+      #   <![CDATA[
+      #   // the script
+      #    ]]>
+      #   </script>
+      def javascript(*args, &block)
+        attrs = {:type=>"text/javascript", :language=>"JavaScript"}
+        attrs.merge!(args.pop) if args.last.respond_to?(:fetch) 
+        args.push(Proc.new) if block_given?
+        script("//<![CDATA[\n", new(*args), "\n//]]>\n", attrs)
+      end
+    end
+  end
+end