correspondence-markup 0.0.4 → 0.1.0

data/lib/correspondence-markup/bracketed-grammar.treetop

@@ -5,7 +5,7 @@ grammar CorrespondenceMarkupLanguage
   include CorrespondenceMarkup
 
   rule structure_groups
-    s groups:("[" structure_group "]" s)*
+    s groups:("(" structure_group ")" s)*
     {
       def value
         groups.elements.map {|e| e.structure_group.value}
@@ -14,7 +14,7 @@ grammar CorrespondenceMarkupLanguage
   end
 
   rule structure_group
-    s structures:("[" structure "]" s)*
+    s description:structure_group_description? s structures:("{" structure "}" s)*
     { 
       def value
         structureObjects = structures.elements.map {|e| e.structure.value}
@@ -22,12 +22,32 @@ grammar CorrespondenceMarkupLanguage
       end
     }
   end
+  
+  rule structure_group_description
+    "#" s [^{\n]* "\n"
+  end
 
   rule structure
-    components:(item / non_item)*
+    class:structure_class s itemGroups:("[" item_group "]" s)*
+    { 
+      def value
+        itemGroupObjects = itemGroups.elements.map {|e| e.item_group.value}
+        CorrespondenceMarkup::Structure.new(itemGroupObjects)
+      end
+    }
+  end
+  
+  rule structure_class
+    ([a-zA-Z] [a-zA-Z0-9_-]*)?
+  end
+
+  rule item_group
+    optional_id:(id:[A-Z]* ":")? components:(item / non_item)*
     { 
       def value
-        CorrespondenceMarkup::Structure.new(components.elements.map &:value)
+        group_id = optional_id.elements ? optional_id.elements[0].text_value : ""
+        componentObjects = components.elements.map {|e| e.value(group_id)}
+        CorrespondenceMarkup::ItemGroup.new(group_id, componentObjects)
       end
     }
   end
@@ -35,17 +55,21 @@ grammar CorrespondenceMarkupLanguage
   rule non_item
     text:text
     { 
-      def value
+      def value(group_id = "")
         CorrespondenceMarkup::NonItem.new(text.value)
       end
     }
   end
 
   rule item
-    "[" id:number S text:text "]"
+    "[" id:item_id S text:text "]"
     { 
-      def value
-        CorrespondenceMarkup::Item.new(id.value, text.value)
+      def value(group_id = "")
+        item_id = id.text_value
+        if !item_id.match(/[A-Z]/)
+          item_id = group_id + item_id
+        end
+        CorrespondenceMarkup::Item.new(item_id, text.value)
       end
     }
   end
@@ -59,15 +83,10 @@ grammar CorrespondenceMarkupLanguage
     }
   end
 
-  rule number
-    [0-9]+
-    { 
-      def value
-        text_value.to_i
-      end
-    }
+  rule item_id
+    [A-Z]* [0-9]+
   end
-
+  
   rule s
     [\s\n\r\t]*
   end

data/lib/correspondence-markup/types.rb

@@ -78,20 +78,42 @@ module CorrespondenceMarkup
     end
   end
   
+  # A group of items & non-items that will form part of a structure
+  class ItemGroup
+    attr_reader :id, :content
+    
+    def initialize(id, content)
+      @id = id
+      @content = content
+    end
+
+    def ==(otherItemGroup)
+      otherItemGroup.class == ItemGroup && otherItemGroup.id == @id && otherItemGroup.content == @content
+    end
+    
+    def to_html(options={})
+      "<div class=\"item-group\" data-group-id=\"#{@id}\">\n  " + 
+        @content.map{|x| x.to_html(options)}.join("") + "\n</div>\n"
+    end
+  end
+  
   # A structure, containing a sequence of items and non-items
   class Structure
-    attr_reader :content
+    attr_reader :item_groups
     
-    def initialize(content)
-      @content = content
+    def initialize(item_groups)
+      @item_groups = item_groups
     end
 
     def ==(otherStructure)
-      otherStructure.class == Structure && otherStructure.content == @content
+      otherStructure.class == Structure && otherStructure.item_groups == @item_groups
     end
     
     def to_html(options={})
-      "<div class=\"structure\">\n  " + @content.map{|x| x.to_html(options)}.join("") + "\n</div>\n"
+      itemGroupHtmls = @item_groups.map{|x| x.to_html(options)}
+      "<div class=\"structure\">\n  " + 
+        itemGroupHtmls.join("").chomp("\n").gsub("\n", "\n  ") +
+        "\n</div>\n"
     end
     
   end

data/lib/correspondence-markup.rb

@@ -11,7 +11,11 @@ module CorrespondenceMarkup
     end
     
     def compile_structure_groups(markup)
-      @parser.parse(markup, root: :structure_groups).value
+      syntax_tree = @parser.parse(markup, root: :structure_groups)
+      if(syntax_tree.nil?)
+        raise Exception, "Parse error: #{@parser.failure_reason}"
+      end
+      syntax_tree.value
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: correspondence-markup
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-03 00:00:00.000000000 Z
+date: 2013-07-05 00:00:00.000000000 Z
 dependencies: []
 description: Use to generate HTML pages containing structure groups, structures and
   items as used by correspondence.js.
@@ -38,7 +38,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 496569331
+      hash: -240696941
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: