quality-measure-engine 0.1.2 → 0.2.0

data/lib/qme/map/map_reduce_executor.rb

@@ -1,31 +1,115 @@
 module QME
   module MapReduce
+
+    # Computes the value of quality measures based on the current set of patient
+    # records in the database
     class Executor
+    
+      # Create a new Executor for the supplied database connection
       def initialize(db)
         @db = db
       end
 
-      def measure_def(measure_id)
+      # Retrieve a measure definition from the database
+      # @param [String] measure_id value of the measure's id field
+      # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
+      # @return [Hash] a JSON hash of the encoded measure
+      def measure_def(measure_id, sub_id=nil)
         measures = @db.collection('measures')
-        measures.find({'id'=> "#{measure_id}"}).to_a[0]
+        if sub_id
+          measures.find_one({'id'=>measure_id, 'sub_id'=>sub_id})
+        else
+          measures.find_one({'id'=>measure_id})
+        end
       end
 
-      def measure_result(measure_id, parameter_values)
+      # Compute the specified measure
+      # @param [String] measure_id value of the measure's id field
+      # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
+      # @param [Hash] parameter_values a hash of the measure parameter values. Keys may be either a String or Symbol
+      # @return [Hash] a hash of the measure result with Symbol keys: population, denominator, numerator, antinumerator and exclusions whose values are the count of patient records that meet the criteria for each component of the measure. Also included are keys: population_members, denominator_members, numerator_members, antinumerator_members and exclusions_members whose values are arrays of the patient record identifiers that meet the criteria for each component of the measure.
+      def measure_result(measure_id, sub_id, parameter_values)
         
-        measure = Builder.new(measure_def(measure_id), parameter_values)
+        cache = @db.collection("query_cache")
+        cache_q = {:measure_id=>measure_id, :sub_id=>sub_id,:effective_date=>parameter_values[:effective_date]}
+        result = cache.find_one(cache_q)
+        unless result
+          measure = Builder.new(@db, measure_def(measure_id, sub_id), parameter_values)
 
-        records = @db.collection('records')
-        results = records.map_reduce(measure.map_function, measure.reduce_function)
-        result = results.find.to_a[0]
+          records = @db.collection('records')
+          results = records.map_reduce(measure.map_function, measure.reduce_function)
+          result = results.find_one # only one key is used by map fn
+          result['value']['cache_name'] = cache_name(measure_id,sub_id,parameter_values[:effective_date])
+          cache_q["value"] =result['value']
+          cache << cache_q
+          
+          cache_measure_patients(measure_id,sub_id,parameter_values[:effective_date],result['value'])
+        end  
+        
         value = result['value']
+        summary = {}
+        %w(population denominator numerator antinumerator exclusions).each do |field|
+          summary[field.intern] = value[field].length
+          summary[(field+'_members').intern] = value[field]
+        end
+        summary
 
-        {
-          :population=>value['i'].to_i,
-          :denominator=> value['d'].to_i,
-          :numerator=> value['n'].to_i,
-          :exceptions=> value['e'].to_i
-        }
       end
+      
+      # Return a list of the measures in the database
+      # @return [Hash] an hash of measure definitions
+      def all_measures
+        result = {}
+        measures = @db.collection('measures')
+        measures.find().each do |measure|
+          id = measure['id']
+          sub_id = measure['sub_id']
+          measure_id = "#{id}#{sub_id}.json"
+          result[measure_id] ||= measure
+        end
+        result
+      end
+      
+      
+      private 
+      
+      
+      def cache_name(measure_id, sub_id, effective_date)
+        "cached_measure_patients_#{measure_id}_#{sub_id}_#{effective_date}"
+      end
+      
+       #  Private method to cache the patient record for a particular measure and effective time.  This also caches if they are part of the denominator, numeratore ..... which will be used for sorting.
+        # @param [String] measure_id value of the measure's id field
+        # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
+        # @param [Integer] effective_date the effective date used by the map reduce function to calculate popultion, denominator ....... 
+      def cache_measure_patients(measure_id, sub_id, effective_date, results,drop=true)
+        col_name =cache_name(measure_id, sub_id, effective_date)
+        @db.collection(col_name).drop if drop
+        cached_patients =  @db.collection(col_name)
+        population = results['population']
+        if population
+        records =   @db.collection("records").find('_id' => {'$in' => results['population']})
+        records.each do |record|
+          record_id = record['_id']
+          new_record = {:first=>record['first'],
+                     :last=>record['last'],
+                     :birthdate=>record['birthdate'],
+                     :gender=>record['gender'],
+                     :measure_id => measure_id,
+                     :sub_id=>sub_id,
+                     :effective_date => effective_date,
+                     :measure_data => record[measure_id],
+                     :numerator=>!results['numerator'].index(record_id).nil?,
+                     :denominator=>!results['denominator'].index(record_id).nil?,
+                     :exclusion=>!results['exclusions'].index(record_id).nil?,
+                     :antinumerator=>!results['antinumerator'].index(record_id).nil?}
+                     
+            cached_patients << new_record         
+          
+        end
+      end
+      end
+      
     end
   end
 end

data/lib/qme/measure/database_loader.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__),'measure_loader')
+
+module QME
+  module Database
+  
+    # Utility class for working with JSON files and the database
+    class Loader
+      # Create a new Loader. Database host and port may be set using the 
+      # environment variables TEST_DB_HOST and TEST_DB_PORT which default
+      # to localhost and 27017 respectively.
+      # @param [String] db_name the name of the database to use
+      def initialize(db_name)
+        @db_name = db_name
+        @db_host = ENV['TEST_DB_HOST'] || 'localhost'
+        @db_port = ENV['TEST_DB_PORT'] ? ENV['TEST_DB_PORT'].to_i : 27017
+      end
+      
+      # Lazily creates a connection to the database and initializes the
+      # JavaScript environment
+      # @return [Mongo::Connection]
+      def get_db
+        if @db==nil
+          @db = Mongo::Connection.new(@db_host, @db_port).db(@db_name)
+          QME::MongoHelpers.initialize_javascript_frameworks(@db)
+        end
+        @db
+      end
+      
+      # Load a measure from the filesystem and save it in the database.
+      # @param [String] measure_dir path to the directory containing a measure or measure collection document
+      # @param [String] collection_name name of the database collection to save the measure into.
+      # @return [Array] the stroed measures as an array of JSON measure hashes
+      def save_measure(measure_dir, collection_name)
+        measures = QME::Measure::Loader.load_measure(measure_dir)
+        measures.each do |measure|
+          save(collection_name, measure)
+        end
+        measures
+      end
+      
+      # Save a JSON hash to the specified collection, creates the
+      # collection if it doesn't already exist.
+      # @param [String] collection_name name of the database collection
+      # @param [Hash] json the JSON hash to save in the database 
+      def save(collection_name, json)
+        collection = get_db.create_collection(collection_name)
+        collection.save(json)
+      end
+      
+      # Drop a database collection
+      # @param [String] collection_name name of the database collection
+      def drop_collection(collection_name)
+        get_db.drop_collection(collection_name)
+      end
+      
+      
+      # Save a bundle to the db,  this will save the bundle meta data, javascript extension functions and measures to 
+      # the db in their respective loacations
+      # @param [String] bundle_dir the bundle directory
+      # @param [String] bundle_collection the collection to save the bundle meta_data and extension functions to
+      # @param [String] measure_collection the collection to save the measures to, defaults to measures
+      def save_bundle(bundle_dir,bundle_collection, measure_collection = 'measures')
+        bundle = QME::Measure::Loader.load_bundle(bundle_dir)
+        bundle[:bundle_data][:measures] = []
+        b_id = save(bundle_collection,bundle[:bundle_data])
+        measures = bundle[:measures]
+        measures.each do |measure|
+           measure[:bundle] = b_id
+           m_id = save(measure_collection,measure)
+           bundle[:bundle_data][:measures] << m_id
+        end
+        save(bundle_collection,bundle[:bundle_data])
+        bundle[:bundle_data][:extensions].each do |ext|
+          get_db.eval(ext)
+        end
+        bundle
+      end
+      
+      
+      def remove_bundle(bundle_id, bundle_collection = 'bundles', measure_collection = 'measures')
+        bundle = get_db[bundle_collection].find_one(bundle_id)
+        bundle['measures'].each do |measure|
+          mes = get_db[measure_collection].find_one(measure)
+          get_db[measure_collection].remove(mes)
+        end
+        get_db[bundle_collection].remove(bundle)
+      end
+    end
+  end
+end

data/lib/qme/measure/measure_loader.rb

@@ -0,0 +1,141 @@
+gem 'rubyzip'
+require 'json'
+require 'zip/zip'
+require 'zip/zipfilesystem'
+
+module QME
+  module Measure
+  
+    # Utility class for working with JSON measure definition files
+    class Loader
+
+      # Load a measure from the filesystem
+      # @param [String] measure_dir path to the directory containing a measure or measure collection document
+      # @return [Array] the measures as an array of JSON measure hashes
+      def self.load_measure(measure_dir)
+        measures = []
+        Dir.glob(File.join(measure_dir, '*.col')).each do |collection_file|
+          component_dir = File.join(measure_dir, 'components')
+          load_collection(collection_file, component_dir).each do |measure|
+            measures << measure
+          end
+        end
+        Dir.glob(File.join(measure_dir, '*.json')).each do |measure_file|
+          files = Dir.glob(File.join(measure_dir,'*.js'))
+          if files.length!=1
+            raise "Unexpected number of map functions in #{measure_dir}, expected 1"
+          end
+          map_file = files[0]
+          measure = load_measure_file(measure_file, map_file)
+          measures << measure
+        end
+        measures
+      end
+      
+      # Load a collection of measures definitions by processing a collection
+      # definition file.
+      # @param [String] collection_file path of the collection definition file
+      # @param [String] component_dir path to the directory that contains the measure components
+      # @return [Array] an array of measure definition JSON hashes
+      def self.load_collection(collection_file, component_dir)
+        collection_def = JSON.parse(File.read(collection_file))
+        measure_file = File.join(component_dir, collection_def['root'])
+        measures = []
+        collection_def['combinations'].each do |combination|
+          map_file = File.join(component_dir, combination['map_fn'])
+          measure = load_measure_file(measure_file, map_file)
+          # add inline metadata to top level of definition
+          combination['metadata'] ||= {}
+          combination['metadata'].each do |key, value|
+            measure[key] = value
+          end
+          # add inline measure-specific properties to definition
+          combination['measure'] ||= {}
+          measure['measure'] ||= {}
+          combination['measure'].each do |key, value|
+            measure['measure'][key] = value
+          end
+          ['population', 'denominator', 'numerator', 'exclusions'].each do |component|
+            if combination[component]
+              measure[component] = load_json(component_dir, combination[component])
+            end
+          end
+          measures << measure
+        end
+        measures
+      end
+      
+      # For ease of development, measure definition JSON files and JavaScript 
+      # map functions are stored separately in the file system, this function 
+      # combines the two and returns the result
+      # @param [String] measure_file path to the measure file
+      # @param [String] map_fn_file path to the map function file
+      # @return [Hash] a JSON hash of the measure with embedded map function.
+      def self.load_measure_file(measure_file, map_fn_file)
+        map_fn = File.read(map_fn_file)
+        measure = JSON.parse(File.read(measure_file))
+        measure['map_fn'] = map_fn
+        measure
+      end
+      
+      # Load a JSON file from the specified directory
+      # @param [String] dir_path path to the directory containing the JSON file
+      # @param [String] filename the JSON file
+      # @return [Hash] the parsed JSON hash
+      def self.load_json(dir_path, filename)
+        file_path = File.join(dir_path, filename)
+        JSON.parse(File.read(file_path))
+      end
+      
+      
+      #Load a bundle from a directory
+      #@param [String] bundel_path path to directory containing the bundle information
+      
+      def self.load_bundle(bundle_path)
+        bundle = {};
+        bundle_file = File.join(bundle_path,'bundle.js')
+        
+        bundle[:bundle_data] =  File.exists?(bundle_file) ? JSON.parse(File.read(bundle_file)) : JSON.parse("{}")
+        bundle[:bundle_data][:extensions] = load_bundle_extensions(bundle_path)
+        bundle[:measures] = []
+        Dir.glob(File.join(bundle_path, 'measures', '*')).each do |measure_dir|
+          load_measure(measure_dir).each do |measure|
+            bundle[:measures] << measure
+          end
+        end
+        bundle
+      end
+      
+      
+      # Load all of the extenson functions that will be available to map reduce functions from the bundle dir
+      # This will load from bundle_path/js and from ext directories in the individule measures directories 
+      # like bundle_path/measures/0001/ext/ 
+      #@param [String] bundle_path the path to the bundle directory
+      def self.load_bundle_extensions(bundle_path)
+        extensions = []
+        Dir.glob(File.join(bundle_path, 'js', '*.js')).each do |js_file|
+          raw_js = File.read(js_file)
+           extensions << raw_js
+        end
+        Dir.glob(File.join(bundle_path, 'measures', '*','ext', '*.js')).each do |js_file|
+          raw_js = File.read(js_file)
+          extensions << raw_js
+        end
+        extensions
+      end
+      
+      
+      def self.load_from_zip(archive)
+            unzip_path = "./tmp/#{Time.new.to_i}/" 
+            FileUtils.mkdir_p(unzip_path)
+            all_measures = []
+            Zip::ZipFile.foreach(archive) do |zipfile|
+              fname = unzip_path+ zipfile.name
+              FileUtils.rm fname, :force=>true
+              zipfile.extract(fname)
+            end
+           load_bundle(unzip_path)
+      end
+    end
+  end
+end

data/lib/qme/mongo_helpers.rb

@@ -0,0 +1,15 @@
+module QME
+  module MongoHelpers
+    # Evaluates underscore.js in the "js" directory of this project on
+    # the Mongo database passed in. This will make the library available
+    # to subsiquent calls on the database. This is useful for queries with 
+    # where clauses or MapReduce functions
+    #
+    # @param [Mongo::DB] db The database to evaluate the JavaScript on
+    def self.initialize_javascript_frameworks(db,bundle_collection = 'bundles')
+      underscore_js = File.read(File.join(File.dirname(__FILE__), '..', '..', 'js', 'underscore-min.js'))
+      db.eval(underscore_js)
+    end
+    
+  end
+end

data/lib/qme/randomizer/patient_randomizer.rb

@@ -0,0 +1,95 @@
+require 'erb'
+
+module QME
+  module Randomizer
+  
+    # Provides functionality for randomizing patient records based on erb templates
+    class Patient
+
+      # Utility class used to supply a binding to Erb
+      class Context
+        # Create a new context
+        def initialize()
+          @genders = ['M', 'F']
+          # 300 most popular forenames according to US census 1990
+          @forenames = {
+            'M' => %w{James John Robert Michael William David Richard Charles Joseph Thomas Christopher Daniel Paul Mark Donald George Kenneth Steven Edward Brian Ronald Anthony Kevin Jason Matthew Gary Timothy Jose Larry Jeffrey Frank Scott Eric Stephen Andrew Raymond Gregory Joshua Jerry Dennis Walter Patrick Peter Harold Douglas Henry Carl Arthur Ryan Roger Joe Juan Jack Albert Jonathan Justin Terry Gerald Keith Samuel Willie Ralph Lawrence Nicholas Roy Benjamin Bruce Brandon Adam Harry Fred Wayne Billy Steve Louis Jeremy Aaron Randy Howard Eugene Carlos Russell Bobby Victor Martin Ernest Phillip Todd Jesse Craig Alan Shawn Clarence Sean Philip Chris Johnny Earl Jimmy Antonio Danny Bryan Tony Luis Mike Stanley Leonard Nathan Dale Manuel Rodney Curtis Norman Allen Marvin Vincent Glenn Jeffery Travis Jeff Chad Jacob Lee Melvin Alfred Kyle Francis Bradley Jesus Herbert Frederick Ray Joel Edwin Don Eddie Ricky Troy Randall Barry Alexander Bernard Mario Leroy Francisco Marcus Micheal Theodore Clifford Miguel Oscar Jay Jim Tom Calvin Alex Jon Ronnie Bill Lloyd Tommy Leon Derek Warren Darrell Jerome Floyd Leo Alvin Tim Wesley Gordon Dean Greg Jorge Dustin Pedro Derrick Dan Lewis Zachary Corey Herman Maurice Vernon Roberto Clyde Glen Hector Shane Ricardo Sam Rick Lester Brent Ramon Charlie Tyler Gilbert Gene Marc Reginald Ruben Brett Angel Nathaniel Rafael Leslie Edgar Milton Raul Ben Chester Cecil Duane Franklin Andre Elmer Brad Gabriel Ron Mitchell Roland Arnold Harvey Jared Adrian Karl Cory Claude Erik Darryl Jamie Neil Jessie Christian Javier Fernando Clinton Ted Mathew Tyrone Darren Lonnie Lance Cody Julio Kelly Kurt Allan Nelson Guy Clayton Hugh Max Dwayne Dwight Armando Felix Jimmie Everett Jordan Ian Wallace Ken Bob Jaime Casey Alfredo Alberto Dave Ivan Johnnie Sidney Byron Julian Isaac Morris Clifton Willard Daryl Ross Virgil Andy Marshall Salvador Perry Kirk Sergio Marion Tracy Seth Kent Terrance Rene Eduardo Terrence Enrique Freddie Wade},
+            'F' => %w{Mary Patricia Linda Barbara Elizabeth Jennifer Maria Susan Margaret Dorothy Lisa Nancy Karen Betty Helen Sandra Donna Carol Ruth Sharon Michelle Laura Sarah Kimberly Deborah Jessica Shirley Cynthia Angela Melissa Brenda Amy Anna Rebecca Virginia Kathleen Pamela Martha Debra Amanda Stephanie Carolyn Christine Marie Janet Catherine Frances Ann Joyce Diane Alice Julie Heather Teresa Doris Gloria Evelyn Jean Cheryl Mildred Katherine Joan Ashley Judith Rose Janice Kelly Nicole Judy Christina Kathy Theresa Beverly Denise Tammy Irene Jane Lori Rachel Marilyn Andrea Kathryn Louise Sara Anne Jacqueline Wanda Bonnie Julia Ruby Lois Tina Phyllis Norma Paula Diana Annie Lillian Emily Robin Peggy Crystal Gladys Rita Dawn Connie Florence Tracy Edna Tiffany Carmen Rosa Cindy Grace Wendy Victoria Edith Kim Sherry Sylvia Josephine Thelma Shannon Sheila Ethel Ellen Elaine Marjorie Carrie Charlotte Monica Esther Pauline Emma Juanita Anita Rhonda Hazel Amber Eva Debbie April Leslie Clara Lucille Jamie Joanne Eleanor Valerie Danielle Megan Alicia Suzanne Michele Gail Bertha Darlene Veronica Jill Erin Geraldine Lauren Cathy Joann Lorraine Lynn Sally Regina Erica Beatrice Dolores Bernice Audrey Yvonne Annette June Samantha Marion Dana Stacy Ana Renee Ida Vivian Roberta Holly Brittany Melanie Loretta Yolanda Jeanette Laurie Katie Kristen Vanessa Alma Sue Elsie Beth Jeanne Vicki Carla Tara Rosemary Eileen Terri Gertrude Lucy Tonya Ella Stacey Wilma Gina Kristin Jessie Natalie Agnes Vera Willie Charlene Bessie Delores Melinda Pearl Arlene Maureen Colleen Allison Tamara Joy Georgia Constance Lillie Claudia Jackie Marcia Tanya Nellie Minnie Marlene Heidi Glenda Lydia Viola Courtney Marian Stella Caroline Dora Jo Vickie Mattie Terry Maxine Irma Mabel Marsha Myrtle Lena Christy Deanna Patsy Hilda Gwendolyn Jennie Nora Margie Nina Cassandra Leah Penny Kay Priscilla Naomi Carole Brandy Olga Billie Dianne Tracey Leona Jenny Felicia Sonia Miriam Velma Becky Bobbie Violet Kristina Toni Misty Mae Shelly Daisy Ramona Sherri Erika Katrina Claire}
+          }
+          # 500 most popular surnames according to US census 1990
+          @surnames = %w{Smith Johnson Williams Jones Brown Davis Miller Wilson Moore Taylor Anderson Thomas Jackson White Harris Martin Thompson Garcia Martinez Robinson Clark Rodriguez Lewis Lee Walker Hall Allen Young Hernandez King Wright Lopez Hill Scott Green Adams Baker Gonzalez Nelson Carter Mitchell Perez Roberts Turner Phillips Campbell Parker Evans Edwards Collins Stewart Sanchez Morris Rogers Reed Cook Morgan Bell Murphy Bailey Rivera Cooper Richardson Cox Howard Ward Torres Peterson Gray Ramirez James Watson Brooks Kelly Sanders Price Bennett Wood Barnes Ross Henderson Coleman Jenkins Perry Powell Long Patterson Hughes Flores Washington Butler Simmons Foster Gonzales Bryant Alexander Russell Griffin Diaz Hayes Myers Ford Hamilton Graham Sullivan Wallace Woods Cole West Jordan Owens Reynolds Fisher Ellis Harrison Gibson Mcdonald Cruz Marshall Ortiz Gomez Murray Freeman Wells Webb Simpson Stevens Tucker Porter Hunter Hicks Crawford Henry Boyd Mason Morales Kennedy Warren Dixon Ramos Reyes Burns Gordon Shaw Holmes Rice Robertson Hunt Black Daniels Palmer Mills Nichols Grant Knight Ferguson Rose Stone Hawkins Dunn Perkins Hudson Spencer Gardner Stephens Payne Pierce Berry Matthews Arnold Wagner Willis Ray Watkins Olson Carroll Duncan Snyder Hart Cunningham Bradley Lane Andrews Ruiz Harper Fox Riley Armstrong Carpenter Weaver Greene Lawrence Elliott Chavez Sims Austin Peters Kelley Franklin Lawson Fields Gutierrez Ryan Schmidt Carr Vasquez Castillo Wheeler Chapman Oliver Montgomery Richards Williamson Johnston Banks Meyer Bishop Mccoy Howell Alvarez Morrison Hansen Fernandez Garza Harvey Little Burton Stanley Nguyen George Jacobs Reid Kim Fuller Lynch Dean Gilbert Garrett Romero Welch Larson Frazier Burke Hanson Day Mendoza Moreno Bowman Medina Fowler Brewer Hoffman Carlson Silva Pearson Holland Douglas Fleming Jensen Vargas Byrd Davidson Hopkins May Terry Herrera Wade Soto Walters Curtis Neal Caldwell Lowe Jennings Barnett Graves Jimenez Horton Shelton Barrett Obrien Castro Sutton Gregory Mckinney Lucas Miles Craig Rodriquez Chambers Holt Lambert Fletcher Watts Bates Hale Rhodes Pena Beck Newman Haynes Mcdaniel Mendez Bush Vaughn Parks Dawson Santiago Norris Hardy Love Steele Curry Powers Schultz Barker Guzman Page Munoz Ball Keller Chandler Weber Leonard Walsh Lyons Ramsey Wolfe Schneider Mullins Benson Sharp Bowen Daniel Barber Cummings Hines Baldwin Griffith Valdez Hubbard Salazar Reeves Warner Stevenson Burgess Santos Tate Cross Garner Mann Mack Moss Thornton Dennis Mcgee Farmer Delgado Aguilar Vega Glover Manning Cohen Harmon Rodgers Robbins Newton Todd Blair Higgins Ingram Reese Cannon Strickland Townsend Potter Goodwin Walton Rowe Hampton Ortega Patton Swanson Joseph Francis Goodman Maldonado Yates Becker Erickson Hodges Rios Conner Adkins Webster Norman Malone Hammond Flowers Cobb Moody Quinn Blake Maxwell Pope Floyd Osborne Paul Mccarthy Guerrero Lindsey Estrada Sandoval Gibbs Tyler Gross Fitzgerald Stokes Doyle Sherman Saunders Wise Colon Gill Alvarado Greer Padilla Simon Waters Nunez Ballard Schwartz Mcbride Houston Christensen Klein Pratt Briggs Parsons Mclaughlin Zimmerman French Buchanan Moran Copeland Roy Pittman Brady Mccormick Holloway Brock Poole Frank Logan Owen Bass Marsh Drake Wong Jefferson Park Morton Abbott Sparks Patrick Norton Huff Clayton Massey Lloyd Figueroa Carson Bowers Roberson Barton Tran Lamb Harrington Casey Boone Cortez Clarke Mathis Singleton Wilkins Cain Bryan Underwood Hogan Mckenzie Collier Luna Phelps Mcguire Allison Bridges Wilkerson Nash Summers Atkins}
+        end
+        
+        # Pick a gender at random
+        # @return 'M' or 'F'
+        def gender
+          @genders[rand(@genders.length)]
+        end
+        
+        # Pick a forename at random appropriate for the supplied gender
+        # @param [String] gender the gender 'M' or 'F'
+        # @return a suitable forename
+        def forename(gender)
+          @forenames[gender][rand(@forenames[gender].length)]
+        end
+        
+        # Pick a surname at random
+        # @return a surname
+        def surname
+          @surnames[rand(@surnames.length)]
+        end
+        
+        # Return a set of randomly selected numbers between two bounds
+        # @param [int] min the lower inclusive bound
+        # @param [int] max the upper inclusive bound
+        # @param [int] least the minimum count to return
+        # @param [int] most the maximum count to return
+        # @return [String] a JSON format array of numbers
+        def n_between(min, max, least=1, most=1)
+          count = least+rand(1+most-least).to_i
+          result = []
+          count.times do
+            result << between(min, max)
+          end
+          result.to_json
+        end
+      
+        # Return a randomly selected number between two bounds
+        # @param [int] min the lower inclusive bound
+        # @param [int] max the upper inclusive bound
+        # @return [int] a JSON format array of numbers
+        def between(min, max)
+          span = max.to_i - min.to_i + 1
+          min.to_i+rand(span)
+        end
+        
+        # Pick true or false according to the supplied probability
+        # @param [int] probability the probability of getting true as a percentage
+        # @return [boolean] true or false
+        def percent(probability)
+          return rand(100)<probability
+        end
+      
+        # Get a binding that for the current instance
+        # @return [Binding]
+        def get_binding
+          binding
+        end
+      end
+
+      # Create a new instance with the supplied template
+      # @param [String] patient the patient template
+      def initialize(patient)
+        @template = ERB.new(patient)
+      end
+      
+      # Get a randomized record based on the stored template
+      # @return [String] a randomized patient
+      def get
+        context = Context.new()
+        @template.result(context.get_binding)
+      end
+
+    end
+  end
+end