tag_along 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 391d3d4d89b92c4d71b051eb6545a485e4210669
-  data.tar.gz: 7356ca9775ccbbce9fce5c2078669994dc5212f2
+  metadata.gz: 8c98d99128ba637e0d57ebc32e4be9e3fa7d3b60
+  data.tar.gz: a2f520902d8581be2dde44d2e0ace3ae4ceaf2b3
 SHA512:
-  metadata.gz: bff906e414af8b88c001e8f532421aa6850744982489f1fbaa59108fe453642963779ebb4f1902ae7ad050258201e11541469f229c2820c1eeb7a93c65c19918
-  data.tar.gz: 4edd2b7e8856823343b586dc826ca8c8850ea597daf89d27730a09a622386e6c59bb93a14c7319c8f268f0a042195c3c186514a051824def5d115f9d83d04378
+  metadata.gz: 427e207f9312002bd4459f6668ffda195e7db75b3b098512027d558f47677c7efb2d076a7c7fef02f4069972a9f52d349132da401ed96e57a354e36cb988c3ca
+  data.tar.gz: 1785b8fd997010c9f36469778940e6dfaac605ccf87786d0b83a4e22af75b05d6c18d7bc2f9159f0e33f5c2ad76634648a244c75ca132115af9173ef9b4986e9

data/CHANGELOG

@@ -1,3 +1,5 @@
+0.7.0 -- added dynamic tagging
+
 0.6.1 -- fixed a bug which would crash the gem if an object without
          item_string is entered
 

data/README.md

@@ -40,7 +40,7 @@ For example you want to tag days of week from a text:
 
 To add tags to a text:
 
-    offsets = [[8,13], [27,32]]
+    offsets = [[8, 13], [27, 32]]
     tg = TagAlong.new(text, offsets)
     
     tg.tag('<my_tag>', '</my_tag>')
@@ -53,18 +53,43 @@ To add tags to a text:
 
 Notice that you can retag the text as many times as you want.
 
+### Dynamic tags
+
+Sometimes you tags contain changeable component. To add dynamic data to tags:
+
+    #one substitution in opening tag:
+    offsets = [[8, 13, 'sunday'], [27, 32, 'monday']
+    tg.tag("<my_tag value=\"%s\">", '</my_tag>')
+    puts tg.tagged_text
+    # There's <my_tag value="sunday">Sunday</my_tag> \
+    # and there's <my_tag value="monday">Monday</my_tag>
+    
+    #one substitution in closing tag tag:
+    offsets = [[8, 13, nil, 'sunday'], [27, 32, nil, 'monday']
+    tg.tag('<my_tag', "</my_tag value=\"%s\">")
+    puts tg.tagged_text
+    # There's <my_tag>Sunday</my_tag value="sunday"> \
+    # and there's <my_tag>Monday</my_tag value="monday">
+
+    #several substitutions
+    offsets = [[8, 13, nil, ['sunday', 'http://en.wikipedia.org/wiki/Sunday'],
+      [27, 32, nil, ['monday', http://en.wikipedia.org/wiki/Monday']]
+
+    tg.tag("<my_tag value=\"%s\", url=\"%s\">", '</my_tag>')
+
+
 ### Offsets
   
 To prepare offsets from an arbitrary object:
     
     # Array of arrays
-    my_ary = [[8,13], [27,32]]
+    my_ary = [[8, 13], [27, 32]]
     offsets = TagAlong::Offsets.new(my_ary)
 
     # Array of hashes
-    my_hash = [{ start: 8, end:13 }, { start:27, end:32 }]
+    my_hash = [{ start: 8, end: 13 }, { start: 27, end: 32 }]
     offsets = TagAlong::Offsets.new(my_hash,
-                                    offset_start: 'start'
+                                    offset_start: 'start',
                                     offset_end: 'end')
     or
     offsets = TagAlong::Offsets.new(my_hash,
@@ -83,6 +108,75 @@ In all cases you can instantiate TagAlong with resulting offsets:
     tg = TagAlong.new(text, offsets)
     tg.tag('|hi|', '|bye|')
 
+Examples of dynamic tags:
+
+    # Array of arrays
+    my_ary = [[8, 13, ['sunday', 'http://en.wikipedia.org/wiki/Sunday']], 
+      [27, 32, ['monday', 'http://en.wikipedia.org/wiki/Monday']]]
+    offsets = TagAlong::Offsets.new(my_ary)
+
+    # Array of hashes
+    my_hash = [
+      { start: 8, 
+        end: 13, 
+        subst: ['sunday', 'http://en.wikipedia.org/wiki/Sunday'] }, 
+      { start: 27, 
+        end: 32,
+        subst: ['monday', 'http://en.wikipedia.org/wiki/Monday'] }
+      ]
+    offsets = TagAlong::Offsets.new(my_hash,
+                                    offset_start: 'start',
+                                    offset_end: 'end',
+                                    data_start: 'subst')
+    or
+    offsets = TagAlong::Offsets.new(my_hash,
+                                    offset_start: :start,
+                                    offset_end: :end,
+                                    data_start: :subst)
+
+    # Array of objects
+    require 'ostruct'
+    my_obj = [OpenStruct.new(s: 8, 
+                             e: 13, 
+                             values: ['sunday', 
+                                      'http://en.wikipedia.org/wiki/Sunday']),
+              OpenStruct.new(s: 27, 
+                             e: 32, 
+                             values: ['monday', 
+                                      'http://en.wikipedia.org/wiki/Monday'])]
+    offsets = TagAlong::Offsets.new(my_obj,
+                                    offset_start: :s,
+                                    offset_end: :e,
+                                    data_start: :values)
+
+In all cases you can instantiate TagAlong with resulting offsets:
+
+    tg = TagAlong.new(text, offsets)
+    tg.tag("<my_tag value=\"%s\", href=\"%s\">", '</my_tag>')
+
+Example of dynamic information in a closing tag:
+
+    # Array of hashes
+    my_hash = [
+      { start: 8, 
+        end: 13, 
+        subst: 'sunday' }, 
+      { start: 27, 
+        end: 32,
+        subst: 'monday' }
+      ]
+    offsets = TagAlong::Offsets.new(my_hash,
+                                    offset_start: 'start',
+                                    offset_end: 'end',
+                                    data_end: 'subst')
+    tg = TagAlong.new(text, offsets)
+    tg.tag('<my_tag>', "</my_tag value=\"%s\">")
+
+Versioning
+----------
+
+This gem is following practices of [Semantic Versioning][11]
+
 Contributing
 ------------
 
@@ -95,7 +189,7 @@ Contributing
 Copyright
 ---------
 
-Authors: [Dmitry Mozzherin][11] 
+Authors: [Dmitry Mozzherin][12] 
 
 Copyright (c) 2013 Marine Biological Laboratory. See LICENSE for
 further details.
@@ -110,4 +204,5 @@ further details.
 [8]: https://codeclimate.com/github/GlobalNamesArchitecture/tag_along
 [9]: https://gemnasium.com/GlobalNamesArchitecture/tag_along.png
 [10]: https://gemnasium.com/GlobalNamesArchitecture/tag_along
-[11]: https://github.com/dimus
+[11]: http://semver.org/
+[12]: https://github.com/dimus

data/lib/tag_along/offsets.rb

@@ -8,7 +8,8 @@ class TagAlong
       @offsets      = offsets
       @offset_start = (opts[:offset_start] || 'offset_start').to_sym
       @offset_end   = (opts[:offset_end]   || 'offset_end').to_sym
-      @item_string   = (opts[:item_string]  || 'item_string').to_sym
+      @data_start   = (opts[:data_start]   || 'data_start').to_sym
+      @data_end     = (opts[:data_end]     || 'data_end').to_sym
       
       item = @offsets.first
       if item.is_a?(Array)
@@ -32,33 +33,43 @@ class TagAlong
       @offsets = @offsets.map do |o|
         offset_start = o[0]
         offset_end = o[1]
-        item_string = o[2]
-        instantiate(offset_start, offset_end, item_string) 
+        data_start = o[2]
+        data_end = o[3]
+        instantiate(offset_start, offset_end, data_start, data_end) 
       end
     end
 
     def process_hash
       @offsets.each { |h| symbolize_keys(h) }
       @offsets = @offsets.map do |o|
-        instantiate(o[@offset_start], o[@offset_end], o[@item_string]) 
+        instantiate(o[@offset_start], 
+                    o[@offset_end],
+                    o[@data_start],
+                    o[@data_end]) 
       end
     end
 
     def process_obj
       @offsets = @offsets.map do |o|
-        item_string = o.respond_to?(@item_string) ? 
-          o.send(@item_string) :
-          nil
         instantiate(o.send(@offset_start), 
-                    o.send(@offset_end), 
-                    item_string) 
+                    o.send(@offset_end),
+                    o.send(@data_start),
+                    o.send(@data_end)) 
       end
     end
     
-    def instantiate(offset_start, offset_end, item_string)
+    def instantiate(offset_start, offset_end, data_start = nil, data_end = nil)
+      data_start = data_to_ary(data_start)
+      data_end = data_to_ary(data_end)
       OpenStruct.new(offset_start: to_int(offset_start),
                      offset_end:   to_int(offset_end),
-                     item_string:  item_string)
+                     data_start:   data_start,
+                     data_end:     data_end)
+    end
+
+    def data_to_ary(data)
+      return data unless data
+      data.is_a?(Array) ? data : [data]
     end
 
     def to_int(val)

data/lib/tag_along/version.rb

@@ -1,3 +1,3 @@
 class TagAlong
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

data/lib/tag_along.rb

@@ -19,9 +19,13 @@ class TagAlong
   end
 
   def tag(open_tag, close_tag)
+    open_tag_subs = open_tag.scan(/%s/).size
+    close_tag_subs = close_tag.scan(/%s/).size
     @tagged_text = @split_text.inject([]) do |res, t|
       if t[:tagged]
-        [open_tag, t[:text], close_tag].each { |text| res << text }
+        ot = dyn_tag(open_tag, t[:data_start], open_tag_subs) 
+        ct = dyn_tag(close_tag, t[:data_end], close_tag_subs)
+        [ot, t[:text], ct].each { |text| res << text }
       else
         res << t[:text]
       end
@@ -31,6 +35,11 @@ class TagAlong
 
   private
 
+  def dyn_tag(tag, data, subs_num)
+    return tag if subs_num == 0
+    tag % data
+  end
+
   def split_text
     return  if @split_text
     
@@ -38,7 +47,6 @@ class TagAlong
     cursor = 0
     fragment = []
     res = []
-    
     @offsets.each do |item|
       chars_num = item.offset_start - cursor
       chars_num.times { fragment << text_ary.shift }
@@ -47,7 +55,10 @@ class TagAlong
       cursor = item.offset_start
       chars_num = item.offset_end + 1 - cursor
       chars_num.times { fragment << text_ary.shift }
-      res << { tagged: true, text: fragment }
+      res << { tagged:     true, 
+               text:       fragment, 
+               data_start: item.data_start,
+               data_end:   item.data_end}
       fragment = []
       cursor = item.offset_end + 1
     end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ Coveralls.wear!
 
 require 'json'
 require 'ostruct'
-require_relative '../lib/tag_along'
+require 'tag_along'
 
 RSpec.configure do |c|
   c.mock_with :rr
@@ -16,11 +16,11 @@ module TagAlongSpec
     text = data[:content]
     offset_hash = data[:names]
     offset_obj = offset_hash.map do |h| 
-      OpenStruct.new(name: h[:verbatim],
+      OpenStruct.new(name:  h[:verbatim],
                      start: h[:offsetStart],
-                     end: h[:offsetEnd])
+                     end:   h[:offsetEnd])
     end
-    offset_ary = offset_obj.map { |h| [h.start, h.end] }
+    offset_ary = offset_obj.map { |h| [h.start, h.end, h.name] }
     [text, offset_ary, offset_hash, offset_obj]
   end
 end

data/spec/tag_along/offsets_spec.rb

@@ -12,14 +12,6 @@ describe TagAlong::Offsets do
     o.is_a?(TagAlong::Offsets).should be_true
     o.first.offset_start.should == 61
     o.first.offset_end.should == 68
-    o.first.item_string.should be_nil
-    ary_with_item = OFFSETS_HASH.map do |h| 
-      [h[:offsetStart], h[:offsetEnd], h[:verbatim]]
-    end
-    o = TagAlong::Offsets.new(ary_with_item)
-    o.first.offset_start.should == 61
-    o.first.offset_end.should == 68
-    o.first.item_string.should == 'Pundulus'
     -> { TagAlong::Offsets.new([['a','b']]) }.should 
       raise_error(TypeError, 'Offsets must be integers') 
   end
@@ -31,14 +23,6 @@ describe TagAlong::Offsets do
     o.is_a?(TagAlong::Offsets).should be_true
     o.first.offset_start.should == 61
     o.first.offset_end.should == 68
-    o.first.item_string.should be_nil
-    o = TagAlong::Offsets.new(OFFSETS_HASH, 
-                              offset_start: 'offsetStart',
-                              offset_end: 'offsetEnd',
-                              item_string: 'verbatim')
-    o.first.offset_start.should == 61
-    o.first.offset_end.should == 68
-    o.first.item_string.should == 'Pundulus'
   end
 
   it 'should process object' do
@@ -48,14 +32,53 @@ describe TagAlong::Offsets do
     o.is_a?(TagAlong::Offsets).should be_true
     o.first.offset_start.should == 61
     o.first.offset_end.should == 68
-    o.first.item_string.should be_nil
+  end
+
+  it 'should process arrays with dynamic start tag' do
+    o = TagAlong::Offsets.new(OFFSETS_ARY)
+    o.is_a?(TagAlong::Offsets).should be_true
+    o.first.offset_start.should == 61
+    o.first.offset_end.should == 68
+    o.first.data_start.should == ["Pundulus"]
+    o.first.data_end.should be_nil
+  end
+
+  it 'should process dynamic hash' do
+    o = TagAlong::Offsets.new(OFFSETS_HASH, 
+                              offset_start: :offsetStart,
+                              offset_end: :offsetEnd,
+                              data_start: :verbatim,
+                              data_end: :verbatim)
+    o.is_a?(TagAlong::Offsets).should be_true
+    o.first.offset_start.should == 61
+    o.first.offset_end.should == 68
+    o.first.data_start.should == ["Pundulus"]
+    o.first.data_end.should == ["Pundulus"]
+    o = TagAlong::Offsets.new(OFFSETS_HASH, 
+                              offset_start: :offsetStart,
+                              offset_end: :offsetEnd,
+                              data_end: :verbatim)
+    o.first.data_start.should be_nil
+    o.first.data_end.should == ["Pundulus"]
+  end
+
+  it 'should process dynamic object' do
     o = TagAlong::Offsets.new(OFFSETS_OBJ, 
                               offset_start: :start,
                               offset_end: :end,
-                              item_string: 'name')
+                              data_start: :name,
+                              data_end: :name)
     o.is_a?(TagAlong::Offsets).should be_true
     o.first.offset_start.should == 61
     o.first.offset_end.should == 68
-    o.first.item_string.should == 'Pundulus'
+    o.first.data_start.should == ["Pundulus"]
+    o.first.data_end.should == ["Pundulus"]
+    o = TagAlong::Offsets.new(OFFSETS_OBJ, 
+                              offset_start: :start,
+                              offset_end: :end,
+                              data_end: :name)
+    o.first.data_start.should be_nil
+    o.first.data_end.should == ["Pundulus"]
   end
+
 end

data/spec/tag_along_spec.rb

@@ -22,7 +22,7 @@ describe TagAlong do
     tg.tagged_text.should 
       include('<another_tag>Lebistes reticulatus</another_tag>')
   end
-
+  
   it 'should tag' do
     text = 'There\'s Sunday and there\'s Monday'
     offsets = [[8,13], [27,32]]
@@ -30,4 +30,28 @@ describe TagAlong do
     tg.tag('<em>', '</em>').should == 
       %q{There's <em>Sunday</em> and there's <em>Monday</em>}
   end
+
+  it 'should tag dynamicly' do
+    tg = TagAlong.new(TEXT, OFFSETS_ARY)
+    tagged_text = tg.tag("<my_tag name=\"%s\">", '</my_tag>')
+    tg.tagged_text.should == tagged_text
+    tg.tagged_text.should include('<my_tag name="Lebistes reticulatus">' + 
+                                  'Lebistes reticulatus</my_tag>')
+  end
+
+  it 'should tag dynamicly end tag' do
+    offsets = OFFSETS_ARY.each {|i| i.insert(-2, nil)}
+    tg = TagAlong.new(TEXT, OFFSETS_ARY)
+    tagged_text = tg.tag('<my_tag>', "</my_tag name=\"%s\">")
+    tg.tagged_text.should == tagged_text
+    tg.tagged_text.should include("</my_tag name=\"Pundulus\">")
+  end
+  
+  it 'should break dynamic taging if there is problem with data' do
+    offsets = OFFSETS_ARY.each {|i| i.insert(-2, nil)}
+    tg = TagAlong.new(TEXT, OFFSETS_ARY)
+    -> { tg.tag('<my_tag>', "</my_tag val=\"%s\" name=\"%s\">") }.
+      should raise_error
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tag_along
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Dmitry Mozzherin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-03 00:00:00.000000000 Z
+date: 2013-09-10 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Tags a text with arbitrary tags