class Lightning::Bolt::Codex

Public Class Methods

new(bookstore, theorems, memories) click to toggle source
# File lib/lightning/bolt.rb, line 12
def initialize(bookstore, theorems, memories)
  @cypher = Lightning::Bolt::Cypher.new(bookstore)
  @fuzzer = Lightning::Bolt::Fuzzer.new('UTF-8')
  @keys = YAML.load_file("#{File.dirname(__FILE__)}/bolt/keys.yml")
  @theorems = theorems
  @memories = memories
  @thoughts = []
end

Public Instance Methods

archive() click to toggle source
# File lib/lightning/bolt.rb, line 53
def archive
  return @memories
end
signal(mode, unique, name) click to toggle source
# File lib/lightning/bolt.rb, line 21
def signal(mode, unique, name)
  path = nil
  @theorems.each do | theorem |
    if theorem["name"].eql?(name)
      path = theorem["path"]
    end
  end
  return validate(mode, unique, path)
end
validate(mode, unique, path) click to toggle source
# File lib/lightning/bolt.rb, line 31
def validate(mode, unique, path)
  @mode = mode.eql?(nil) ? 'system' : mode
  unique = unique.eql?(nil) ? false : unique
  data = ""
  if path
    if unique
      is_unique = false
      while !is_unique
        data = decrypt(path)
        hash = Digest::SHA256.hexdigest(path)
        if @memories[hash].eql?(nil)
          @memories[hash] = data
          is_unique = true
        end
      end
    else
      data = decrypt(path)
    end
  end
  return data
end

Private Instance Methods

concat(rule) click to toggle source
# File lib/lightning/bolt.rb, line 229
def concat(rule)
  combinator = ""
  subrules = rule.split(Regexp.new(@keys["keys"]["and"]))
  subrules.each do | subrule |
    combinator += decrypt(subrule)
  end
  return rule.sub(rule, combinator)
end
datum(rule) click to toggle source
# File lib/lightning/bolt.rb, line 105
def datum(rule)
  datum = rule.scan(Regexp.new(@keys["keys"]["data"]))
  datum.each do | data |
    arc = @cypher.arc(data)
    if @mode.eql?('strict')
      rule = rule.sub(data, @fuzzer.random_character(arc.size))
    else
      rule = rule.sub(data, arc)
    end
  end
  return rule
end
decrypt(rule) click to toggle source
# File lib/lightning/bolt.rb, line 59
def decrypt(rule)
  rule = rotar(rule, @keys["keys"]["reference"]) ? references(rule) : rule
  rule = rotar(rule, @keys["keys"]["data"]) ? datum(rule) : rule
  rule = rotar(rule, @keys["keys"]["group"]) ? group(rule) : rule
  rule = rotar(rule, @keys["keys"]["repeat"]) ? repeat(rule) : rule
  rule = rotar(rule, @keys["keys"]["set"]) ? set(rule) : rule
  rule = rotar(rule, @keys["keys"]["or"]) ? either(rule) : rule
  rule = rotar(rule, @keys["keys"]["and"]) ? concat(rule) : rule
  rule = rotar(rule, @keys["keys"]["exist"]) ? exist(rule) : rule
  rule = rotar(rule, @keys["keys"]["escapable"]) ? escapable(rule) : rule
  rule = rotar(rule, @keys["keys"]["memorize"]) ? remember(rule) : rule
  return rule
end
either(rule) click to toggle source
# File lib/lightning/bolt.rb, line 209
def either(rule)
  subrules = rule.split(Regexp.new(@keys["keys"]["not"] + "?" + @keys["keys"]["or"]))
  testcases = Array.new
  subrules.each do | subrule |
    if !@mode.eql?('regression') && !subrule[1].eql?(@keys["keys"]["not"])
      testcases.push(subrule)
    elsif @mode.eql?('regression') && subrule[1].eql?(@keys["keys"]["not"])
      testcases.push(subrule)
    end
  end
  subrule = ""
  if testcases.size > 0
    subrule = testcases[@fuzzer.random_number(0,subrules.length)]
  else
    subrule = subrules[@fuzzer.random_number(0,subrules.length)]
  end
  rule = rule.sub(rule, decrypt(subrule))
  return rule
end
escapable(rule) click to toggle source
# File lib/lightning/bolt.rb, line 291
def escapable(rule)
  escapes = rule.scan(Regexp.new(@keys["keys"]["escapable"]))
  escapes.each do | escape |
    if @mode.eql?('strict')
      rule = rule.sub(escape, @fuzzer.random_character(1))
    elsif escape[1..-1].eql?(@keys["keys"]["any"])
      rule = rule.sub(escape, @fuzzer.random_character(1))
    else
      rule = rule.sub(escape, escape[1..-1])
    end
  end
  return decrypt(rule)
end
exists(rule) click to toggle source
# File lib/lightning/bolt.rb, line 238
def exists(rule)
  group_ranges = rule.match(Regexp.new(@keys["keys"]["group"] + @keys["keys"]["exist"]))
  set_ranges = rule.match(Regexp.new(@keys["keys"]["set"] + @keys["keys"]["exist"]))
  ranges = []
  ranges += group_ranges.eql?(nil) ? [] : group_ranges[0..-1]
  ranges += set_ranges.eql?(nil) ? [] : set_ranges[0..-1]
  if ranges
    ranges.each do | range |
      range_set = range.match(Regexp.new(@keys["keys"]["exist"]))
      if range_set
        subrule = ""
        if @fuzzer.random_number(0,1).eql(1)
          subrule = rule[0..rule.size-2]
        end
        rule = rule.sub(rule, decrypt(subrule))
      end
    end
  end
  return rule
end
group(rule) click to toggle source
# File lib/lightning/bolt.rb, line 118
def group(rule)
  groups = rule.scan(Regexp.new(@keys["keys"]["not"] + "?" + @keys["keys"]["group"]))
  invalid_groups = rule.scan(Regexp.new(@keys["keys"]["not"] + @keys["keys"]["group"]))
  groups.each do | group |
    group = group.join("")
    if invalid_groups.size > 0 && @mode.eql?('regression') && group[1].eql?(@keys["keys"]["not"])
      rule = rule.sub(group, decrypt(group[2..-2]))
    else
      rule = rule.sub(group, decrypt(group[1..-2]))
    end
  end
  return rule
end
radar(map) click to toggle source
# File lib/lightning/bolt.rb, line 95
def radar(map)
  rule = ""
  @theorems.each do | theorem |
    if theorem["path"].eql?(map)
      rule = theorem["rule"]
    end
  end
  return rule
end
references(rule) click to toggle source
# File lib/lightning/bolt.rb, line 77
def references(rule)
  vars = rule.scan(Regexp.new(@keys["keys"]["reference"]))
  lock = false
  vars.each do | var |
    scan = radar(var)
    if scan.eql?("")
      lock = true
    else
      rule = rule.sub(var, radar(var))
    end
  end
  if lock
    return rule
  else
    return decrypt(rule)
  end
end
remember(rule) click to toggle source
# File lib/lightning/bolt.rb, line 305
def remember(rule)
  cortex = rule.scan(Regexp.new(@keys["keys"]["memorize"]))
  bank = rule.split("+:")
  hash = Digest::SHA256.hexdigest(bank[1])
  memory = @thoughts[hash]
  if memory
    return memory
  else
    rule = decrypt(bank[0])
    thought = decrypt(bank[0])
    @thoughts[hash] = thought
    return thought
  end
end
repeat(rule) click to toggle source
# File lib/lightning/bolt.rb, line 259
def repeat(rule)
  combinator = ""
  min = max = 0
  invalidate = rule.match(Regexp.new(@keys["keys"]["not"]))
  rule = (!invalidate.eql?(nil)) ? rule[1..-1] : rule
  repeater = rule.scan(Regexp.new(@keys["keys"]["repeat"]))[0]
  if repeater
    rule = rule.sub(repeater, "")
    range = repeater.to_s[1..-2].split(":")
    if @mode.eql?('strict') && invalidate
      min = @fuzzer.random_number(0,min)
      max = @fuzzer.random_number(min, rand(max + 9))
    else
      min = range[0].to_i()
      max = range[1].to_i()
    end
    if min.eql?(max)
      (0..max-1).each do | i |
        combinator += decrypt(rule)
      end
    else
      (0..min-1).each do | i |
         combinator += decrypt(rule)
      end
      (min..max-min).each do | i |
         combinator += decrypt(rule)
      end
    end
  end
  return rule.sub(rule, combinator)
end
rotar(rule, expr) click to toggle source
# File lib/lightning/bolt.rb, line 73
def rotar(rule, expr)
  return (rule.scan(Regexp.new(expr)).size > 0)
end
ruleset(subset) click to toggle source
# File lib/lightning/bolt.rb, line 181
def ruleset(subset)
  charset = []
  if subset
    if subset.size == 3
      set_range = subset.split("-")
      if set_range.size == 2
        min = set_range[0]
        max = set_range[1]
        range_set = []
        (min..max).each do | range |
          range_set.push(range)
        end
        if range_set.size == 1
          (max..min).each do | range |
            range_set.push(range)
          end
        end
        charset += range_set
      end
    elsif subset.size == 2 && subset[0].eql?("\\")
      charset.push(subset[1])
    else
      charset.push(subset)
    end
  end
  return charset
end
set(rule) click to toggle source
# File lib/lightning/bolt.rb, line 132
def set(rule)
  sets = rule.scan(Regexp.new(@keys["keys"]["set"]))
  if sets
    sets.each do | set |
      rangesets = set[0].scan(Regexp.new(@keys["keys"]["not"] + "?" + @keys["keys"]["range"]))
      subsets = set[0].scan(Regexp.new(@keys["keys"]["not"] + "?" + @keys["keys"]["subsets"]))
      if rangesets.size > 0
        rangesets.each do | rangeset |
          subranges = Array.new
          if !@mode.eql?('regression') && !rangeset[1].eql?(@keys["keys"]["not"][1])
            subrangeset = rangeset[1..-2].split("..")
            (subrangeset[0]..subrangeset[1]).each do | x |
              subranges.push(x)
            end
            if subranges.size == 1
              subranges = Array.new
              (subrangeset[1]..subrangeset[0]).each do | x |
                subranges.push(x)
              end
            end
          else
            subranges.push(@fuzzer.random_character(1))
          end
          swap = subranges[@fuzzer.random_number(0,subranges.size)]
          rule = rule.sub(rangeset, swap)
        end
      elsif subsets.size > 0
        charset = []
        subsets.each do | subset |
          if subset
            if @mode.eql?('strict')
              charset.push(@fuzzer.random_character(1))
            elsif @mode.eql?('regression') && subset[0][1].eql?(@keys["keys"]["not"][1])
              charset.push(ruleset([subset[0][1..-1]]))
            else
              charset.push(ruleset(subset[0]))
            end
          end
        end
        if charset.size > 0
          char = charset[0][@fuzzer.random_number(0,charset.size)]
          rule = rule.sub(set[0], char)
        end
      end
    end
  end
  return (rule)
end