-- master frame
local sb = CreateFrame("Frame")
local markClearFrame = CreateFrame("Frame")

-- constants
local SPELLS = { [64465] = true, }
local NAMES = { ["Marked Immortal Guardian"] = true, }

-- variables
local lastIconIndex = 9

-- mobs tracking
local guids = { }
local ignoreGuids = { }

-- loop and timer control
local nextCheckTime = nil
local lastBeaconBatchTime = nil


-- mark clearing control
local markToClear = 8
local nextMarkCheckTime = nil


-- Main mark clearing loop.
local function ClearAllMarksLoop()
    if nextMarkCheckTime ~= nil then
        local curTime = GetTime()
        local abort = nil


        if curTime >= nextMarkCheckTime then
            if markToClear == 6 then
                markToClear = 0
                abort = true
            end

            SetRaidTarget("player", markToClear)

            if abort then
                nextMarkCheckTime = nil
                markToClear = 8
                markClearFrame:SetScript("OnUpdate", nil)
            else
                markToClear = markToClear + 1

                if markToClear == 6 then
                    nextMarkCheckTime = curTime + 0.5
                else
                    nextMarkCheckTime = curTime + 0.2
                end
            end
        end
    end
end


-- Starts the mark clearing loop.
function ClearAllMarks()
    markToClear = 8
    nextMarkCheckTime = GetTime()
    markClearFrame:SetScript("OnUpdate", ClearAllMarksLoop)
end


-- Gets the next icon index to mark a mob with.
local function GetNextAvailableIcon()
    if lastIconIndex == 6 then
        lastIconIndex = 9
    end

    lastIconIndex = lastIconIndex - 1

    return lastIconIndex
end


-- Marks the supplied unit.
local function MarkUnit(unit)
    if UnitExists(unit) then
        local guid = UnitGUID(unit)


        SetRaidTarget(unit, GetNextAvailableIcon())
        ignoreGuids[guid] = true
    end
end

-- Checks to see if we want to mark this unitId, by
-- checking to see if it's a known GUID from the
-- combat log, if it's name matches something in our
-- list of markable mobs, or if it has the Shadow
-- Beacon buff.  Returns true if we are interested
-- in the mob, nil otherwise.
local function IsMobOfInterest(unitId)
    local rc


    if UnitExists(unitId) then
        local name = UnitName(unitId)
        local guid = UnitGUID(unitId)


        if not ignoreGuids[guid] then
            if guids[guid] then
                rc = true

            elseif NAMES[name] then
                rc = true

            else
                for spellId, _ in pairs(SPELLS) do
                    local spellName = GetSpellInfo(spellId)


                    if spellName then
                        if UnitBuff(unitId, spellName) then
                            rc = true
                            break
                        end
                    end
                end
            end
        end
    end

    return rc
end


-- Checks the supplied unitId to see if it matches the
-- supplied GUID.  If it does, this function ensures
-- that mob has one of the acceptable Shadow Beacon
-- marks.  If the mob doesn't yet have an allowed
-- mark, it marks it up with the next usable mark.
-- Returns true if the mob matched the GUID and has
-- a mark, nil otherwise.
local function MarkMobByUnitIfGUID(unitId, guid)
    local rc


    if UnitExists(unitId) then
        if UnitGUID(unitId) == guid then
            local curIcon = GetRaidTargetIndex(unitId) or 0


            -- only mark up if it doesn't already
            -- have one of the five marks we use
            if curIcon < 6 or curIcon > 8 then
                MarkUnit(unitId)
            end

            rc = true
        end
    end

    return rc
end


-- Scans all available targets to see if any of them match
-- the supplied GUID.  If that mob is found, this function
-- ensures it is marked with one of the acceptable Shadow
-- Beacon marks.  Returns true if the mob was found and
-- is (or was caused to be) marked, nil otherwise.
local function MarkMobByGUIDFromRaidTargets(guid)
    local rc


    for i = 1, 40 do
        local unitId = "raid"..i.."target"

        if MarkMobByUnitIfGUID(unitId, guid) then
            rc = true
            break
        end
    end

    return rc
end


-- Attempts to mark up the mob with the supplied GUID, and
-- if it can't be found, the GUID is put in a list to be
-- scanned on a 100ms timer so it will be marked ASAP.
local function RecordMobByGUID(guid)
    if not MarkMobByGUIDFromRaidTargets(guid) then  
        guids[guid] = true
    end
end


-- Detect Yogg-Saron casting Shadow Beacon and find out which mob he cast it on.
local function HandleCombatLog(timeStamp, event, sourceGuid, sourceName, sourceFlags, destGuid, destName, destFlags, spellId)
    if event == "SPELL_AURA_APPLIED" or event == "SPELL_AURA_REFRESH" then
        if SPELLS[spellId] then
            -- Activate the mouseover timer.
            nextCheckTime = GetTime()

            -- If this is a new round of Beacons, tell the player
            -- to start going nuts with the mouseovers.
            if lastBeaconBatchTime == nil then
                lastBeaconBatchTime = GetTime()
                UIErrorsFrame:AddMessage("Shadow Beacon cast - start mousing over the elephants!")
                PlaySoundFile(("Interface\\AddOns\\AjantisShadowBeacon\\aoogah.ogg"))
            end

            -- Record this mob as one of interest.
            RecordMobByGUID(destGuid)
        end
    end
end


-- Forgets we ever did anything.
local function Reset(removeIgnored)
    guids = { }
    nextCheckTime = nil
    lastIconIndex = 9
    lastBeaconBatchTime = nil
    ClearAllMarks()

    ignoreGuids = { }
end


-- The timer loop for marking mobs that weren't being
-- targeted by someone at the time the Beacon was cast.
-- It tracks mouseovers until all mobs that are known
-- to be of interest are marked up.
sb:SetScript("OnUpdate", function(f, event, ...)
    local curTime = GetTime()


    -- Reset everything if the last 'batch' of Shadow Beacons sent out was long enough ago.
    if lastBeaconBatchTime ~= nil and curTime - lastBeaconBatchTime >= 31 then
        Reset()
    else
        -- Main mouseover loop to check the current mouseover unit
        -- to see if it's in need of a mark.
        if nextCheckTime ~= nil and curTime >= nextCheckTime then
            if IsMobOfInterest("mouseover") then
                local curGuid = UnitGUID("mouseover")
                local curIcon = GetRaidTargetIndex("mouseover") or 0


                -- Only mark up if it doesn't already
                -- have one of the five marks we use.
                if curIcon < 6 or curIcon > 8 then
                    MarkUnit("mouseover")
                end

                -- Done marking this mob, forget about it now.
                guids[curGuid] = nil
            end

            nextCheckTime = curTime + 0.15
        end
    end
end)


-- Hook into and handle the various events.
sb:SetScript("OnEvent", function(f, event, ...)
    if event == "COMBAT_LOG_EVENT_UNFILTERED" then
        HandleCombatLog(...)

    elseif event == "PLAYER_REGEN_DISABLED" then
        Reset(true)

    elseif event == "ZONE_CHANGED_NEW_AREA" then
        Reset(true)

    elseif event == "ZONE_CHANGED" then
        Reset(true)

    end
end)

sb:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
sb:RegisterEvent("PLAYER_REGEN_DISABLED")
sb:RegisterEvent("ZONE_CHANGED_NEW_AREA")
sb:RegisterEvent("ZONE_CHANGED")

/^(?:(\d)[ \-\.]?)?(?:\(?(\d{3})\)?[ \-\.])?(\d{3})[ \-\.](\d{4})(?: ?x?(\d+))?$/

Try copy and pasting it in Rubular.

Capture Groups:
0: “1″ prefix, if included
1: Area code, if included
2: Prefix
3: Line Number
4: Extension, if included

It allows for a handful of formats as well. You may use dashes, dots, spaces or even nothing as separators, parentheses around area code are optional. Extension may be defined as simply another segment, or prefixed with “x”.

Examples that all work
155555555555555
1.555.555.5555 5555
(555) 555-5555 x5555
555-5555

Simple validation can be performed just by checking if it matches, more robust validation can be performed by validating each capture group.

Users earn reputation points by asking questions, providing answers, and receiving votes. Users may also earn “Badges” by doing other tasks like filling out their profile, or providing a very good answer to a long-outdated question.

If you’re a developer, you owe it to yourself to check out Stack Overflow.

A first-class function is a function that acts as an object or variable. They are sometimes called lambdas, anonymous functions, or procs. A closure is a special type of anonymous function that has access to external variables not passed in as arguments. In most cases with the popular dynamic languages (Javascript, Ruby, Groovy, etc…) first-class functions are indeed closures, but I believe that it is less important that they are closures as they are first-class functions.

To help clarify, in Javascript:

var lambda = function(x) {  return x + 2; };

This is an example of a first-class function. Technically it is also a closure, but the fact that it is is unimportant because it doesn’t reference and variable outside its scope.

var y = 35;
var closure = function(x) { return x+y; };

This time it IS important to call this function a closure (though it is also an anonymous function, lambda, etc…) because it references variable ‘y’ which is defined outside the scope of the function.

In Ruby a ‘block’ is a special type of anonymous function that is passed to another function as an argument. Because they have access to their parent scope’s variables, they are closures, but they are more importantly blocks. So call them that. Using ‘closure’ all the time just adds confusion as to what a closure really is.

Ruby block example:

['one', 'two', 'three'].each {|it| puts it }

The “{|it| puts it}” part is the block. It is not important that it is a closure, again, because it doesn’t reference external variables.

This is really a bunch of hot air, but I believe that it’s very important, especially when dealing with very technical subjects, to use the most appropriate nomenclature. Unless you’re referencing the fact that a lambda (etc..) is referencing external variables, don’t call it a closure.

What’s to come? An article on RESTful architecture for PHP and a preview of my REST server framework (oh god, that’s terrible news… not another web framework!). The good news? It’s easier to use than Rails (really!), and will be available for PHP with ports to Ruby and Java/Groovy in the works (and possibly Python as well).

Isn’t that cute? She just wanted to be a cheerleader. While public humiliation is one thing, I think pressing charges is a bit extreme. I mean; Who doesn’t want to be a high school cheerleader?

Thanks for the link Charles.

Well I’ve found myself needing to generate hashes in Java apps a couple of times, and have found myself very disappointed in the amount of code required to perform what seems to me like a very mundane task. Simply put, it’s a pain in the butt.

So, I wrote a simple Java class with a single static method to do just that. To use it just type:


String myHash = DigestUtil.computeHexDigest(DigestUtil.ALGORITHM_MD5, "your favorite string goes here");


And that’s that. Well, it’ll never be as simple as but this beats the pants off doing it manually.

So, without further adieu, here’s the code ripe for copying-and-pasting into your app. Sorry for the formatting, WordPress is giving me trouble.

–BEGIN CODE SNIPPET–

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class DigestUtil
{
/**
* Constant representing the MD2 hash algorithm
*/
public static String ALGORITHM_MD2 = “MD2″;

/**
* Constant representing the MD5 hash algorithm
*/
public static String ALGORITHM_MD5 = “MD5″;

/**
* Constant representing the SHA-1 hash algorithm
*/
public static String ALGORITHM_SHA1 = “SHA-1″;

/**
* Constant representing the SHA-256 hash algorithm
*/
public static String ALGORITHM_SHA256 = “SHA-256″;

/**
* Constant representing the SHA-384 hash algorithm
*/
public static String ALGORITHM_SHA384 = “SHA-384″;

/**
* Constant representing the SHA-512 hash algorithm
*/
public static String ALGORITHM_SHA512 = “SHA-512″;

/**
*
* Computes the hexadecimal hash key for <em>input</em> using given <em>algorithm</em>
*
* @param algorithm
* @param input
* @return
* @throws NoSuchAlgorithmException
*
*/
public static String computeHexDigest(String algorithm, String input)
throws NoSuchAlgorithmException
{
byte [] inputBytes = input.getBytes();
MessageDigest md = MessageDigest.getInstance(algorithm);
byte [] digest = md.digest(inputBytes);
BigInteger bigNumber = new BigInteger(1, digest);
String hash = bigNumber.toString(16);

if ( hash.length() < 64 )
{
StringBuffer buf = new StringBuffer();

for ( int i = 1; i < 64 – hash.length(); i++ )
{
buf.append(“0″);
}

hash = buf.toString() + hash;
}

return hash;
}

}

–END CODE SNIPPET–

This specification should be read like all other specifications. First, it should be read cover-to-cover, multiple times. Then, it should be read backwards at least once. Then it should be read by picking random sections from the contents list and following all the cross-references.

Just as an exercise I wrote a regex for parsing a url. I’m sure it can be improved on (for example, it won’t deal with an “@” symbol) but for regular web addresses it will be quite useful. Copy and paste into Rubular for a demo.

Regex:
^(\w+):(?:\/\/)?([\w.]+)(\/(?:\w*/)*)(\w+)(\.\w+)?(?:\?([\w=&]*))?$

Test string:
https://www.example.com/parent/child/resource.xml?query=something&sort=asc

I’m looking forward to when Ruby changes its regex engine to Onigurama, then I can do this:


^(?<protocol>\w+):(?:\/\/)?(?<domain>[\w.]+)(?<path>\/(?:\w*/)*)(?<resource>\w+)(?<format>\.\w+)?(?:\?(?:<query_string>[\w=&]*))?$


This way I can refer to each capture by name. Onigurama is currently supported by the TextMate text editor.