Coverage Report - org.crosswire.jsword.book.filter.gbf.GBFTagBuilders
 
Classes in this File Line Coverage Branch Coverage Complexity
GBFTagBuilders
0%
0/64
0%
0/18
1.48
GBFTagBuilders$BoldStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$BookTitleStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$CrossRefStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$DefaultEndTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$EndOfLineTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$EscapeTagBuilder
0%
0/4
0%
0/2
1.48
GBFTagBuilders$FootnoteEndTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$FootnoteStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$HeaderStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$IgnoredTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$ItalicStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$JustifyRightTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$OTQuoteStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$ParagraphTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$PoetryStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$PsalmTitleStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$RedLetterStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$StrongsMorphTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$StrongsWordTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$TextFootnoteTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$TitleStartTagBuilder
0%
0/2
N/A
1.48
GBFTagBuilders$UnderlineStartTagBuilder
0%
0/2
N/A
1.48
 
 1  
 /**
 2  
  * Distribution License:
 3  
  * JSword is free software; you can redistribute it and/or modify it under
 4  
  * the terms of the GNU Lesser General Public License, version 2.1 or later
 5  
  * as published by the Free Software Foundation. This program is distributed
 6  
  * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 7  
  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 8  
  * See the GNU Lesser General Public License for more details.
 9  
  *
 10  
  * The License is available on the internet at:
 11  
  *      http://www.gnu.org/copyleft/lgpl.html
 12  
  * or by writing to:
 13  
  *      Free Software Foundation, Inc.
 14  
  *      59 Temple Place - Suite 330
 15  
  *      Boston, MA 02111-1307, USA
 16  
  *
 17  
  * © CrossWire Bible Society, 2005 - 2016
 18  
  *
 19  
  */
 20  
 package org.crosswire.jsword.book.filter.gbf;
 21  
 
 22  
 import java.util.HashMap;
 23  
 import java.util.Map;
 24  
 
 25  
 import org.crosswire.jsword.book.Book;
 26  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.BoldStartTag;
 27  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.CrossRefStartTag;
 28  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.BookTitleStartTag;
 29  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.DefaultEndTag;
 30  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.EOLTag;
 31  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.FootnoteEndTag;
 32  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.FootnoteStartTag;
 33  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.HeaderStartTag;
 34  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.IgnoredTag;
 35  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.ItalicStartTag;
 36  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.JustifyRightTag;
 37  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.OTQuoteStartTag;
 38  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.ParagraphTag;
 39  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.PoetryStartTag;
 40  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.PsalmStartTag;
 41  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.RedLetterStartTag;
 42  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.StrongsMorphTag;
 43  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.StrongsWordTag;
 44  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.TextFootnoteTag;
 45  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.TextTag;
 46  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.TitleStartTag;
 47  
 import org.crosswire.jsword.book.filter.gbf.GBFTags.UnderlineStartTag;
 48  
 import org.crosswire.jsword.passage.Key;
 49  
 import org.slf4j.Logger;
 50  
 import org.slf4j.LoggerFactory;
 51  
 
 52  
 /**
 53  
  * This class is a convenience to get GBF Tags.
 54  
  * 
 55  
  * The best place to go for more information about the GBF spec that I have
 56  
  * found is: <a
 57  
  * href="http://ebible.org/bible/gbf.htm">http://ebible.org/bible/gbf.htm</a>
 58  
  * 
 59  
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
 60  
  * @author Joe Walker
 61  
  * @author DM Smith
 62  
  */
 63  
 public final class GBFTagBuilders {
 64  
     /**
 65  
      *
 66  
      */
 67  0
     private GBFTagBuilders() {
 68  0
     }
 69  
 
 70  
     /**
 71  
      * @param book the book
 72  
      * @param key the key
 73  
      * @param name the tag name
 74  
      * @return return a GBF Tag for the given tag name
 75  
      */
 76  
     public static Tag getTag(Book book, Key key, String name) {
 77  0
         Tag tag = null;
 78  0
         if (name.startsWith("W") && (name.contains("-") || name.contains(":")) && name.matches("WT?[GH] ?[0-9]+[-:][0-9abc-]+")) {
 79  
             // these tags show verse boundaries in different versification;
 80  
             // ignore them instead of parsing them as Strongs / Morphology tags
 81  0
             return null;
 82  
         }
 83  0
         int length = name.length();
 84  0
         if (length > 0) {
 85  
             // Only the first two letters of the tag are indicative of the tag
 86  
             // The rest, if present, is data.
 87  0
             TagBuilder builder = null;
 88  0
             if (length == 2) {
 89  0
                 builder = BUILDERS.get(name);
 90  0
             } else if (length > 2) {
 91  0
                 builder = BUILDERS.get(name.substring(0, 2));
 92  
             }
 93  
 
 94  0
             if (builder != null) {
 95  0
                 tag = builder.createTag(name);
 96  
             }
 97  
 
 98  0
             if (tag == null) {
 99  
                 // I'm not confident enough that we handle all the GBF tags
 100  
                 // that I will blame the book instead of the program
 101  0
                 log.warn("In {}({}) ignoring tag of <{}>", book.getInitials(), key.getName(), name);
 102  
             }
 103  
         }
 104  0
         return tag;
 105  
     }
 106  
 
 107  
     /**
 108  
      * @param text
 109  
      * @return get a Text Tag object containing the text
 110  
      */
 111  
     public static Tag getTextTag(String text) {
 112  0
         return new TextTag(text);
 113  
     }
 114  
 
 115  
     /**
 116  
      *
 117  
      */
 118  0
     static final class BoldStartTagBuilder implements TagBuilder {
 119  
         public Tag createTag(String name) {
 120  0
             return new BoldStartTag(name);
 121  
         }
 122  
     }
 123  
 
 124  
     /**
 125  
     *
 126  
     */
 127  0
    static final class BookTitleStartTagBuilder implements TagBuilder {
 128  
        public Tag createTag(String name) {
 129  0
            return new BookTitleStartTag(name);
 130  
        }
 131  
    }
 132  
 
 133  
     /**
 134  
      *
 135  
      */
 136  0
     static final class CrossRefStartTagBuilder implements TagBuilder {
 137  
         public Tag createTag(final String name) {
 138  0
             return new CrossRefStartTag(name);
 139  
         }
 140  
     }
 141  
 
 142  
     /**
 143  
      *
 144  
      */
 145  0
     static final class DefaultEndTagBuilder implements TagBuilder {
 146  
         public Tag createTag(String name) {
 147  0
             return new DefaultEndTag(name);
 148  
         }
 149  
     }
 150  
 
 151  
     /**
 152  
      *
 153  
      */
 154  0
     static final class EndOfLineTagBuilder implements TagBuilder {
 155  
         public Tag createTag(final String name) {
 156  0
             return new EOLTag(name);
 157  
         }
 158  
 
 159  
     }
 160  
 
 161  
     /**
 162  
     *
 163  
     */
 164  0
     static final class EscapeTagBuilder implements TagBuilder {
 165  
         public Tag createTag(final String name) {
 166  0
             if ("CG".equals(name)) {
 167  0
                 return new TextTag("&gt;");
 168  
             }
 169  
 
 170  
             // else "CT"
 171  0
             return new TextTag("&lt;");
 172  
         }
 173  
 
 174  
     }
 175  
 
 176  
     /**
 177  
      *
 178  
      */
 179  0
     static final class FootnoteStartTagBuilder implements TagBuilder {
 180  
         public Tag createTag(String name) {
 181  0
             return new FootnoteStartTag(name);
 182  
         }
 183  
     }
 184  
 
 185  
     /**
 186  
      *
 187  
      */
 188  0
     static final class FootnoteEndTagBuilder implements TagBuilder {
 189  
         public Tag createTag(String name) {
 190  0
             return new FootnoteEndTag(name);
 191  
         }
 192  
     }
 193  
 
 194  
     /**
 195  
      *
 196  
      */
 197  0
     static final class HeaderStartTagBuilder implements TagBuilder {
 198  
         public Tag createTag(String name) {
 199  0
             return new HeaderStartTag(name);
 200  
         }
 201  
     }
 202  
 
 203  
     /**
 204  
      *
 205  
      */
 206  0
     static final class IgnoredTagBuilder implements TagBuilder {
 207  
         public Tag createTag(final String name) {
 208  0
             return new IgnoredTag(name);
 209  
         }
 210  
     }
 211  
 
 212  
     /**
 213  
      *
 214  
      */
 215  0
     static final class ItalicStartTagBuilder implements TagBuilder {
 216  
        public Tag createTag(String name) {
 217  0
             return new ItalicStartTag(name);
 218  
         }
 219  
     }
 220  
 
 221  
     /**
 222  
      *
 223  
      */
 224  0
     static final class JustifyRightTagBuilder implements TagBuilder {
 225  
         public Tag createTag(String name) {
 226  0
             return new JustifyRightTag(name);
 227  
         }
 228  
     }
 229  
 
 230  
     /**
 231  
      *
 232  
      */
 233  0
     static final class OTQuoteStartTagBuilder implements TagBuilder {
 234  
        public Tag createTag(String name) {
 235  0
             return new OTQuoteStartTag(name);
 236  
         }
 237  
     }
 238  
 
 239  
     /**
 240  
      *
 241  
      */
 242  0
     static final class ParagraphTagBuilder implements TagBuilder {
 243  
        public Tag createTag(String name) {
 244  0
             return new ParagraphTag(name);
 245  
         }
 246  
     }
 247  
 
 248  
     /**
 249  
      *
 250  
      */
 251  0
     static final class PoetryStartTagBuilder implements TagBuilder {
 252  
        public Tag createTag(String name) {
 253  0
             return new PoetryStartTag(name);
 254  
         }
 255  
 
 256  
     }
 257  
 
 258  
     /**
 259  
      *
 260  
      */
 261  0
     static final class PsalmTitleStartTagBuilder implements TagBuilder {
 262  
         public Tag createTag(String name) {
 263  0
             return new PsalmStartTag(name);
 264  
         }
 265  
 
 266  
     }
 267  
 
 268  
     /**
 269  
      *
 270  
      */
 271  0
     static final class RedLetterStartTagBuilder implements TagBuilder {
 272  
        public Tag createTag(String name) {
 273  0
             return new RedLetterStartTag(name);
 274  
         }
 275  
     }
 276  
 
 277  
     /**
 278  
      *
 279  
      */
 280  0
     static final class StrongsMorphTagBuilder implements TagBuilder {
 281  
        public Tag createTag(final String name) {
 282  0
             return new StrongsMorphTag(name);
 283  
         }
 284  
     }
 285  
 
 286  
     /**
 287  
      *
 288  
      */
 289  0
     static final class StrongsWordTagBuilder implements TagBuilder {
 290  
         public Tag createTag(final String name) {
 291  0
             return new StrongsWordTag(name);
 292  
         }
 293  
     }
 294  
 
 295  
     /**
 296  
      *
 297  
      */
 298  0
     static final class TextFootnoteTagBuilder implements TagBuilder {
 299  
         public Tag createTag(String name) {
 300  0
             return new TextFootnoteTag(name);
 301  
         }
 302  
     }
 303  
 
 304  
     /**
 305  
      *
 306  
      */
 307  0
     static final class TitleStartTagBuilder implements TagBuilder {
 308  
         public Tag createTag(String name) {
 309  0
             return new TitleStartTag(name);
 310  
         }
 311  
     }
 312  
 
 313  
     /**
 314  
      *
 315  
      */
 316  0
     static final class UnderlineStartTagBuilder implements TagBuilder {
 317  
         public Tag createTag(String name) {
 318  0
             return new UnderlineStartTag(name);
 319  
         }
 320  
     }
 321  
 
 322  
     /**
 323  
      * The <code>BUILDERS</code> maps the 2 letter GBF tag to a class that
 324  
      * proxies for the tag.
 325  
      */
 326  0
     private static final Map<String, TagBuilder> BUILDERS = new HashMap<String, TagBuilder>();
 327  
     static {
 328  0
         TagBuilder defaultEndTagBuilder = new DefaultEndTagBuilder();
 329  0
         TagBuilder ignoreTagBuilder = new IgnoredTagBuilder();
 330  
 
 331  0
         BUILDERS.put("FB", new BoldStartTagBuilder());
 332  0
         BUILDERS.put("Fb", defaultEndTagBuilder);
 333  
 
 334  0
         BUILDERS.put("FI", new ItalicStartTagBuilder());
 335  0
         BUILDERS.put("Fi", defaultEndTagBuilder);
 336  
 
 337  0
         BUILDERS.put("FR", new RedLetterStartTagBuilder());
 338  0
         BUILDERS.put("Fr", defaultEndTagBuilder);
 339  
 
 340  0
         BUILDERS.put("FU", new UnderlineStartTagBuilder());
 341  0
         BUILDERS.put("Fu", defaultEndTagBuilder);
 342  
 
 343  0
         BUILDERS.put("RX", new CrossRefStartTagBuilder());
 344  0
         BUILDERS.put("Rx", defaultEndTagBuilder);
 345  
 
 346  0
         BUILDERS.put("CL", new EndOfLineTagBuilder());
 347  0
         BUILDERS.put("CM", new ParagraphTagBuilder());
 348  
 
 349  0
         BUILDERS.put("RF", new FootnoteStartTagBuilder());
 350  0
         BUILDERS.put("Rf", new FootnoteEndTagBuilder());
 351  0
         BUILDERS.put("RB", new TextFootnoteTagBuilder());
 352  
 
 353  0
         BUILDERS.put("TS", new HeaderStartTagBuilder());
 354  0
         BUILDERS.put("Ts", defaultEndTagBuilder);
 355  
 
 356  0
         BUILDERS.put("TB", new PsalmTitleStartTagBuilder());
 357  0
         BUILDERS.put("Tb", defaultEndTagBuilder);
 358  
 
 359  0
         BUILDERS.put("TH", new TitleStartTagBuilder());
 360  0
         BUILDERS.put("Th", defaultEndTagBuilder);
 361  
 
 362  0
         BUILDERS.put("TT", new BookTitleStartTagBuilder());
 363  0
         BUILDERS.put("Tt", defaultEndTagBuilder);
 364  
 
 365  0
         BUILDERS.put("BA", ignoreTagBuilder);
 366  0
         BUILDERS.put("BC", ignoreTagBuilder);
 367  0
         BUILDERS.put("BI", ignoreTagBuilder);
 368  0
         BUILDERS.put("BN", ignoreTagBuilder);
 369  0
         BUILDERS.put("BO", ignoreTagBuilder);
 370  0
         BUILDERS.put("BP", ignoreTagBuilder);
 371  
 
 372  0
         BUILDERS.put("JR", new JustifyRightTagBuilder());
 373  0
         BUILDERS.put("JC", ignoreTagBuilder);
 374  0
         BUILDERS.put("JL", ignoreTagBuilder);
 375  
 
 376  0
         BUILDERS.put("FO", new OTQuoteStartTagBuilder());
 377  0
         BUILDERS.put("Fo", defaultEndTagBuilder);
 378  
 
 379  0
         BUILDERS.put("PP", new PoetryStartTagBuilder());
 380  0
         BUILDERS.put("Pp", defaultEndTagBuilder);
 381  
 
 382  0
         TagBuilder builder = new StrongsWordTagBuilder();
 383  0
         BUILDERS.put("WH", builder);
 384  0
         BUILDERS.put("WG", builder);
 385  0
         BUILDERS.put("WT", new StrongsMorphTagBuilder());
 386  
 
 387  0
         BUILDERS.put("CG", new EscapeTagBuilder());
 388  0
         BUILDERS.put("CT", new EscapeTagBuilder());
 389  
     }
 390  
 
 391  
     /**
 392  
      * The log stream
 393  
      */
 394  0
     private static final Logger log = LoggerFactory.getLogger(GBFTagBuilders.class);
 395  
 }