cml 1.4.2

data/lib/cml/tag.rb

@@ -0,0 +1,308 @@
+require 'cgi'
+
+module CML
+  class Tag
+    attr_reader :attrs, :tag, :data, :cml, :opts
+    #liquid_methods :raw_label
+    
+    def initialize(cml, opts = {})
+      @cml = cml.is_a?(String) ? Parser.parse(cml).at("/root/*") : cml
+      @attrs = @cml.attributes#Hash[*cml.attributes.map {|k,v| [k.intern,v]}.flatten]
+      @tag = @cml.name
+      @opts = opts
+    end
+    
+    #This is convoluted as fuck
+    def prefix(name)
+      if @opts[:iteration] 
+        m = case @tag
+          when "checkbox": "[{{i}}][]"
+          when "radio":  "[{{i}}]"
+          when "rating": @opts[:normalize] ? "[{{i}}][]" : "[{{i}}]"
+          when "text", "textarea": @opts[:normalize] ? "[{{i}}][]" : "[]"
+          else
+            "[]"
+          end
+      elsif multi_type.to_s =~ /list$/
+        m = "[]"
+      else
+        m = @opts[:normalize] ? "[]" : ""
+      end
+      @opts[:prefix] ? "#{@opts[:prefix]}[#{name}]#{m}" : name
+    end
+    
+    def name(auto_gold = true, suffix="")
+      name = (@attrs["name"] || @attrs["label"]).to_s.downcase.gsub(/\s/,"_").gsub(/\W/,"")
+      name += ("_" + suffix) unless suffix.size == 0
+      if auto_gold && @opts[:normalize]        
+        if g = @opts[:parser].golds[name]
+          name = g
+        else
+          #This kinda sucks...
+          name = "#{name}_gold" unless name =~ /_gold$/ || name.empty?
+        end
+      end
+      #This really sucks
+      name = name.sub(/_gold$/,"") unless auto_gold
+      #this underscoring multi_type bullshit needs to go way
+      name + (multi_type.to_s =~ /column/ && !(name =~ /_1$/) ? "_1" : "")
+    end
+    
+    #:column means a new column in the result csv, does this by adding _1 to the name
+    #:list means an array of values in the result csv
+    #:columnlist means a new column that is a list
+    def multi_type
+      grouped = @cml.xpath("ancestor::cml:*[@multiple]")
+      if @attrs["multiple"] || !grouped.empty?
+        if @cml.at(".//cml:checkboxes|.//cml:radios|.//cml:ratings")
+          :column
+        elsif !grouped.empty?
+          if grouped.length > 1
+            :columnlist 
+          elsif grouped.detect {|g| g.at(".//cml:checkboxes|.//cml:radios|.//cml:ratings") }
+            @attrs["multiple"] ? :columnlist : :column            
+          else
+            :list
+          end
+        else
+          :list
+        end
+      else
+        nil
+      end
+    end
+    
+    def gold?
+      @attrs["gold"] ? @cml : @cml.at("./cml:gold")
+    end
+    
+    def iterating?
+      @cml.at_xpath("ancestor::cml:iterate")
+    end
+    
+    def gold=(opts = {})
+      cur = gold?
+      advanced = ["strict", "regex"].any? {|k| opts && opts[k] }
+      if !cur
+        cur = advanced ? @cml.add_child(Parser.parse("<cml:gold/>").at("/root/*")) : @cml
+      end
+          
+      if cur.name == "gold"
+        if !opts
+          cur.remove
+        elsif advanced
+          opts.each do |k,v|
+            cur[k] = v.to_s if v
+          end
+        else
+          cur.remove
+          cur = @cml
+        end
+      end
+            
+      if cur.name != "gold"
+        if !opts
+          @cml.remove_attribute("gold")
+        elsif opts["src"] && opts["src"] != "#{name}_gold"
+          @cml["gold"] = opts["src"]
+        else
+          @cml["gold"] = "true"
+        end 
+      end
+    end
+    
+    def wrapper_classes
+      extras = []
+      extras << "logic-only-if:#{@attrs["only-if"]}" if @attrs["only-if"]
+      extras << "matcher:#{@attrs["matcher"]}" if @attrs["matcher"]
+      extras += ["multiple",multi_type] if @attrs["multiple"]
+      extras << "cml_field" unless ["group","iterate"].include?(@tag)
+      extras << @attrs["class"].to_s if @attrs["class"]
+      "#{@tag.gsub(/_/," ")} #{extras.join(" ")}".strip
+    end
+    
+    def children
+      false
+    end
+    
+    def classes
+      @classes ||= [name] << validations << @attrs["class"].to_s.split(/ /)
+      @classes << "cml_data_preloaded" if @opts[:show_data] && @opts[:data][name]
+      @classes.uniq.reject {|c| c.length == 0 }.join(" ").strip
+    end
+    
+    def convert(opts = nil)
+      @opts = @opts.merge(opts) if opts
+      html = to_html
+      
+      html.strip.length == 0 ? Nokogiri::XML::Text.new(html, @cml.document) : Nokogiri::HTML.fragment(html)
+    end
+    
+    def to_html
+      template = @opts[:bare] ? self.class::BareTemplate : self.class::Template
+      #Add a hidden element if this is a checkbox inside an iteration
+      #if @tag == "checkbox" && @opts[:iteration]
+      #  hidden = CML::Tags::Hidden.new("<cml:hidden name=\"#{name}\" value=\"\"/>", @opts).to_html
+      #else
+      #  hidden = ""
+      #end
+      wrapper(Liquid::Template.parse(template).render(data, [LiquidFilters]))
+    end
+
+    def to_s
+      @cml.to_s
+    end
+    
+    def raw_label
+      label = @attrs["label"] ? @attrs["label"].to_s : nil
+      label = cml.inner_text if label.nil? && @tag == "option"
+      label ||= (@attrs["name"] || "").to_s.capitalize
+    end
+    
+    def label(tag = "label")
+      required = " <span class=\"required\">(required)</span>" if validations.include?("required")
+      raw_label == "" ? "" : "<#{tag} class=\"legend\">#{raw_label}#{required}</#{tag.split(" ")[0]}>"
+    end
+    
+    def legend
+      label("h2")
+    end
+    
+    def to_liquid
+      LiquidHash[
+        "to_s" => to_html,
+        "raw_label" => raw_label.to_s
+      ]
+    end
+    
+    def gold_reason
+      return "" unless @opts[:normalize] && !name.empty? && @opts[:no_reason].nil? && !["iterate", "group"].include?(@tag)
+      reason_name = @opts[:iteration] ? prefix(name+"_reason").sub(/\[\{\{i\}\}\]/,"") : prefix(name+"_reason").sub(/\[\]/,"")
+      <<-HTML
+<div class="cml_gold_reason">
+  <label class="legend">Reason</label>
+  <textarea name="#{reason_name}">#{Array((@opts[:data] || {})[name+"_reason"])[@opts[:iteration].to_i]}</textarea>
+</div>
+      HTML
+    end
+    
+    def validators
+      @validators ||= @attrs["validates"].to_s.split(/ /)
+    end
+    
+    def validations
+      @validations ||= validators.map {|v| "validates-#{v}"}
+    end
+    
+    def instructions
+      @instructions ||= @attrs["instructions"] || (@cml.at("./cml:instructions") ? @cml.at("./cml:instructions").inner_html : nil)
+      @instructions ? "<p class=\"instructions\">#{@instructions}</p>\n#{gold_reason}" : gold_reason
+    end
+    
+    def validate?
+      true
+    end
+    
+    def cacheable?
+      !(@opts[:normalize] || @opts[:show_data] || @opts[:no_memoize] || @opts[:missed])
+    end
+    
+    #Check if the provided value contains a liquid variable
+    #If have a variable, data, and are not cachable return the resolved data
+    def ensure_resolved(value)
+      variable = value[/\{\{\s*([\w-]+)/, 1]
+      res = variable && @opts[:data] && !cacheable? ? @opts[:data][variable] : value
+      #Don't resolve arrays as this would suck
+      res.is_a?(Array) ? value : res
+    end
+    
+    def wrapper(parsed, tag = "div")
+      #Deal with a label only wrapper... kinda jank
+      if tag == "label" && instructions
+        tag = "div"
+        parsed = "<label>#{parsed}</label>"
+      end
+      #Inserting instructions here makes it a non-variable input maybe...
+      style = @attrs["style"] ? "style=\"#{@attrs["style"]}\"" : ""
+      
+      data_attrs = data_attributes_string || ""
+      
+      "<#{tag} class=\"#{wrapper_classes}\" #{style} #{data_attrs}>#{parsed}#{instructions}</#{tag}>"
+    end
+    
+    def value
+      ensure_resolved(@attrs["value"].to_s)
+    end
+    
+    def preloaded_data
+      @opts[:show_data] && @opts[:data][name]
+    end
+    
+    def gold_class
+      if @opts[:missed]
+        if @opts[:missed][name]
+          bad = Array(@opts[:missed][name][0])
+          good = Array(@opts[:missed][name][1])
+          if bad.include?(value)
+            return "gold_bad"
+          elsif good.include?(value)
+            return "gold_good"
+          end
+        end
+      end
+      ""
+    end
+    
+    def data
+      (@opts[:data] || {}).merge({
+        "name" => prefix(name), 
+        "label" => label,
+        "legend" => legend,
+        "classes" => classes,
+        "value" => value,
+        "gold_class" => gold_class 
+      })
+    end
+    
+    protected
+    
+    def data_attributes
+      data_attrs = {}
+      @attrs.each do |key, value|
+        if key =~ /^data-/
+          data_attrs[key] = value
+        end
+      end
+      data_attrs.empty? ? nil : data_attrs
+    end
+    
+    def data_attributes_string
+      return "" unless data_attrs = data_attributes
+      attributes = []
+      data_attrs.each do |key, attribute|
+        name = attribute.name
+        value = attribute.value
+        
+        attributes << "#{name}=\"#{CGI.escapeHTML( value )}\""
+      end
+      
+      attributes.join(" ")
+    end
+    
+    #memoize hotness
+    def self.memoize(*methods)
+      methods.each do |m|
+        class_eval %Q{
+          alias :original_#{m} :#{m}
+          
+          def #{m}(*args)
+            @#{m}_cache ||= {}
+            key = {:prefix => @opts[:prefix], :missed => @opts[:missed]}.merge(:_args => args)
+            return @#{m}_cache[key] if @#{m}_cache[key]
+            @#{m}_cache[key] = send(:original_#{m}, *args)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/cml/tags/checkbox.rb

@@ -0,0 +1,77 @@
+module CML
+  module Tags
+    class Checkbox < Tag
+      BareTemplate = <<-HTML.freeze
+{{default}}
+<input name="{{name}}" type="checkbox" value="{{value}}" class="{{classes}}" {{checked}}/>
+      HTML
+      
+      Template = <<-HTML.freeze
+{{default_normalized}}<div class="cml_row"><label class="{{gold_class}}">#{BareTemplate} {{label}}</label></div>
+      HTML
+      
+      def prefix(name)
+        #Don't add another bracket if it's already a list...
+        name = super(name)
+        name + (name !~ /\[\]$/ && grouped? ? "[]" : "")
+      end
+      
+      def grouped?
+        @opts[:bare] || (@cml.parent && @cml.parent.name == "checkboxes")
+      end
+      
+      def wrapper(parsed)
+        grouped? || @opts[:no_reason] ? parsed : super
+      end
+      
+      def value
+        value = (@attrs["value"] || (grouped? ? @attrs["label"] : "true")).to_s
+        ensure_resolved(value)
+      end
+      
+      def classes
+        super+(@checked ? " cml_gold_loaded" : "")
+      end
+      
+      def checked
+        manipulated = !@opts[:missed].nil?
+        if @opts[:data] && @opts[:normalize]
+          manipulated = true
+          seeds = Array(@opts[:data][@opts[:parser].golds[name(false)]] || @opts[:data][name(false)]).map {|s| s.is_a?(Array) ? s.map {|t| t.to_s.downcase } : s.to_s.downcase }
+          seeds = @opts[:iteration] ? [seeds[@opts[:iteration]]].flatten : seeds
+          if seeds.compact.empty?
+            manipulated = false
+          elsif seeds.include?(value.to_s.downcase)
+            @checked = true
+            return "checked=\"checked\""
+          end
+        elsif preload = preloaded_data
+          manipulated = true
+          if preload.map{|x| x.to_s.downcase }.include?(value.to_s.downcase)
+            return "checked=\"checked\""
+          end
+        end
+        !manipulated && @attrs["checked"] ? "checked=\"checked\"" : ""
+      end
+      
+      def data
+        default = ""
+        default_normalized = ""
+        if @attrs["default"]
+          if @opts[:normalize]
+            default_normalized = Checkbox.new("<cml:checkbox label=\"Default value: #{@attrs["default"]}\" name=\"#{name(false)}\" value=\"#{@attrs["default"]}\"/>", @opts.merge(:no_reason => true, :normalize => true)).to_html
+          else
+            default = Hidden.new("<cml:hidden name=\"#{name(false)}\" value=\"#{@attrs["default"]}\"/>", @opts.merge(:grouped => grouped?,  :no_field_wrap => true)).to_html
+          end
+        end
+        #be sure to set the instance variable ahead of time
+        c = checked
+        super.merge({ 
+          "default" => default, 
+          "default_normalized" => default_normalized,
+          "checked" => c,
+          "label" => @attrs["label"].to_s})
+      end
+    end
+  end
+end

data/lib/cml/tags/checkboxes.rb

@@ -0,0 +1,38 @@
+module CML
+  module Tags
+    class Checkboxes < Tag
+      Template = <<-HTML.freeze
+{{legend}}
+  {{content}}
+      HTML
+      
+      def data
+        #Don't memoize individual checkboxes if we are normalizing
+        super.merge({"content" => content(@opts[:normalize] ? @opts[:iteration] : nil) })
+      end
+      
+      def content(*args)
+        cloned= @cml.dup
+        c = children
+        cloned.xpath(".//cml:*[not(self::cml:checkbox)]").remove
+        #re-merge opts to get iterations...
+        cloned.xpath(".//cml:checkbox").each_with_index do |r,i|
+          r.namespace = nil
+          r.replace(c[i].convert(@opts))
+        end
+        #Removal of the root tag
+        html = cloned.to_xhtml.gsub(/<\/?cml:checkboxes[^>]*?>|<\/?>/,'')
+      end
+      memoize :content
+      
+      def children
+        @cml.xpath(".//cml:checkbox").map do |c|
+          c["name"] ||= name(false)
+          c["validates"] ||= @attrs["validates"].to_s
+          Checkbox.new(c, @opts)
+        end
+      end
+      memoize :children
+    end
+  end
+end

data/lib/cml/tags/group.rb

@@ -0,0 +1,25 @@
+module CML
+  module Tags
+    class Group < Tag
+      Template = <<-HTML.freeze
+{{label}}
+  {{content}}
+      HTML
+      
+      def validate?
+        false
+      end
+      
+      def children
+        Parser.new(@cml.children.to_xml, @opts.merge(:no_wrap => true)).tags
+      end
+      memoize :children
+      
+      def data
+        #this is dangerous because of seg faults...
+        super.merge({"content" => Parser.new(@cml, @opts.merge(:no_wrap => true)).to_html})
+      end
+      memoize :data
+    end
+  end
+end

data/lib/cml/tags/hidden.rb

@@ -0,0 +1,17 @@
+module CML
+  module Tags
+    class Hidden < Tag
+      Template = <<-HTML.freeze
+<input name="{{name}}" type="hidden" value="{{value}}" class="{{classes}}"/>
+      HTML
+      
+      def prefix(name)
+        super(name) + (@opts[:grouped] ? "[]" : "")
+      end
+      
+      def wrapper(parsed)
+        @opts[:no_field_wrap] ? parsed : super
+      end
+    end
+  end
+end

data/lib/cml/tags/iterate.rb

@@ -0,0 +1,86 @@
+module CML
+  module Tags
+    class Iterate < Tag
+      Template = <<-HTML.freeze
+  {{ content }}
+      HTML
+      
+      def validate?
+        false
+      end
+      
+      def children
+        #Only take the first children because that's how she likes it
+        parser.tags
+      end
+      
+      def wrapper_classes
+        (super + " " + @attrs["class"].to_s).strip
+      end
+            
+      def data
+        #this is dangerous because of seg faults...
+        super.merge({
+          "content" => content
+        })
+      end
+      
+      def columns
+        @opts[:data].select {|k,v| v.is_a?(Array)}.map {|a| a[0]} rescue []
+      end
+      
+      private
+      
+      #This sure is ugly
+      def content
+        reproduce.map!.with_index do |html,i|
+          h = "<div class=\"cml_nugget\">#{html.dup}</div>"
+          columns.each {|c| h.gsub!(/\{\{\s*#{c}\s*[^\[]/, "{{ #{c}[#{i}] }") }
+          h.gsub!(/\{\{i\}\}/, i.to_s)
+          #Nested gold hotness
+          if key = @opts[:parser].golds.keys.detect {|k| k =~ /structured$/ }
+            reason_key = key[1..-12]+"_reason"
+          end
+          reasons = @opts[:data][reason_key]
+          missed = @opts[:missed] && @opts[:missed]["structured"] && @opts[:missed]["structured"][i] && !@opts[:missed]["structured"][i].empty?
+          
+          if missed && reasons.is_a?(Array) && reasons.length > 1 && reasons[i].to_s.strip.length > 1
+            h + "<div class=\"reason\"><h4>The reason this question was marked wrong is:</h4><p>#{reasons[i]}</p></div>"
+          else
+            #Don't show the nugget if they didn't miss it
+            @opts[:normalize].nil? && @opts[:missed] && !missed ? "" : h
+          end
+        end.join("\n")
+      end
+      
+      def parser
+        return @parser if @parser
+        @parser = Parser.new(@cml.children.to_xml, @opts.merge(
+          :no_wrap => true, 
+          :multi_type => multi_type, 
+          :missed => @opts[:missed] && @opts[:missed]["structured"] ? @opts[:missed]["structured"][0] : nil,
+          :iteration => 0)
+        )
+      end
+      
+      def on
+        @attrs["on"].to_s
+      end
+      
+      def reproduce
+        children = []
+        iterations = @opts[:data][@attrs["on"].to_s].length rescue 1
+        iterations.times do |i|
+          @cache ||= parser.to_html(
+            :missed => @opts[:missed] && @opts[:missed]["structured"] ? @opts[:missed]["structured"][i] : nil,
+            :iteration => i
+          )
+          children << @cache
+          #kill the cache if we have to display missed messaging or we're digging gold
+          @cache = nil if @opts[:normalize] || (@opts[:missed] && @opts[:missed]["structured"])
+        end
+        children.empty? ? [Parser.new("<cml:hidden name=\"#{@attrs["on"]}\" value=\"Nothing to iterate\"/>", @opts.merge(:no_wrap => true)).to_html] : children
+      end
+    end
+  end
+end

data/lib/cml/tags/meta.rb

@@ -0,0 +1,12 @@
+module CML
+  module Tags
+    class Meta < Tag
+      Template = <<-HTML.freeze
+      HTML
+      
+      def wrapper(parsed)
+        parsed
+      end
+    end
+  end
+end

data/lib/cml/tags/multiple_text.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__)+"/text"
+module CML
+  module Tags
+    class MultipleText < Text
+      def initialize(cml, opts)
+        cml = cml.to_xml unless cml.is_a?(String)
+        super(cml.sub(/multiple_text/, "text multiple=\"true\""), opts)
+      end
+    end
+  end
+end

data/lib/cml/tags/option.rb

@@ -0,0 +1,29 @@
+module CML
+  module Tags
+    class Option < Tag
+      Template = <<-HTML.freeze
+<option {{value}} {{selected}}>{{label}}</option>
+      HTML
+      
+      def wrapper(parsed)
+        parsed
+      end
+      
+      def value
+        (@attrs["value"] || @attrs["label"]).to_s
+      end
+      
+      def selected=(selected)
+        @attrs["selected"] = selected
+      end
+      
+      def data
+        super.merge({
+          "value" => @attrs["value"] ? "value=\"#{@attrs["value"]}\"" : "", 
+          "selected" => @attrs["selected"] ? "selected=\"selected\"" : "",
+          "label" => (@attrs["label"] || @cml.inner_html).to_s
+        })
+      end
+    end
+  end
+end

data/lib/cml/tags/radio.rb

@@ -0,0 +1,48 @@
+module CML
+  module Tags
+    class Radio < Tag
+      BareTemplate = <<-HTML.freeze
+<input name="{{name}}" type="radio" value="{{value}}" class="{{classes}}" {{checked}}/>
+      HTML
+      
+      Template = <<-HTML.freeze
+<div class="cml_row"><label class="{{gold_class}}">#{BareTemplate} {{label}}</label></div>
+      HTML
+      
+      #Radios should always be grouped, but for consistency with checkboxes, we check
+      def grouped?
+        @opts[:bare] || (@cml.parent && ["radios","ratings"].include?(@cml.parent.name))
+      end
+      
+      def wrapper(parsed)
+        grouped? ? parsed : super
+      end
+      
+      def value
+        ensure_resolved((@attrs["value"] || @attrs["label"]).to_s)
+      end
+      
+      def validate?
+        @attrs["duplicate"] ? false : true
+      end
+      
+      def checked
+        manipulated = !@opts[:missed].nil?
+        if preload = preloaded_data
+          manipulated = true
+          if preload.map{|x| x.to_s.downcase }.include?(value.to_s.downcase)
+            return "checked=\"checked\""
+          end
+        end
+        !manipulated && @attrs["checked"] ? "checked=\"checked\"" : ""
+      end
+      
+      def data
+        super.merge({
+          "checked" => checked,
+          "label" => @attrs["label"].to_s
+        })
+      end
+    end
+  end
+end

data/lib/cml/tags/radios.rb

@@ -0,0 +1,36 @@
+module CML
+  module Tags
+    class Radios < Tag
+      Template = <<-HTML.freeze
+{{legend}}
+  {{content}}
+      HTML
+      
+      def data
+        super.merge({"content" => content })
+      end
+      
+      def content
+        cloned= @cml.dup
+        c = children
+        cloned.xpath(".//cml:*[not(self::cml:radio)]").remove
+        cloned.xpath(".//cml:radio").each_with_index do |r,i|
+          r.namespace = nil
+          r.replace(c[i].convert)
+        end
+        #Remove the surrounding tag
+        cloned.to_xhtml.gsub(/<\/?cml:radios[^>]*?>|<\/?>/,'')
+      end
+      memoize :content
+      
+      def children
+        @cml.xpath(".//cml:radio").map do |c|
+          c["name"] ||= name
+          c["validates"] ||= @attrs["validates"].to_s
+          Radio.new(c, @opts)
+        end
+      end
+      memoize :children
+    end
+  end
+end