1  /*
     2   * Copyright (c) 2003-2006, Simon Brown
     3   * All rights reserved.
     4   *
     5   * Redistribution and use in source and binary forms, with or without
     6   * modification, are permitted provided that the following conditions are met:
     7   *
     8   *   - Redistributions of source code must retain the above copyright
     9   *     notice, this list of conditions and the following disclaimer.
    10   *
    11   *   - Redistributions in binary form must reproduce the above copyright
    12   *     notice, this list of conditions and the following disclaimer in
    13   *     the documentation and/or other materials provided with the
    14   *     distribution.
    15   *
    16   *   - Neither the name of Pebble nor the names of its contributors may
    17   *     be used to endorse or promote products derived from this software
    18   *     without specific prior written permission.
    19   *
    20   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    21   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    22   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    23   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    24   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    25   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    26   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    27   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    28   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    29   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    30   * POSSIBILITY OF SUCH DAMAGE.
    31   */
    32  package net.sourceforge.pebble.domain;
    33  
    34  import net.sourceforge.pebble.util.StringUtils;
    35  
    36  import org.apache.commons.logging.Log;
    37  import org.apache.commons.logging.LogFactory;
    38  
    39  import java.util.*;
    40  
    41  /**
    42   * Represents a tag.
    43   *
    44   * @author    Simon Brown
    45   */
    46  public class Tag implements Permalinkable, Comparable {
    47  
    48    /** the log used by this class */
    49    private static final Log log = LogFactory.getLog(Tag.class);
    50  
    51    /** the owning blog */
    52    private Blog blog;
    53  
    54    /** the name of the tag */
    55    private String name = "";
    56  
    57    /** the rank for this tag */
    58    protected int rank;
    59  
    60    /**
    61     * Creates a new tag with the specified properties.
    62     *
    63     * @param name    the name
    64     * @param blog    a Blog instance
    65     */
    66    public Tag(String name, Blog blog) {
    67      setName(name);
    68      this.blog = blog;
    69    }
    70  
    71    /**
    72     * Gets the name of this tag.
    73     *
    74     * @return    the name as a String
    75     */
    76    public String getName() {
             /* 
    P/P       *  Method: String getName()
              * 
              *  Preconditions:
              *    init'ed(this.name)
              * 
              *  Postconditions:
              *    return_value == this.name
              *    init'ed(return_value)
              */
    77      return name;
    78    }
    79  
    80    /**
    81     * Sets the name of this tag.
    82     *
    83     * @param name    the new tag name
    84     */
    85    public void setName(String name) {
             /* 
    P/P       *  Method: void setName(String)
              * 
              *  Postconditions:
              *    this.name != null
              */
    86      this.name = Tag.encode(name);
    87    }
    88  
    89    /**
    90     * Gets the permalink for this object.
    91     *
    92     * @return  a URL as a String
    93     */
    94    public String getPermalink() {
             /* 
    P/P       *  Method: String getPermalink()
              * 
              *  Preconditions:
              *    this.blog != null
              *    init'ed(this.name)
              * 
              *  Postconditions:
              *    return_value != null
              * 
              *  Preconditions:
              *    (soft) net/sourceforge/pebble/domain/BlogManager.instance != null
              *    (soft) init'ed(net/sourceforge/pebble/domain/BlogManager.instance.multiBlog)
              *    (soft) init'ed(this.blog.id)
              */
    95      return blog.getUrl() + "tags/" + name + "/";
    96    }
    97  
    98    /**
    99     * Gets the hashcode of this object.
   100     *
   101     * @return  the hashcode as an int
   102     */
   103    public int hashCode() {
             /* 
    P/P       *  Method: int hashCode()
              * 
              *  Preconditions:
              *    this.name != null
              * 
              *  Postconditions:
              *    init'ed(return_value)
              */
   104      return name.hashCode();
   105    }
   106  
   107    /**
   108     * Determines whether the specified object is equal to this one.
   109     *
   110     * @param o   the object to compare against
   111     * @return    true if Object o represents the same tag, false otherwise
   112     */
   113    public boolean equals(Object o) {
             /* 
    P/P       *  Method: bool equals(Object)
              * 
              *  Preconditions:
              *    (soft) o.name != null
              *    (soft) init'ed(this.name)
              * 
              *  Postconditions:
              *    init'ed(return_value)
              */
   114      if (!(o instanceof Tag)) {
   115        return false;
   116      }
   117  
   118      Tag tag = (Tag)o;
   119      return tag.getName().equals(name);
   120    }
   121  
   122    /**
   123     * Compares this object with the specified object for order.  Returns a
   124     * negative integer, zero, or a positive integer as this object is less
   125     * than, equal to, or greater than the specified object.<p>
   126     *
   127     * @param   o the Object to be compared.
   128     * @return  a negative integer, zero, or a positive integer as this object
   129     *		is less than, equal to, or greater than the specified object.
   130     *
   131     * @throws ClassCastException if the specified object's type prevents it
   132     *         from being compared to this Object.
   133     */
   134    public int compareTo(Object o) {
             /* 
    P/P       *  Method: int compareTo(Object)
              * 
              *  Preconditions:
              *    o != null
              *    init'ed(o.name)
              *    this.name != null
              * 
              *  Postconditions:
              *    init'ed(return_value)
              */
   135      Tag tag = (Tag)o;
   136      return getName().compareTo(tag.getName());
   137    }
   138  
   139    /**
   140     * Returns a String representation of this object.
   141     *
   142     * @return  a String
   143     */
   144    public String toString() {
             /* 
    P/P       *  Method: String toString()
              * 
              *  Preconditions:
              *    init'ed(this.name)
              * 
              *  Postconditions:
              *    return_value == this.name
              *    init'ed(return_value)
              */
   145      return this.name;
   146    }
   147  
   148    /**
   149     * Gets the rank for this tag.
   150     *
   151     * @return  an int between 1 and 10;
   152     */
   153    public int getRank() {
             /* 
    P/P       *  Method: int getRank()
              * 
              *  Preconditions:
              *    init'ed(this.rank)
              * 
              *  Postconditions:
              *    return_value == this.rank
              *    init'ed(return_value)
              */
   154      return this.rank;
   155    }
   156  
   157    /**
   158     * Given a string containing whitespace separated tags, this method returns a
   159     * List containing the tags.
   160     *
   161     * @param tags    a whitespace separated list of tags
   162     * @return        a List of Tag instances
   163     */
   164    public static List<Tag> parse(Blog blog, String tags) {
             /* 
    P/P       *  Method: List parse(Blog, String)
              * 
              *  Presumptions:
              *    s.length@168 <= 232-1
              *    s[i]@168 != null
              * 
              *  Postconditions:
              *    return_value == &new ArrayList(parse#1)
              *    new ArrayList(parse#1) num objects == 1
              * 
              *  Test Vectors:
              *    tags: Addr_Set{null}, Inverse{null}
              *    java.lang.String:length(...)@167: {0}, {1..232-1}
              *    java.util.List:contains(...)@171: {1}, {0}
              */
   165      List<Tag> list = new ArrayList<Tag>();
   166  
   167      if (tags != null && tags.trim().length() > 0) {
   168        String s[] = tags.trim().split(" ");
   169        for (int i = 0; i < s.length; i++) {
   170          Tag tag = new Tag(StringUtils.transformHTML(s[i].trim()), blog);
   171          if (!list.contains(tag)) {
   172            list.add(tag);
   173          }
   174        }
   175      }
   176  
   177      return list;
   178    }
   179  
   180    /**
   181     * Given a list of tags, this method formats them into a comma separated list.
   182     *
   183     * @param tags    a List of tags
   184     * @return  a comma separated String
   185     */
   186    public static String format(List<Tag> tags) {
             /* 
    P/P       *  Method: String format(List)
              * 
              *  Presumptions:
              *    java.util.Iterator:next(...)@192 != null
              * 
              *  Postconditions:
              *    return_value != null
              * 
              *  Test Vectors:
              *    tags: Addr_Set{null}, Inverse{null}
              *    java.util.Iterator:hasNext(...)@191: {1}, {0}
              *    java.util.Iterator:hasNext(...)@194: {0}, {1}
              */
   187      StringBuilder builder = new StringBuilder();
   188  
   189      if (tags != null) {
   190        Iterator it = tags.iterator();
   191        while (it.hasNext()) {
   192          Tag tag = (Tag)it.next();
   193          builder.append(tag.getName());
   194          if (it.hasNext()) {
   195            builder.append(", ");
   196          }
   197        }
   198      }
   199  
   200      return builder.toString();
   201    }
   202  
   203    /**
   204     * Encodes a tag.
   205     *
   206     * @param tag   a String
   207     */
   208    public static String encode(String tag) {
             /* 
    P/P       *  Method: String encode(String)
              * 
              *  Postconditions:
              *    return_value != null
              * 
              *  Test Vectors:
              *    tag: Inverse{null}, Addr_Set{null}
              */
   209      if (tag == null) {
   210        return "";
   211      } else {
   212        String encodedTag = tag.trim().toLowerCase();
   213        encodedTag = encodedTag.replaceAll("\\+", " ");
   214        return encodedTag;
   215      }
   216    }
   217  
   218  }