lightning-bolt 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7471df6d70bb592054a2af7c3c5c1ff1ab8c0f8c
-  data.tar.gz: 6f7524eb8b95366ce4150421d5bd3e1811d242f5
+  metadata.gz: 14a570b0301f4b6762152de51c14bde142aa8758
+  data.tar.gz: 1635e9d632ba71791d6217758c6b81cdaeb515c5
 SHA512:
-  metadata.gz: 632a6d4885dadc45b4457835aa83ca31544da964300b9bd4283e21c04fa5773b488edd298b962de8332e970c50f354e8cab0e7396cd86e9334da625afc2bf3d0
-  data.tar.gz: daaf4a3fdd304dd0e1983ee2158613a259bfdd9b66b8c910ea737abd3f8ce5a802e8de9167de9a192b44881182eff3b9944df1c804f7049e3abb6dfdcb030bd8
+  metadata.gz: f88dc2d733b77040763b93c9a98460b7a598890d2fe6da34adb2a3c516d614c5e093b765ae2fe2621008096c55129a18f9fdc203a3e237650688e25ed521d4f7
+  data.tar.gz: 28a41fd9d4e93076228360f7ddbe24e74e5ca9ac11e10ca8bf334050f63dd60d22fc74796459049493d7a4beb560e331c135c6b614fe3ffc391205277e0015a2

data/lib/lightning/bolt/cli.rb

@@ -1,6 +1,7 @@
+require 'lightning/bolt'
 require 'thor'
 require 'yaml'
-require_relative "codex"
+
 module Lightning
   module Bolt
     class Storm < Thor

data/lib/lightning/bolt/fuzzer.rb

@@ -5,35 +5,37 @@ module Lightning
 
       def initialize(encoder)
         @encoder = encoder
-        @ftldrive = 0
-        @warp = Time.new.to_i
+        @alphabet = alphabet()
       end
 
       def random_number(min,max)
         return SecureRandom.random_number(max-min)+min
       end
 
-      def launch(seed, size, non_printable)
-        randomizer = seeder(seed)
-        addable = true
+      def random_character(seed, size, flags)
         enigma = ""
-        while(enigma.length < size)
-          rotar = randomizer.bytes(1)
-          if encodable?(rotar)
-            enigma += rotar
-          end
+        (0..size).each do | index |
+          engima += random_number(0,@alphabet.size)
         end
-        return enigma.encode(@encoder)
       end
 
       private
 
-      def seeder(seed)
-        time = Time.new.to_i
-        time += @ftldrive
-        @ftldrive = @ftldrive + 1
-        seed = seed.eql?(nil) ? time : seed
-        return Random.new(seed)
+      def alphabet
+        charset = []
+        0.upto(1112064) do |i|
+          char = nil
+          begin
+            char = "" << i
+          rescue
+          end
+          if !char.eql?(nil)
+            if encodable?(char)
+              charset.push(char.encode(@encoder))
+            end
+          end
+        end
+        return charset
       end
 
       def encodable?(rotar)

data/lib/lightning/bolt/templates/payload.yml

@@ -1,67 +1,116 @@
 ---
-vault: templates/codex
-records:
-  - en:
-      - us:
-          - states.yml
-          - domains.yml
-      - names.yml
-      - colors.yml
-  - it:
-      - names.yml
-  - fr:
-      - names.yml
-  - currency.yml
-  - characters.yml
-payload:
-- name: ""
-  reports:
-    email: ""
-  rules:
-    address: ""
-- name: ""
-  reports:
-    email: |-
-      Hello #:NAMES/EN/FULL_NAME,
-      News has reached us that on #:DATES/ACCEPTED_DATE,
-      you have received conformation that you will be attending
-      Kettering University. We are equally pleased to hear the news
-      and would like to extend the offer for you to intern with us as a coop.
-
-      Thank you,
-
-      Software Engineer @ #:MISC/COMPANY+company_sig
-      Email: #:MISC/EMAIL
-      Phone Number: #:MISC/PHONE_NUMBER
-    full_name: "#:NAMES/EN/FULL_NAME"
-    goog_email: "#:IT/FIRST_NAME.#:IT/LAST_NAME@COMPANY+goog.[com|org|net]"
-    hw_email: "#:IT/FIRST_NAME.#:IT/LAST_NAME@[helloworld|eprize]+hw.[com|org|net]"
-    test_email: "#:IT/FIRST_NAME.#:IT/LAST_NAME@COMPANY+test.[com|org|net]"
-
-  rules:
-    names:
-      en:
-        full_name: '#:FIRST_NAME #:MIDDLE_INITIAL #:LAST_NAME'
-        first_name: "=:en/us/first_names"
-        middle_initial: "[A-Z]"
-        last_name: "=:en/us/last_names"
-      it:
-        first_name: "=:it/first_names"
-        last_name: "=:it/last_names"
-    dates:
-      birth_date: "#:MONTH #:DAY #:BIRTH_YEAR #:TIME/HOUR #:TIME/MINUTE #:TIME/SECOND"
-      accepted_date: "#:MONTH #:DAY #:RECENT_YEAR #:TIME/HOUR #:TIME/MINUTE #:TIME/SECOND"
-      month: "=:en/months"
-      day: "=:en/days"
-      birth_year: "19[6-9][0-9]"
-      recent_year: "20((0[0-9])|(1[0-6]))"
-    time:
-      hour: "(0[1-9]) | (1[0-2])"
-      minute: "[0-5][0-9]"
-      second: "[0..59]"
-    misc:
-      domains: "=:en/us/domains"
-      area_code: "=:en/us/area_codes"
-      phone_number: " #:AREA_CODE-([0-9]{3:3})-([0-9]{4:4})"
-      email: "#:IT/FIRST_NAME.#:IT/LAST_NAME@COMPANY+company_sig.[com|org|net]"
-      company: "=:en/us/companies"
+theorems:
+  - name: "birth_date"
+    path: "#:identification-birth-date"
+    path: "#:identification-birth-date-range|#:identification-birth-date-norange"
+  - name: "birth_date_range"
+    path: "#:identification-birth-date-range"
+    rule: "#:birth-date-month&#:identification-birth-date-delimiter&#:identification-birth-year"
+  - name: "birth_date_month"
+    path: "#:birth-date-month"
+    rule: "(#:birth-date-feburary|#:birth-date-days-thirty-even|#:birth-date-days-thirty-odd)"
+  - name: "birth_date_feburary"
+    path: "#:birth-date-feburary"
+    rule: "(2#:identification-birth-date-delimiter[0..29])"
+  - name: "birth_date_days_thirty_even"
+    path: "#:birth-date-days-thirty-even"
+    rule: "((4|6|9|11)#:identification-birth-date-delimiter[0..30])"
+  - name: "birth_date_days_thirty_odd"
+    path: "#:birth-date-days-thirty-odd"
+    rule: "((1|3|5|7|8|10|12)#:identification-birth-date-delimiter[0..31])"
+  - name: "birth_date_norange"
+    path: "#:identification-birth-date-norange"
+    rule: "((2(([0-1][0-9])|(2[0-9])))|((1|3|5|7|8|10|12)&(([0-2])|([0-2][0-9])))|((4|6|9|11)[0..30]))"
+  - name: "birth_date_delimiter"
+    path: "#:identification-birth-date-delimiter"
+    rule: "/"
+  - name: "birth_year"
+    path: "#:identification-birth-year"
+    rule: "(19[0-9][0-9])|(20[0-1][0-9])|(20[0-1][6])"
+  - name: "time_year"
+    path: "#:time-year"
+    rule: "[0-9]{4:4}"
+  - name: "us_dollar"
+    path: "#:en-us-dollar"
+    rule: "$([0-9]{0:2}),([1-9]{3:3})\\.[0-9][0-9]"
+  - name: "time_month_numeric"
+    path: "#:time-month-numeric"
+    rule: "([1..12])|((0[0-9])|1(0-2))"
+  - name: "time_day_numeric"
+    path: "#:time-day-numeric"
+    rule: "([1..31])|(([0-2][0-9])|(3[01]))"
+  - name: "identification-email"
+    path: "#:profile-email"
+    rule: "#:name-dot@#:organization-website"
+  - name: "identification-website"
+    path: "#:organization-website"
+    rule: "@:en-organizations\\.#:names-domain"
+  - name: "website_domain"
+    path: "#:names-domain"
+    rule: "(org|com|net|)"
+  - name: "dot_name"
+    path: "#:name-dot"
+    rule: "((#:en-first-name)&(\\.)&(#:en-last-name)|(#:fr-first-name)&(\\.)&(#:fr-last-name)|(#:it-first-name)&(\\.)&(#:it-last-name))"
+  - name: "dash_name"
+    path: "#:name-dash"
+    rule: "((#:en-first-name\\-#:en-last-name)|(#:fr-first-name\\-#:fr-last-name)|(#:it-first-name\\-#:it-last-name))"
+  - name: "full_name"
+    path: "#:name-full"
+    rule: "((#:en-first-name #:en-last-name)|(#:fr-first-name #:fr-last-name)|(#:it-first-name #:it-last-name))"
+  - name: "english_first_name"
+    path: "#:en-first-name"
+    rule: "@:en-names-first"
+  - name: "english_last_name"
+    path: "#:en-last-name"
+    rule: "@:en-names-last"
+  - name: "french_first_name"
+    path: "#:fr-first-name"
+    rule: "@:fr-names-first"
+  - name: "french_last_name"
+    path: "#:fr-last-name"
+    rule: "@:fr-names-last"
+  - name: "italian_first_name"
+    path: "#:it-first-name"
+    rule: "@:it-names-first"
+  - name: "italian_last_name"
+    path: "#:it-last-name"
+    rule: "@:it-names-last"
+  - name: "hexadecimal"
+    path: "#:numeric-base-sixteen"
+    rule: "[0-9a-f]"
+  - name: "ipv4"
+    path: "#:technology-internet-ipv4"
+    rule: "(((([0-1][0-9][0-9])|(2([0-4][0-9]|5[0-5])))|(2[0..55]))\\.{3:3})&((([0-1][0-9][0-9])|(2([0-4][0-9]|5[0-5])))|(2[0..55]))"
+  - name: "ipv6"
+    path: "#:technology-internet-ipv6"
+    rule: "((#:numeric-base-sixteen{4:4}):{7:7})(#:numeric-base-sixteen{4:4})"
+  - name: "social_security_number"
+    path: "#:identification-socialsecuritynumber"
+    rule: "([0-9]{3:3})\\-([0-9]{2:2})\\-([0-9]{4:4})"
+  - name: "geolocation_latitude"
+    path: "#:geolocation-latitude"
+    rule: "#:numeric-float-signed"
+  - name: "geolocation_longitude"
+    path: "#:geolocation-longitude"
+    rule: "#:numeric-float-signed"
+  - name: "numeric_float_signed"
+    path: "#:numeric-float-signed"
+    rule: "(\\+|\\-)[0..65536]\\.[0..65536]"
+  - name: "us_address"
+    path: "#:identification-us-address"
+    rule: "[0..99999] @:"
+  - name: "us_city"
+    path: "#:identification-us-city"
+    rule: "@:en-us-cities"
+  - name: "us_state"
+    path: "#:identification-us-state"
+    rule: "@:en-us-states"
+  - name: "us_zipcode"
+    path: "#:identification-us-zipcode"
+    rule: "[0-9]{5:5}"
+  - name: "us_phone_number"
+    path: "#:identification-us-phonenumber"
+    rule: "[1-9][1-9][1-9]\\-[1-9][1-9][1-9]\\-[1-9][1-9][1-9][1-9]"
+  - name: "international_phone_number"
+    path: "#:identification-international-phonenumber"
+    rule: "hi"

data/lib/lightning/bolt/version.rb

@@ -1,5 +1,5 @@
 module Lightning
   module Bolt
-    VERSION = "1.4.0"
+    VERSION = "1.5.0"
   end
 end

data/lib/lightning/bolt.rb

@@ -1,8 +1,298 @@
+require "lightning/bolt/cypher"
+require "lightning/bolt/fuzzer"
 require "lightning/bolt/version"
-require "lightning/bolt/codex"
+
+require 'yaml'
+require 'json'
+require 'digest'
 
 module Lightning
   module Bolt
-    
+    class Codex
+      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__)}/keys.yml")
+        @passable = true
+        @theorems = theorems
+        @memory = memories
+      end
+
+      def signal(passable, unique, name)
+        @passable = passable.eql?(nil) ? true : passable
+        unique = unique.eql?(nil) ? false : unique
+        path = nil
+        @theorems.each do | theorem |
+          if theorem["name"].eql?(name)
+            path = theorem["path"]
+          end
+        end
+        if path
+          data = decrypt(path)
+          if unique
+            hash = Digest::SHA256.hexdigest(path)
+            @memory[hash] = data
+          end
+          return path
+        else
+          return ""
+        end
+      end
+
+      def archive
+        return @memory
+      end
+
+      private
+
+      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"]["not"]) ? exclude(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"]["remember"]) ? remember(rule) : rule
+        return rule
+      end
+
+      def rotar(rule, expr)
+        return (rule.scan(Regexp.new(expr)).size > 0)
+      end
+
+      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
+
+      def radar(map)
+        rule = ""
+        if @passable
+          @theorems.each do | theorem |
+            if theorem["path"].eql?(map)
+              rule = theorem["rule"]
+            end
+          end
+        else
+          rule = @theorems[@fuzzer.random_number(0, @theorems.size)]
+        end
+        return rule
+      end
+
+      def datum(rule)
+        datum = rule.scan(Regexp.new(@keys["keys"]["data"]))
+        datum.each do | data |
+          if @passable
+            rule = rule.sub(data, @cypher.arc(data))
+          else
+            rule = rule.sub(data, @fuzzer.random_character(64, ''))
+          end
+        end
+        return rule
+      end
+
+      def group(rule)
+        groups = rule.scan(Regexp.new(@keys["keys"]["group"]))
+        groups.each do | group |
+          group = group.join("")
+          rule = rule.sub(group, decrypt(group[1..-2]))
+        end
+        return rule
+      end
+
+      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"]["range"]))
+            subsets = set[0].scan(Regexp.new(@keys["keys"]["subsets"]))
+            if rangesets.size > 0
+              rangesets.each do | rangeset |
+                subranges = []
+                subrangeset = rangeset[1..-2].split("..")
+                (subrangeset[0]..subrangeset[1]).each do | x |
+                  subranges.push(x)
+                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 @passable
+                    charset += ruleset(subset[0])
+                  else
+                    charset += @fuzzer.random_character(1, '')
+                  end
+                end
+              end
+              if charset.size > 0
+                char = charset[@fuzzer.random_number(0,charset.size)]
+                rule = rule.sub(set[0], char)
+              end
+            end
+          end
+        end
+        return (rule)
+      end
+
+      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
+              charset += range_set
+            end
+          elsif subset.size == 2 && subset[0].eql?("\\")
+            charset.push(subset[1])
+          else
+            charset.push(subset)
+          end
+        end
+        return charset
+      end
+
+      def either(rule)
+        if !@passable
+          rule = charflip(rule, "|", "&")
+        end
+        subrules = rule.split(Regexp.new(@keys["keys"]["or"]))
+        subrule = subrules[@fuzzer.random_number(0,subrules.length)]
+        rule = rule.sub(rule, decrypt(subrule))
+      end
+
+      def concat(rule)
+        if !@passable
+          rule = charflip(rule, "&", "|")
+        end
+        combinator = ""
+        subrules = rule.split(Regexp.new(@keys["keys"]["and"]))
+        subrules.each do | subrule |
+          combinator += decrypt(subrule)
+        end
+        return rule.sub(rule, combinator)
+      end
+
+      def charflip(str, a, b)
+        charset = str.split("")
+        charset.each_with_index do | set, index |
+          if set.eql?(a)
+            charset[index] = b
+          elsif set.eql?(b)
+            charset[index] = a
+          else
+          end
+        end
+        return charset.join("")
+      end
+
+      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
+
+      def exclude(rule)
+        rule.scan(Regexp.new(@keys["keys"]["exclude"]))
+        violated = true
+        while violated.eql?(true) do
+          violated = false
+          decrypt(rule)
+        end
+        return rule
+      end
+
+      def repeat(rule)
+        combinator = ""
+        min = max = 0
+        repeater = rule.scan(Regexp.new(@keys["keys"]["repeat"]))[0]
+        if repeater
+          rule = rule.sub(repeater, "")
+          range = repeater.to_s[1..-2].split(":")
+          min = @passable ? range[0].to_i() : @fuzzer.random_number(0,min)
+          max = @passable ? range[1].to_i() : @fuzzer.random_number(min, rand(max + 9))
+          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
+
+      def escapable(rule)
+        escapes = rule.scan(Regexp.new(@keys["keys"]["escapable"]))
+        escapes.each do | escape |
+          if @passable
+            rule = rule.sub(escape, escape[1..-1])
+          else
+            rule = rule.sub(escape, @fuzzer.random_character(1, ''))
+          end
+        end
+        return decrypt(rule)
+      end
+
+      def remember(rule)
+        cortex = rule.scan(Regexp.new(@keys["keys"]["memorize"]))
+        bank = rule.split("+:")
+        memory = @memory[bank[1]]
+        if memory
+          return memory
+        else
+          bank = rule.split("+:")
+          rule = decrypt(bank[0])
+          memory = decrypt(bank[0])
+          return memory
+        end
+      end
+
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightning-bolt
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Austin Vecchio
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-06 00:00:00.000000000 Z
+date: 2016-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -96,9 +96,7 @@ files:
 - bin/lightningbolt
 - lib/lightning/bolt.rb
 - lib/lightning/bolt/cli.rb
-- lib/lightning/bolt/codex.rb
 - lib/lightning/bolt/cypher.rb
-- lib/lightning/bolt/encoding.yml
 - lib/lightning/bolt/fuzzer.rb
 - lib/lightning/bolt/keys.yml
 - lib/lightning/bolt/templates/codex/en/colors.yml

data/lib/lightning/bolt/codex.rb

@@ -1,302 +0,0 @@
-require "lightning/bolt/cypher"
-require "lightning/bolt/fuzzer"
-
-require 'yaml'
-require 'json'
-
-module Lightning
-  module Bolt
-    class Codex
-      def initialize(bookstore, theorems, memory)
-        @cypher = Lightning::Bolt::Cypher.new(bookstore)
-        @fuzzer = Lightning::Bolt::Fuzzer.new('UTF-8')
-        @keys = YAML.load_file("#{File.dirname(__FILE__)}/keys.yml")
-        @passable = true
-        @unique = false
-        @theorems = theorems
-        @memory = memory
-      end
-
-      def signal(passable, unique, name)
-        @passable = passable.eql?(nil) ? true : passable
-        @unique = unique.eql?(nil) ? false : unique
-        path = nil
-        @theorems.each do | theorem |
-          if theorem["name"].eql?(name)
-            path = theorem["path"]
-          end
-        end
-        if path
-          path = decrypt(path)
-          path = rotar(path, @keys["keys"]["escapable"]) ? escapable(path) : path
-          return path
-        else
-          return ""
-        end
-      end
-
-      private
-
-      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"]["not"]) ? exclude(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"]["remember"]) ? remember(rule) : rule
-        return rule
-      end
-
-      def rotar(rule, expr)
-        return (rule.scan(Regexp.new(expr)).size > 0)
-      end
-
-      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
-
-      def radar(map)
-        rule = ""
-        if @passable
-          @theorems.each do | theorem |
-            if theorem["path"].eql?(map)
-              rule = theorem["rule"]
-            end
-          end
-        else
-          rule = @theorems[@fuzzer.random_number(0, @theorems.size)]
-        end
-        return rule
-      end
-
-      def datum(rule)
-        datum = rule.scan(Regexp.new(@keys["keys"]["data"]))
-        datum.each do | data |
-          if @passable
-            rule = rule.sub(data, @cypher.arc(data))
-          else
-            rule = rule.sub(data, @fuzzer.launch(nil, 64, true))
-          end
-        end
-        return rule
-      end
-
-      def group(rule)
-        groups = rule.scan(Regexp.new(@keys["keys"]["group"]))
-        groups.each do | group |
-          group = group.join("")
-          rule = rule.sub(group, decrypt(group[1..-2]))
-        end
-        return rule
-      end
-
-      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"]["range"]))
-            subsets = set[0].scan(Regexp.new(@keys["keys"]["subsets"]))
-            if rangesets.size > 0
-              rangesets.each do | rangeset |
-                subranges = []
-                subrangeset = rangeset[1..-2].split("..")
-                (subrangeset[0]..subrangeset[1]).each do | x |
-                  subranges.push(x)
-                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 @passable
-                    charset += ruleset(subset[0])
-                  else
-                    charset += glyph
-                  end
-                end
-              end
-              if charset.size > 0
-                char = charset[@fuzzer.random_number(0,charset.size)]
-                rule = rule.sub(set[0], char)
-              end
-            end
-          end
-        end
-        return (rule)
-      end
-
-      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
-              charset += range_set
-            end
-          elsif subset.size == 2 && subset[0].eql?("\\")
-            charset.push(subset[1])
-          else
-            charset.push(subset)
-          end
-        end
-        return charset
-      end
-
-      def glyph()
-        range_set = []
-        min = rand(65)
-        max = rand(129)
-        (min..@fuzzer.random_number(min,max)).each do | range |
-          range_set.push(range.to_s(2).to_i(2))
-        end
-        return charsets
-      end
-
-      def either(rule)
-        if !@passable
-          rule = charflip(rule, "|", "&")
-        end
-        subrules = rule.split(Regexp.new(@keys["keys"]["or"]))
-        subrule = subrules[@fuzzer.random_number(0,subrules.length)]
-        rule = rule.sub(rule, decrypt(subrule))
-      end
-
-      def concat(rule)
-        if !@passable
-          rule = charflip(rule, "&", "|")
-        end
-        combinator = ""
-        subrules = rule.split(Regexp.new(@keys["keys"]["and"]))
-        subrules.each do | subrule |
-          combinator += decrypt(subrule)
-        end
-        return rule.sub(rule, combinator)
-      end
-
-      def charflip(str, a, b)
-        charset = str.split("")
-        charset.each_with_index do | set, index |
-          if set.eql?(a)
-            charset[index] = b
-          elsif set.eql?(b)
-            charset[index] = a
-          else
-          end
-        end
-        return charset.join("")
-      end
-
-      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
-
-      def exclude(rule)
-=begin
-        violated = true
-        rule = switch(rule)
-        while violated.eql?(true) do
-          violated = false
-          rule = decrypt(rule)
-        end
-=end
-        return rule
-      end
-
-      def repeat(rule)
-        combinator = ""
-        min = max = 0
-        repeater = rule.scan(Regexp.new(@keys["keys"]["repeat"]))[0]
-        if repeater
-          rule = rule.sub(repeater, "")
-          range = repeater.to_s[1..-2].split(":")
-          min = @passable ? range[0].to_i() : @fuzzer.random_number(0,min)
-          max = @passable ? range[1].to_i() : @fuzzer.random_number(min, rand(max + 9))
-          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
-
-      def escapable(rule)
-        escapes = rule.scan(Regexp.new(@keys["keys"]["escapable"]))
-        escapes.each do | escape |
-          if @passable
-            rule = rule.sub(escape, escape[1..-1])
-          else
-            rule = rule.sub(escape, @fuzzer.launch(nil, 1, false))
-          end
-        end
-        return decrypt(rule)
-      end
-
-      def remember(rule)
-        cortex = rule.scan(Regexp.new(@keys["keys"]["memorize"]))
-        bank = rule.split("+:")
-        memory = @memory[bank[1]]
-        if memory
-          return memory
-        else
-          bank = rule.split("+:")
-          rule = decrypt(bank[0])
-          memory = decrypt(bank[0])
-          return memory
-        end
-      end
-
-    end
-  end
-end

data/lib/lightning/bolt/encoding.yml

@@ -1,73 +0,0 @@
-encoding: "UTF-8"
-#encodable:
-#  
-non-encodable:
-  start: 55296
-  end: 57343
-non-printable:
-- code: 0
-  char: NUL
-- code: 1
-  char: SOH
-- code: 2
-  char: STX
-- code: 3
-  char: ETX
-- code: 4
-  char: EOT
-- code: 5
-  char: ENQ
-- code: 6
-  char: ACK
-- code: 7
-  char: BEL
-- code: 8
-  char: BS
-- code: 9
-  char: TAB
-- code: A
-  char: LF
-- code: B
-  char: VT
-- code: C
-  char: FF
-- code: D
-  char: CR
-- code: E
-  char: SO
-- code: F
-  char: SI
-- code: 10
-  char: DLE
-- code: 11
-  char: DC1
-- code: 12
-  char: DC2
-- code: 13
-  char: DC3
-- code: 14
-  char: DC4
-- code: 15
-  char: NAK
-- code: 16
-  char: SYN
-- code: 17
-  char: ETB
-- code: 18
-  char: CAN
-- code: 19
-  char: EM
-- code: 1A
-  char: SUB
-- code: 1B
-  char: ESC
-- code: 1C
-  char: FS
-- code: 1D
-  char: GS
-- code: 1E
-  char: RS
-- code: 1F
-  char: US
-- code: 7F
-  char: DEL