lightning-bolt 1.5.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7705fc8efc2ff61f50a4a31602b305e2c4a29117
-  data.tar.gz: 1b61a04a7d4be24afdf76a602ea70f2bcb4f8f5e
+  metadata.gz: fbf88be6e8d1719062216cdda80ec28ceda1e800
+  data.tar.gz: 818bbcfb2e4b0e34802a304204df7fbcc67b9ba5
 SHA512:
-  metadata.gz: 918b0576f5dfc1a93508807ba1398490ef1307a1f693d9ccbf08707471c5d8438759a489ce353c019b47d2c750c75f880a24ef1a55d71cae14dfe27c33daca7a
-  data.tar.gz: 645d4f5978e77a56f608ff030436540df63588429097e9d51657d94b4af52e6ef0f47f5ceab45a29eced166a1e6ec0072c2bb95d04869cc6fd0cb6cf34efd396
+  metadata.gz: ebcd795016f618cd0f5fef18a21b1c7b964988c75916eae3ba702dbea009dd03a4eb8d480f653089fd5c5a553da4dda98626da4f46828a0911325ef2e63e3a76
+  data.tar.gz: 889904d969dce46323cebcfd87db3ef2b1cb346d6282c4a8dc004f666422412fab9e32c8ab206f2399df0b2cccfc308bdc9e5df9d6fcf42adb2349442b7ca153

data/lib/lightning/bolt.rb

@@ -1,6 +1,6 @@
-require "lightning/bolt/cypher"
-require "lightning/bolt/fuzzer"
-require "lightning/bolt/version"
+require_relative "bolt/cypher"
+require_relative "bolt/fuzzer"
+require_relative "bolt/version"
 
 require 'yaml'
 require 'json'
@@ -12,35 +12,46 @@ module Lightning
       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
+        @keys = YAML.load_file("#{File.dirname(__FILE__)}/bolt/keys.yml")
         @theorems = theorems
-        @memory = memories
+        @memories = memories
+        @thoughts = []
       end
 
-      def signal(passable, unique, name)
-        @passable = passable.eql?(nil) ? true : passable
-        unique = unique.eql?(nil) ? false : unique
+      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
+
+      def validate(mode, unique, path)
+        @mode = mode.eql?(nil) ? 'system' : mode
+        unique = unique.eql?(nil) ? false : unique
+        data = ""
         if path
-          data = decrypt(path)
           if unique
-            hash = Digest::SHA256.hexdigest(path)
-            @memory[hash] = data
+            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
-          return path
-        else
-          return ""
         end
+        return data
       end
 
       def archive
-        return @memory
+        return @memories
       end
 
       private
@@ -51,12 +62,11 @@ module Lightning
         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
+        rule = rotar(rule, @keys["keys"]["memorize"]) ? remember(rule) : rule
         return rule
       end
 
@@ -84,14 +94,10 @@ module Lightning
 
       def radar(map)
         rule = ""
-        if @passable
-          @theorems.each do | theorem |
-            if theorem["path"].eql?(map)
-              rule = theorem["rule"]
-            end
+        @theorems.each do | theorem |
+          if theorem["path"].eql?(map)
+            rule = theorem["rule"]
           end
-        else
-          rule = @theorems[@fuzzer.random_number(0, @theorems.size)]
         end
         return rule
       end
@@ -99,20 +105,26 @@ module Lightning
       def datum(rule)
         datum = rule.scan(Regexp.new(@keys["keys"]["data"]))
         datum.each do | data |
-          if @passable
-            rule = rule.sub(data, @cypher.arc(data))
+          arc = @cypher.arc(data)
+          if @mode.eql?('strict')
+            rule = rule.sub(data, @fuzzer.random_character(arc.size))
           else
-            rule = rule.sub(data, @fuzzer.random_character(64, ''))
+            rule = rule.sub(data, arc)
           end
         end
         return rule
       end
 
       def group(rule)
-        groups = rule.scan(Regexp.new(@keys["keys"]["group"]))
+        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("")
-          rule = rule.sub(group, decrypt(group[1..-2]))
+          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
@@ -121,14 +133,24 @@ module Lightning
         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"]))
+            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 = []
-                subrangeset = rangeset[1..-2].split("..")
-                (subrangeset[0]..subrangeset[1]).each do | x |
-                  subranges.push(x)
+                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)
@@ -137,15 +159,17 @@ module Lightning
               charset = []
               subsets.each do | subset |
                 if subset
-                  if @passable
-                    charset += ruleset(subset[0])
+                  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 += @fuzzer.random_character(1, '')
+                    charset.push(ruleset(subset[0]))
                   end
                 end
               end
               if charset.size > 0
-                char = charset[@fuzzer.random_number(0,charset.size)]
+                char = charset[0][@fuzzer.random_number(0,charset.size)]
                 rule = rule.sub(set[0], char)
               end
             end
@@ -166,6 +190,11 @@ module Lightning
               (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?("\\")
@@ -178,18 +207,26 @@ module Lightning
       end
 
       def either(rule)
-        if !@passable
-          rule = charflip(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
-        subrules = rule.split(Regexp.new(@keys["keys"]["or"]))
-        subrule = subrules[@fuzzer.random_number(0,subrules.length)]
         rule = rule.sub(rule, decrypt(subrule))
+        return rule
       end
 
       def concat(rule)
-        if !@passable
-          rule = charflip(rule, "&", "|")
-        end
         combinator = ""
         subrules = rule.split(Regexp.new(@keys["keys"]["and"]))
         subrules.each do | subrule |
@@ -198,19 +235,6 @@ module Lightning
         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"]))
@@ -232,25 +256,22 @@ module Lightning
         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
+        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(":")
-          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 @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)
@@ -270,10 +291,12 @@ module Lightning
       def escapable(rule)
         escapes = rule.scan(Regexp.new(@keys["keys"]["escapable"]))
         escapes.each do | escape |
-          if @passable
-            rule = rule.sub(escape, escape[1..-1])
+          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, @fuzzer.random_character(1, ''))
+            rule = rule.sub(escape, escape[1..-1])
           end
         end
         return decrypt(rule)
@@ -283,14 +306,14 @@ module Lightning
         cortex = rule.scan(Regexp.new(@keys["keys"]["memorize"]))
         bank = rule.split("+:")
         hash = Digest::SHA256.hexdigest(bank[1])
-        memory = @memory[hash]
+        memory = @thoughts[hash]
         if memory
           return memory
         else
           rule = decrypt(bank[0])
-          memory = decrypt(bank[0])
-          @memory[hash] = memory
-          return memory
+          thought = decrypt(bank[0])
+          @thoughts[hash] = thought
+          return thought
         end
       end
 

data/lib/lightning/bolt/cypher.rb

@@ -1,4 +1,4 @@
-require 'xelor'
+require 'securerandom'
 module Lightning
   module Bolt
     class Cypher
@@ -29,7 +29,7 @@ module Lightning
         @reports.each do | report |
           if report["key"].eql?(pin)
             data = report["cypher"]
-            xrand = Xelor.hex(data.size)
+            xrand = SecureRandom.random_number(data.size)
             value = data[xrand]
           end
         end

data/lib/lightning/bolt/fuzzer.rb

@@ -12,11 +12,15 @@ module Lightning
         return SecureRandom.random_number(max-min)+min
       end
 
-      def random_character(seed, size, flags)
+      def random_character(size)
         enigma = ""
-        (0..size).each do | index |
-          engima += random_number(0,@alphabet.size)
+        while (enigma.size < size + 1)
+          char = @alphabet[random_number(0,@alphabet.size)]
+          if char
+            enigma += char
+          end
         end
+        return enigma
       end
 
       private

data/lib/lightning/bolt/version.rb

@@ -1,5 +1,5 @@
 module Lightning
   module Bolt
-    VERSION = "1.5.1"
+    VERSION = "3.1.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightning-bolt
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Austin Vecchio
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-12 00:00:00.000000000 Z
+date: 2016-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -109,9 +109,6 @@ files:
 - lib/lightning/bolt/templates/payload.yml
 - lib/lightning/bolt/version.rb
 - lightning-bolt.gemspec
-- specs/baseline.yml
-- specs/checkpoints.rb
-- specs/payload.yml
 homepage: https://github.com/avecchio/lightning-bolt
 licenses:
 - MIT

data/specs/baseline.yml

@@ -1,79 +0,0 @@
-baselines:
-- theorem: "birth_date"
-  regex: ""
-- theorem: "birth_date_range"
-  regex: ""
-- theorem: "birth_date_month"
-  regex: ""
-- theorem: "birth_date_feburary"
-  regex: ""
-- theorem: "birth_date_days_thirty_even"
-  regex: ""
-- theorem: "birth_date_days_thirty_odd"
-  regex: ""
-- theorem: "birth_date_norange"
-  regex: ""
-- theorem: "birth_date_delimiter"
-  regex: ""
-- theorem: "birth_year"
-  regex: ""
-- theorem: "time_year"
-  regex: ""
-- theorem: "us_dollar"
-  regex: ""
-- theorem: "time_month_numeric"
-  regex: ""
-- theorem: "time_day_numeric"
-  regex: ""
-- theorem: "states"
-  regex: ""
-- theorem: "email"
-  regex: ""
-- theorem: "website"
-  regex: ""
-- theorem: "website_domain"
-  regex: ""
-- theorem: "dot_name"
-  regex: ""
-- theorem: "dash_name"
-  regex: ""
-- theorem: "full_name"
-  regex: ""
-- theorem: "english_first_name"
-  regex: ""
-- theorem: "english_last_name"
-  regex: ""
-- theorem: "french_first_name"
-  regex: ""
-- theorem: "french_last_name"
-  regex: ""
-- theorem: "italian_first_name"
-  regex: ""
-- theorem: "italian_last_name"
-  regex: ""
-- theorem: "hexadecimal"
-  regex: ""
-- theorem: "ipv4"
-  regex: ""
-- theorem: "ipv6"
-  regex: ""
-- theorem: "social_security_number"
-  regex: ""
-- theorem: "geolocation_latitude"
-  regex: ""
-- theorem: "geolocation_longitude"
-  regex: ""
-- theorem: "numeric_float_signed"
-  regex: ""
-- theorem: "us_address"
-  regex: ""
-- theorem: "us_city"
-  regex: ""
-- theorem: "us_state"
-  regex: ""
-- theorem: "us_zipcode"
-  regex: ""
-- theorem: "us_phone_number"
-  regex: ""
-- theorem: "international_phone_number"
-  regex: ""

data/specs/checkpoints.rb

@@ -1,22 +0,0 @@
-require_relative "../lib/lightning/bolt/codex"
-require 'yaml'
-
-baseline_theorems = YAML.load_file("./baseline.yml")["baselines"] | []
-
-bookstore = "#{Dir.pwd}/../lib/lightning/bolt/templates/codex/"
-payload = YAML.load_file("./payload.yml")
-memory = []
-
-codex = Lightning::Bolt::Codex.new(bookstore, payload["theorems"], payload["reports"], memory)
-(0..0).each do | iteration |
-  baseline_theorems.each do | theorem |
-    puts "theorem: #{theorem["theorem"]}"
-    passable_theorem = codex.signal(true, false, theorem["theorem"])
-    #nonpassable_theorem = codex.signal(false, false, theorem["theorem"])
-    puts "passable"
-    puts passable_theorem#.scan(Regexp.new(theorem["regex"]))
-#    puts "nonpassable"
-#    puts nonpassable_theorem#.scan(Regexp.new(theorem["regex"]))
-    puts "------------"
-  end
-end

data/specs/payload.yml

@@ -1,116 +0,0 @@
----
-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"