dolores-cml 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Van Pelt
+
+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,18 @@
+= cml
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Chris Van Pelt. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cml"
+    gem.summary = "CML is CrowdFlower Markup Language"
+    gem.description = "CML let's you easily create form elements and custom interfaces for the CrowdFlower Croud Labor platform"
+    gem.email = "vanpelt@doloreslabs.com"
+    gem.homepage = "http://github.com/dolores/cml"
+    gem.authors = ["Chris Van Pelt"]
+    gem.add_dependency 'liquid', '>= 2.0.0'
+    gem.add_dependency 'nokogiri', '>= 1.3.3'
+    gem.add_dependency 'json_pure', '>= 1.1.3'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :refresh_builder => [:build] do
+  cp "pkg/cml-#{File.read("VERSION").strip}.gem", "../builder/gems/cache/"
+  rm_rf "../builder/gems/gems/cml-#{File.read("VERSION").strip}/"
+  `cd ../builder && bin/thor merb:gem:redeploy`
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cml #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/cml.gemspec

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cml}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Van Pelt"]
+  s.date = %q{2009-08-25}
+  s.description = %q{CML let's you easily create form elements and custom interfaces for the CrowdFlower Croud Labor platform}
+  s.email = %q{vanpelt@doloreslabs.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "cml.gemspec",
+     "lib/cml.rb",
+     "lib/cml/converters/jsawesome.rb",
+     "lib/cml/liquid_filters.rb",
+     "lib/cml/parser.rb",
+     "lib/cml/tag.rb",
+     "lib/cml/tags/checkbox.rb",
+     "lib/cml/tags/checkboxes.rb",
+     "lib/cml/tags/group.rb",
+     "lib/cml/tags/hidden.rb",
+     "lib/cml/tags/meta.rb",
+     "lib/cml/tags/option.rb",
+     "lib/cml/tags/radio.rb",
+     "lib/cml/tags/radios.rb",
+     "lib/cml/tags/ratings.rb",
+     "lib/cml/tags/select.rb",
+     "lib/cml/tags/text.rb",
+     "lib/cml/tags/textarea.rb",
+     "lib/cml/tags/unknown.rb",
+     "spec/complex_spec.rb",
+     "spec/converters/jsawesome_spec.rb",
+     "spec/fixtures/complex.cml",
+     "spec/fixtures/invalid.cml",
+     "spec/meta_spec.rb",
+     "spec/sorta_match.rb",
+     "spec/spec_helper.rb",
+     "spec/tags/checkbox_spec.rb",
+     "spec/tags/checkboxes_spec.rb",
+     "spec/tags/group_spec.rb",
+     "spec/tags/hidden_spec.rb",
+     "spec/tags/meta_spec.rb",
+     "spec/tags/radios_spec.rb",
+     "spec/tags/select_spec.rb",
+     "spec/tags/text_spec.rb",
+     "spec/tags/textarea_spec.rb",
+     "spec/tags/unknown_spec.rb",
+     "spec/validation_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/dolores/cml}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{CML is CrowdFlower Markup Language}
+  s.test_files = [
+    "spec/complex_spec.rb",
+     "spec/converters/jsawesome_spec.rb",
+     "spec/meta_spec.rb",
+     "spec/sorta_match.rb",
+     "spec/spec_helper.rb",
+     "spec/tags/checkbox_spec.rb",
+     "spec/tags/checkboxes_spec.rb",
+     "spec/tags/group_spec.rb",
+     "spec/tags/hidden_spec.rb",
+     "spec/tags/meta_spec.rb",
+     "spec/tags/radios_spec.rb",
+     "spec/tags/select_spec.rb",
+     "spec/tags/text_spec.rb",
+     "spec/tags/textarea_spec.rb",
+     "spec/tags/unknown_spec.rb",
+     "spec/validation_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<liquid>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.3"])
+      s.add_runtime_dependency(%q<json_pure>, [">= 1.1.3"])
+    else
+      s.add_dependency(%q<liquid>, [">= 2.0.0"])
+      s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
+      s.add_dependency(%q<json_pure>, [">= 1.1.3"])
+    end
+  else
+    s.add_dependency(%q<liquid>, [">= 2.0.0"])
+    s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
+    s.add_dependency(%q<json_pure>, [">= 1.1.3"])
+  end
+end

data/lib/cml/converters/jsawesome.rb

@@ -0,0 +1,102 @@
+module CML
+  module Converters
+    class JSAwesome
+      def initialize(json)
+        parsed = JSON.parse(json)
+        @json = parsed[0] || []
+        @labels = parsed[1] || {}
+        @tags = []
+      end
+      
+      def convert
+        @json.map do |k,v|
+          if k.is_a?(Array)
+            (k << v).map {|k,v| process(k,v)}
+          else
+            process(k,v)
+          end
+        end.join("\n") + meta
+      end
+      
+      def meta
+        (@labels["gold"] || {}).select do |k,v|
+          next if k =~ /^_/
+          !@tags.map {|t| t.name }.include?(k)
+        end.map do |k,v|
+          tag("meta", k, {:meta => true})
+        end.join("\n")
+      end
+      
+      def label(k)
+        k = k.sub(/^[_#*^~]?\+?/,'')
+        l = @labels[k]
+        label = l.is_a?(Hash) ? l["label"] : l if l
+        label ||= k.capitalize.gsub(/_/,' ')
+      end
+      
+      def tag(tag, val, opts = {})
+        val = Array(val)
+        parts = val[0].split("|")
+        key = parts[0].sub(/^[_#*^~]?\+?/,'')
+        label = label(parts[0])
+        parts << key if label != key.capitalize.gsub(/_/,' ') || opts[:meta]
+        attrs = opts[:meta] ? [] : ["label=\"#{label}\""]
+        attrs << "name=\"#{parts[1]}\"" if parts[1]
+        attrs << "checked=\"true\"" if val[1]
+        attrs << "validates=\"required\"" if @labels[key] && @labels[key]["required"]
+        opts.reject {|k,v| v.to_s.strip.length == 0 || k.is_a?(Symbol) }.each do |k,v|
+          attrs << "#{k}=\"#{v}\""
+        end
+        if @labels["gold"] && @labels["gold"][key]
+          opts["gold"] = {}
+          src = @labels["gold"][key]
+          opts["gold"]["src"] = src
+          opts["gold"]["regex"], opts["gold"]["flags"] = Array(@labels["gold"]["_"+src+"_regex"])
+          opts["gold"]["strict"] = @labels["gold"]["_"+src+"_strict"]
+        else
+          opts["gold"] = false
+        end
+        
+        tag = Parser.tag_class(tag).new("<cml:#{tag} #{attrs.join(" ")} />")
+        tag.gold = opts["gold"]
+        opts[:children].each { |c| tag.cml.add_child(tag(*c).cml) } if opts[:children]
+        @tags << tag if opts[:parent]
+        tag
+      end
+      
+      def process(k,v)
+        select_default = @labels['{}'] || "Choose Category"
+        cml = case v
+        #a select tag or group of radios/checkboxes
+        when Array:
+          if(k =~ /^[^_]/)
+            if $~[0] == "*"
+              parent = "radios"
+              child = "radio"
+            elsif $~[0] == "^"
+              parent = "checkboxes"
+              child = "checkbox"
+            else
+              parent = "select"
+              child = "option"
+            end
+            tag(parent, k, {:children => v.map { |c| [child, c]}, :parent => true })
+          #Multiple hidden fields...
+          elsif(k =~ /^_/)
+            v.map { |c| tag("hidden", c, :parent => true)}.join("\n")
+          end
+        else
+          if(k =~ /^#/)
+            tag("textarea", k, {"default" => v, :parent => true})
+          elsif(k =~ /^_/)
+            tag("hidden", k, {"value" => v, :parent => true})
+          elsif(k =~ /^\^/)
+            tag("checkbox", k, {"default" => v, :parent => true})
+          else
+            tag("text", k, {"default" => v, :parent => true})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cml/liquid_filters.rb

@@ -0,0 +1,7 @@
+module CML
+  module LiquidFilters    
+    def to_json(input)
+      input.to_json
+    end
+  end
+end

data/lib/cml/parser.rb

@@ -0,0 +1,107 @@
+module CML
+  class Parser
+    attr_reader :doc, :cftags, :tags, :errors
+    
+    def initialize(content, opts = {})
+      @opts = opts
+      @doc = Parser.parse(content)
+      @cftags = @doc.xpath("//cml:*[not(ancestor::cml:*)]")
+      @tags = @cftags.map do |t|
+        Parser.tag_class(t.name).new(t, @opts)
+      end
+    end
+    
+    def self.parse(content)
+      Nokogiri::XML("<root xmlns:cml=\"http://crowdflower.com\">#{content}</root>")
+    end
+    
+    def convert(opts = nil)
+      @opts = opts if opts
+      cloned = @doc.dup
+      cloned.xpath("//cml:*[not(ancestor::cml:*)]").each_with_index do |t,i|
+        t.replace(@tags[i].convert(opts))
+      end
+      cloned
+    end
+    
+    def fields
+      @fields = {}
+      @tags.each do |g|
+        agg = g.attrs["aggregation"]
+        @fields[g.name] = agg.to_s if agg
+      end
+      @fields
+    end
+    
+    def golds
+      return @golds if @golds
+      @golds = {}
+      @tags.each do |g|
+        gold = g.gold?
+        next unless gold
+        val = (gold.attributes["gold"] || gold.attributes["src"]).to_s
+        val = "#{g.name}_gold" if val =~ /^(true|\s*)$/
+        @golds[g.name] = val
+        ["strict","regex"].each do |attrs|
+          if a = gold.attributes[attrs]
+            @golds["_#{val}_#{attrs}"] = attrs == "regex" ? [a.to_s, gold.attributes["flags"].to_s] : a.to_s
+          end
+        end
+      end
+      @golds
+    end
+    
+    def valid?
+      @errors = []
+      if e = @doc.errors.select {|e| s.fatal? }.last
+        @errors << "Malformed CML (#{e.level}).  #{e.message.chomp} on line #{e.line} column #{e.column}."
+      end
+      @tags.select {|t| t.validate? && t.name =~ /^\s*$/ }.each do |t|
+        @errors << "#{t.to_s.split("\n")[0]} does not have a label or name specified."
+      end
+      dupes = @tags.select do |tag|
+        tag.validate? && @tags.select {|t| t.name == tag.name}.length > 1
+      end
+      (dupes[1..-1] || []).each do |t|
+        @errors << "#{t.to_s.split("\n")[0]} has a duplicated name, please specify a unique name attribute."
+      end
+      @tags.each do |t|
+        next unless t.children
+        dupes = t.children.select do |child|
+          t.children.select {|c| c.value == child.value}.length > 1
+        end
+        (dupes[1..-1] || []).each do |c|
+          @errors << "#{c} a child of #{t.to_s.split("\n")[0]} has a duplicated value, please specify a unique value attribute."
+        end
+      end
+      @errors.length == 0
+    end
+    
+    def wrap(content)
+      @opts[:no_wrap] ? content : "<div class=\"cml#{" "+@opts[:class] if @opts[:class]}\" id=\"#{@opts[:prefix]}\">#{content}</div>"
+    end
+    
+    def to_s
+      @doc.root.children.to_s
+    end
+    
+    def to_html(opts = nil)
+      xml = convert(opts)
+      wrap(xml.at("root").inner_html)
+    end
+    
+    def self.escape( string )
+      string.to_s.gsub( /&/, "&amp;" ).
+             gsub( /</, "&lt;" ).
+             gsub( />/, "&gt;" ).
+             gsub( /"/, "&quot;" )
+    end
+        
+    #This takes the name of the tag and converts it to the appropriate task
+    def self.tag_class(name)
+      CML::Tags.module_eval(name.gsub(/(^|_)(.)/) { $2.upcase })
+    rescue
+      CML::Tags::Unknown
+    end
+  end
+end

data/lib/cml/tag.rb

@@ -0,0 +1,134 @@
+module CML
+  class Tag
+    attr_reader :attrs, :tag, :data, :cml
+    
+    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
+    
+    def prefix(name)
+      @opts[:prefix] ? "#{@opts[:prefix]}[#{name}]" : "#{name}"
+    end
+    
+    def gold?
+      @attrs["gold"] ? @cml : @cml.at("./cml:gold")
+    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 name
+      (@attrs["name"] || @attrs["label"]).to_s.downcase.gsub(/\s/,"_").gsub(/\W/,"")
+    end
+    
+    def wrapper_classes
+      extras = @attrs["only-if"] ? "only-if:#{@attrs["only-if"]}" : ""
+      "#{@tag} #{extras}".strip
+    end
+    
+    def children
+      false
+    end
+    
+    def classes
+      @classes ||= [name] << validations << @attrs["class"].to_s.split(/ /)
+      @classes.uniq.reject {|c| c.length == 0 }.join(" ").strip
+    end
+    
+    def convert(opts = nil)
+      @opts = 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
+      wrapper(Liquid::Template.parse(self.class::Template).render(data, [LiquidFilters]))
+    end
+    
+    def to_s
+      @cml.to_s
+    end
+    
+    def label(label, tag = "label")
+      label ||= @attrs["name"].to_s.capitalize
+      required = " <span class=\"required\">(required)</span>" if validations.include?("required")
+      "<#{tag}>#{label}#{required}</#{tag.split(" ")[0]}>" if label.to_s != ""
+    end
+    
+    def legend(label)
+      label(label, "legend") if label
+    end
+    
+    def to_liquid
+      to_html
+    end
+    
+    def validations
+      @validations ||= @attrs["validates"].to_s.split(/ /).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>" : nil
+    end
+    
+    def validate?
+      true
+    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...
+      "<#{tag} class=\"#{wrapper_classes}\">#{parsed}#{instructions}</#{tag}>"
+    end
+    
+    def value
+      @attrs["value"].to_s
+    end
+    
+    def data
+      (@opts[:data] || {}).merge({
+        "name" => prefix(name), 
+        "label" => label(@attrs["label"]),
+        "legend" => label(@attrs["label"], "h2 class=\"legend\""),
+        "classes" => classes,
+        "value" => value
+      })
+    end
+  end
+end

data/lib/cml/tags/checkbox.rb

@@ -0,0 +1,37 @@
+module CML
+  module Tags
+    class Checkbox < Tag
+      Template = <<-HTML.freeze
+{{default}}
+<label><input name="{{name}}" type="checkbox" value="{{value}}" class="{{classes}}" {{checked}}/> {{label}}</label>
+      HTML
+      
+      def prefix(name)
+        super(name) + (grouped? ? "[]" : "")
+      end
+      
+      def grouped?
+        @cml.parent && @cml.parent.name == "checkboxes"
+      end
+      
+      def wrapper(parsed)
+        grouped? ? parsed : super
+      end
+      
+      def value
+        (@attrs["value"] || (grouped? ? @attrs["label"] : "true")).to_s
+      end
+      
+      def data
+        default = ""
+        if @attrs["default"]
+          default = Hidden.new("<cml:hidden name=\"#{name}\" value=\"#{@attrs["default"]}\"/>", @opts).to_html
+        end
+        super.merge({ 
+          "default" => default, 
+          "checked" => @attrs["checked"] ? "checked=\"checked\"" : "",
+          "label" => @attrs["label"].to_s})
+      end
+    end
+  end
+end

data/lib/cml/tags/checkboxes.rb

@@ -0,0 +1,24 @@
+module CML
+  module Tags
+    class Checkboxes < Tag
+      Template = <<-HTML.freeze
+{{legend}}
+  {% for checkbox in checkboxes %}
+  {{checkbox}}
+  {% endfor %}
+      HTML
+      
+      def data
+        super.merge({"checkboxes" => children})
+      end
+      
+      def children
+        @cml.xpath("cml:checkbox").map do |c|
+          c["name"] ||= name
+          c["validates"] ||= @attrs["validates"].to_s
+          Checkbox.new(c, @opts)
+        end
+      end
+    end
+  end
+end

data/lib/cml/tags/group.rb

@@ -0,0 +1,18 @@
+module CML
+  module Tags
+    class Group < Tag
+      Template = <<-HTML.freeze
+{{label}}
+  {{content}}
+      HTML
+      
+      def validate?
+        false
+      end
+      
+      def data
+        super.merge({"content" => Parser.new(@cml.inner_html, @opts.merge(:no_wrap => true)).to_html})
+      end
+    end
+  end
+end

data/lib/cml/tags/hidden.rb

@@ -0,0 +1,13 @@
+module CML
+  module Tags
+    class Hidden < Tag
+      Template = <<-HTML.freeze
+<input name="{{name}}" type="hidden" value="{{value}}" class="{{classes}}"/>
+      HTML
+      
+      def wrapper(parsed)
+        parsed
+      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