reflekt 0.9.2 → 0.9.8

data/lib/web/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "reflekt-server",
+  "version": "1.0.0",
+  "description": "Serves the UI and writes to the DB.",
+  "main": "server.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "nodemon server.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/refIekt/reflekt-ui.git"
+  },
+  "author": "Maedi Prichard",
+  "license": "MPL-2.0",
+  "bugs": {
+    "url": "https://github.com/refIekt/reflekt-ui/issues"
+  },
+  "homepage": "https://reflekt.dev",
+  "dependencies": {
+    "express": "^4.17.1"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.5"
+  }
+}

data/lib/web/server.js

@@ -0,0 +1,122 @@
+const express = require('express')
+const path = require('path')
+const vm = require("vm");
+const fs = require('fs');
+
+const app = express();
+const port = 3001;
+const db_path = 'db.js';
+
+// Configure express.
+app.use(express.json());
+app.use(express.static('.'));
+app.use('/dist', express.static('../dist'));
+
+// Respond with React app.
+app.get('/', (req, res) => {
+  res.sendFile(path.join(__dirname, 'index.html'))
+})
+
+////
+// READ.
+////
+
+var load_db = () => {
+
+  const data = fs.readFileSync(db_path);
+  const script = new vm.Script(data);
+  script.runInThisContext();
+  return JSON.parse(db);
+
+}
+
+////
+// DELETE.
+////
+
+// Handle executions delete request.
+app.post('/executions/delete', (req, res) => {
+
+  // Get reflection ID.
+  var exe_id = req.body.exe_id;
+  var number = req.body.number;
+  console.log(number);
+
+  // Get database.
+  db = load_db();
+
+  for (let [index, reflection] of db.reflections.entries()) {
+    if (reflection.e == exe_id && reflection.n == number) {
+      console.log("DELETED:")
+      console.log(db.reflections[index]);
+      db.reflections.splice(index, 1);
+    }
+    if (reflection.b != null && reflection.b == exe_id && reflection.n == number) {
+      console.log("DELETED:")
+      console.log(db.reflections[index]);
+      db.reflections.splice(index, 1);
+    }
+  }
+
+  // Save database.
+  try {
+    fs.writeFileSync(db_path, 'var db = ' + JSON.stringify(JSON.stringify(db)) + ';');
+  }
+  catch (err) {
+    console.error(err)
+  }
+
+  res.status(200).send({ message: 'ok' });
+
+})
+
+// Handle reflections delete request.
+app.post('/reflections/delete', (req, res) => {
+
+  // Get reflection ID.
+  ref_id = req.body.ref_id;
+
+  // Get database.
+  db = load_db();
+
+  // Delete reflection.
+  for (let [index, reflection] of db.reflections.entries()) {
+    if (reflection.r == ref_id) {
+      console.log("DELETED:")
+      console.log(db.reflections[index]);
+      db.reflections.splice(index, 1);
+      break;
+    }
+  }
+
+  // Save database.
+  try {
+    fs.writeFileSync(db_path, 'var db = ' + JSON.stringify(JSON.stringify(db)) + ';');
+  }
+  catch (err) {
+    console.error(err)
+  }
+
+  res.status(200).send({ message: 'ok' });
+
+})
+
+////
+// UPDATE.
+////
+
+// Handle reflections keep request.
+app.post('/reflections/keep', (req, res) => {
+  console.log(req.body);
+})
+
+// Listen for requests.
+app.listen(port, () => {
+  console.log(`Example app listening at http://localhost:${port}`)
+})
+
+//fs.readFile('student.json', (err, data) => {
+//  if (err) throw err;
+//  let student = JSON.parse(data);
+//  console.log(student);
+//});

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflekt
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.8
 platform: ruby
 authors:
 - Maedi Prichard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
+date: 2020-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rowdb
@@ -25,21 +25,34 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Testing that's completely automated.
-email: maediprichard@gmailcom
+email: maediprichard@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/Accessor.rb
+- lib/Aggregator.rb
 - lib/Control.rb
 - lib/Execution.rb
+- lib/Meta.rb
+- lib/MetaBuilder.rb
 - lib/Reflection.rb
+- lib/Reflekt.rb
+- lib/Renderer.rb
 - lib/Rule.rb
-- lib/Ruler.rb
+- lib/RuleSet.rb
 - lib/ShadowStack.rb
-- lib/reflekt.rb
-- lib/web/script.js
-- lib/web/style.css
-- lib/web/template.html.erb
+- lib/meta/IntegerMeta.rb
+- lib/meta/StringMeta.rb
+- lib/rules/IntegerRule.rb
+- lib/rules/StringRule.rb
+- lib/web/README.md
+- lib/web/bundle.js
+- lib/web/gitignore.txt
+- lib/web/index.html
+- lib/web/package-lock.json
+- lib/web/package.json
+- lib/web/server.js
 homepage: https://github.com/refIekt/reflekt
 licenses:
 - MPL-2.0

data/lib/Ruler.rb

@@ -1,112 +0,0 @@
-require 'Rule'
-
-class Ruler
-
-  INPUT  = "i"
-  OUTPUT = "o"
-  TYPE   = "T"
-  VALUE  = "V"
-
-  def initialize()
-
-    @controls = nil
-
-    # Rules.
-    @inputs = []
-    @output = nil
-
-  end
-
-  def load(controls)
-
-    @controls = controls
-    @controls.each_with_index do |control, index|
-
-      # Multiple inputs.
-      control[INPUT].each_with_index do |input, index|
-        unless input.nil?
-
-          # Create rule.
-          if @inputs[index].nil?
-            rule = Rule.new()
-            @inputs[index] = rule
-          else
-            rule = @inputs[index]
-          end
-
-          # Add rules to rule.
-          unless input[TYPE].nil? || input[TYPE].empty?
-            rule.add_type(input[TYPE].class)
-          end
-          unless input[VALUE].nil? || input[VALUE].empty?
-            rule.add_value(input[VALUE])
-          end
-
-          index = index + 1
-        end
-      end
-
-      # Singular output.
-      output = control[OUTPUT]
-      unless control[OUTPUT].nil?
-
-        # Create rule.
-        if @output.nil?
-          rule = Rule.new()
-          @output = rule
-        else
-          rule = @output
-        end
-
-        ## Add rules to rule.
-        unless output[TYPE].nil? || output[TYPE].empty?
-          rule.add_type(output[TYPE])
-        end
-        unless output[VALUE].nil? || output[VALUE].empty?
-          rule.add_value(output[VALUE])
-        end
-
-      end
-
-    end
-
-  end
-
-  def train()
-
-    @inputs.each do |rule|
-      # Get min/max.
-      if rule.is_number?
-        numbers = rule.values.select {|num| num.class == Integer }
-        numbers.sort!
-        rule.min = numbers.first
-        rule.max = numbers.last
-      end
-
-    end
-
-  end
-
-  def validate_inputs(klass, method, inputs)
-    result = true
-    inputs.each_with_index do |value, index|
-      rule = @inputs[index]
-      if rule.is_number? && value.class == Integer
-        result = false if value < rule.min
-        result = false if value > rule.max
-      end
-    end
-    return result
-  end
-
-  def validate_output(klass, method, outputs)
-    result = true
-    rule = @output
-    if rule.is_number? && value.class == Integer
-      result = false if value < rule.min
-      result = false if value > rule.max
-    end
-    return result
-  end
-
-end

data/lib/reflekt.rb

@@ -1,244 +0,0 @@
-require 'set'
-require 'erb'
-require 'rowdb'
-require 'Control'
-require 'Execution'
-require 'Reflection'
-require 'Ruler'
-require 'ShadowStack'
-
-################################################################################
-# REFLEKT
-#
-# An Execution is created each time a method is called.
-# Multiple Refections are created per Execution.
-# These Reflections execute on a ShadowStack on cloned objects.
-# Then flow is returned to the original method and normal execution continues.
-#
-# Usage:
-#
-#   class ExampleClass
-#     prepend Reflekt
-################################################################################
-
-module Reflekt
-
-  # The amount of reflections to create per method call.
-  @@reflekt_reflect_amount = 2
-
-  # Limit the amount of reflections that can be created per instance method.
-  # A method called thousands of times doesn't need that many reflections.
-  @@reflection_limit = 10
-
-  def initialize(*args)
-
-    @reflection_counts = {}
-
-    # Get instance methods.
-    # TODO: Include parent methods like "Array.include?".
-    self.class.instance_methods(false).each do |method|
-
-      # Don't process skipped methods.
-      next if self.class.reflekt_skipped?(method)
-
-      @reflection_counts[method] = 0
-
-      # When method called in flow.
-      self.define_singleton_method(method) do |*args|
-
-        # Don't reflect when limit reached.
-        unless @reflection_counts[method] >= @@reflection_limit
-
-          # Get current execution.
-          execution = @@reflekt_stack.peek()
-
-          # When stack empty or past execution done reflecting.
-          if execution.nil? || execution.has_finished_reflecting?
-
-            # Create execution.
-            execution = Execution.new(self, @@reflekt_reflect_amount)
-            @@reflekt_stack.push(execution)
-
-          end
-
-          # Get ruler.
-          # The method's ruler will not exist the first time the db generated.
-          if @@reflekt_rules.key? execution.caller_class.to_s.to_sym
-            ruler = @@reflekt_rules[execution.caller_class.to_s.to_sym][method.to_s]
-          else
-            ruler = nil
-          end
-
-          # Reflect.
-          # The first method call in the Execution creates a Reflection.
-          # Subsequent method calls are shadow executions on cloned objects.
-          if execution.has_empty_reflections? && !execution.is_reflecting?
-            execution.is_reflecting = true
-
-            class_name = execution.caller_class.to_s
-            method_name = method.to_s
-
-            # Create control.
-            control = Control.new(execution, method, ruler)
-            execution.control = control
-
-            # Execute control.
-            control.reflect(*args)
-
-            # Save control.
-            @@reflekt_db.get("#{class_name}.#{method_name}.controls").push(control.result())
-
-            # Multiple reflections per execution.
-            execution.reflections.each_with_index do |value, index|
-
-              # Create reflection.
-              reflection = Reflection.new(execution, method, ruler)
-              execution.reflections[index] = reflection
-
-              # Execute reflection.
-              reflection.reflect(*args)
-              @reflection_counts[method] = @reflection_counts[method] + 1
-
-              # Save reflection.
-              @@reflekt_db.get("#{class_name}.#{method_name}.reflections").push(reflection.result())
-
-            end
-
-            # Save results.
-            @@reflekt_db.write()
-
-            # Render results.
-            reflekt_render()
-
-            execution.is_reflecting = false
-          end
-
-        end
-
-        # Continue execution / shadow execution.
-        super *args
-
-      end
-
-    end
-
-    # Continue initialization.
-    super
-
-  end
-
-  ##
-  # Render results.
-  ##
-  def reflekt_render()
-
-    # Get JSON.
-    @@reflekt_json = File.read("#{@@reflekt_output_path}/db.json")
-
-    # Save HTML.
-    template = File.read("#{@@reflekt_path}/web/template.html.erb")
-    rendered = ERB.new(template).result(binding)
-    File.open("#{@@reflekt_output_path}/index.html", 'w+') do |f|
-      f.write rendered
-    end
-
-    # Add JS.
-    javascript = File.read("#{@@reflekt_path}/web/script.js")
-    File.open("#{@@reflekt_output_path}/script.js", 'w+') do |f|
-      f.write javascript
-    end
-
-    # Add CSS.
-    stylesheet = File.read("#{@@reflekt_path}/web/style.css")
-    File.open("#{@@reflekt_output_path}/style.css", 'w+') do |f|
-      f.write stylesheet
-    end
-
-  end
-
-  private
-
-  def self.prepended(base)
-    # Prepend class methods to the instance's singleton class.
-    base.singleton_class.prepend(SingletonClassMethods)
-
-    @@reflekt_setup ||= reflekt_setup_class
-  end
-
-  # Setup class.
-  def self.reflekt_setup_class()
-
-    # Receive configuration.
-    $ENV ||= {}
-    $ENV[:reflekt] ||= $ENV[:reflekt] = {}
-
-    # Set configuration.
-    @@reflekt_path = File.dirname(File.realpath(__FILE__))
-
-    # Build reflections directory.
-    if $ENV[:reflekt][:output_path]
-      @@reflekt_output_path = File.join($ENV[:reflekt][:output_path], 'reflections')
-    # Build reflections directory in current execution path.
-    else
-      @@reflekt_output_path = File.join(Dir.pwd, 'reflections')
-    end
-    # Create reflections directory.
-    unless Dir.exist? @@reflekt_output_path
-      Dir.mkdir(@@reflekt_output_path)
-    end
-
-    # Create database.
-    @@reflekt_db = Rowdb.new(@@reflekt_output_path + '/db.json')
-    @@reflekt_db.defaults({ :reflekt => { :api_version => 1 }})
-
-    # Create shadow execution stack.
-    @@reflekt_stack = ShadowStack.new()
-
-    # Define rules.
-    # TODO: Fix Rowdb.get(path) not returning data at path after Rowdb.push()?
-    @@reflekt_rules = {}
-    db = @@reflekt_db.value()
-    db.each do |class_name, class_values|
-      @@reflekt_rules[class_name] = {}
-      class_values.each do |method_name, method_values|
-        next if method_values.nil?
-        next unless method_values.class == Hash
-        if method_values.key? "controls"
-
-          ruler = Ruler.new()
-          ruler.load(method_values['controls'])
-          ruler.train()
-
-          @@reflekt_rules[class_name][method_name] = ruler
-        end
-      end
-    end
-
-    return true
-  end
-
-  module SingletonClassMethods
-
-    @@reflekt_skipped_methods = Set.new
-
-    ##
-    # Skip a method.
-    #
-    # @param method - A symbol representing the method name.
-    ##
-    def reflekt_skip(method)
-      @@reflekt_skipped_methods.add(method)
-    end
-
-    def reflekt_skipped?(method)
-      return true if @@reflekt_skipped_methods.include?(method)
-      false
-    end
-
-    def reflekt_limit(amount)
-      @@reflection_limit = amount
-    end
-
-  end
-
-end