hyperlayer 0.1

data/app/services/file_builder.rb

@@ -0,0 +1,260 @@
+class FileBuilder
+  def initialize(options = {})
+    @options = options
+
+    if options[:url]
+      parts = options[:url].split('/')
+
+      if parts.count > 1
+        options[:object] = parts.last.singularize
+        options[:class] = parts.last.singularize.capitalize
+      end
+    end
+  end
+
+  attr_reader :options
+
+  OPTION_KLASS_MAP = {
+    'authorisation' => 'Authorisation',
+    'url' => 'ClassDefinition',
+    'request' => 'BuildStrongParams',
+    'controller_action' => 'ControllerAction',
+    'skip-csrf' => 'SkipCsrf'
+  }
+
+  def call
+    options.to_h.each_with_object(parts) do |(option, _value), output|
+      klass = OPTION_KLASS_MAP[option]
+
+      next unless klass
+
+      fragments = "FileBuilder::#{klass}".constantize.call(options: options)
+
+      fragments.each do |part, code|
+        output[part] ||= []
+
+        output[part] << code
+      end
+    end
+  end
+
+  private
+
+  def parts
+    {
+      definition_start: [],
+      before_actions: [],
+      public_methods: [],
+      private_methods: [],
+      definition_finish: []
+    }
+  end
+
+  class Authorisation
+    include Callable
+    expects :options
+
+    def call
+      if options['authorisation'] == '1'
+        {
+          before_actions: authorisation
+        }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def authorisation
+      template.tap do |temp|
+        temp.scan(/\%(.*?)\%/).flatten.uniq.each do |value|
+          temp.gsub!("%#{value}%", options[value])
+        end
+      end
+    end
+
+    def template
+      File.read('app/views/code/authorisation.erb')[0..-2]
+    end
+  end
+
+  class ControllerAction
+    include Callable
+    expects :options
+
+    def call
+      if options['controller_action'].present?
+        {
+          public_methods: code
+        }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def code
+      template.tap do |temp|
+        temp.scan(/\%(.*?)\%/).flatten.uniq.each do |value|
+          temp.gsub!("%#{value}%", options[value])
+        end
+      end
+    end
+
+    def template
+      File.read("app/views/code/controller_actions/#{controller_action}.erb")[0..-2]
+    end
+
+    def controller_action
+      options['controller_action']
+    end
+  end
+
+  class TrackEvent
+    include Callable
+    expects :options
+
+    def call
+      if options['track_event'].present?
+        {
+          before_action: code,
+          private_methods: code
+        }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def code
+      template.tap do |temp|
+        temp.scan(/\%(.*?)\%/).flatten.uniq.each do |value|
+          temp.gsub!("%#{value}%", options[value])
+        end
+      end
+    end
+
+    def template
+      File.read("app/views/code/controller_actions/#{controller_action}.erb")[0..-2]
+    end
+
+    def controller_action
+      options['controller_action']
+    end
+  end
+
+  class ClassDefinition
+    include Callable
+    expects :options
+
+    def call
+      return {} unless options[:url].present?
+
+      {
+        definition_start: start,
+        definition_finish: finish
+      }
+    end
+
+    private
+
+    def start
+      levels.map.with_index(1) do |level, index|
+        if index == count
+          "class #{level.capitalize}Controller < ApplicationController"
+        else
+          "module #{level.capitalize}"
+        end
+      end
+    end
+
+    def levels
+      options[:url].split('/').select(&:present?)
+    end
+
+    def count
+      levels.count
+    end
+
+    def finish
+      levels.map { 'end' }
+    end
+  end
+
+  class SkipCsrf
+    include Callable
+    expects :options
+
+    def call
+      return {} unless options['skip-csrf'] == '1'
+
+      { private_methods: code }
+    end
+
+    private
+
+    def code
+      template.tap do |temp|
+        temp.scan(/\%(.*?)\%/).flatten.uniq.each do |value|
+          temp.gsub!("%#{value}%", options[value].to_s)
+        end
+      end
+    end
+
+    def template
+      File.read('app/views/code/strong_params.erb')
+    end
+  end
+
+  class BuildStrongParams
+    include Callable
+    expects :options
+
+    def call
+      return {} unless options[:request].present?
+
+      options[:keys] = keys
+
+      { private_methods: code }
+    end
+
+    private
+
+    def code
+      template.tap do |temp|
+        temp.scan(/\%(.*?)\%/).flatten.uniq.each do |value|
+          temp.gsub!("%#{value}%", options[value].to_s)
+        end
+      end
+    end
+
+    def template
+      File.read('app/views/code/strong_params.erb')
+    end
+
+    def keys
+      JSON.parse(options[:request]).keys
+    end
+  end
+
+  ############################################
+  # def parts
+  #   {
+  #     definition_start: {
+  #       def_strong_params: {
+  #         open: [],
+  #         body: [],
+  #         end: []
+  #       }
+  #     },
+  #     before_actions: {},
+  #     public_methods: {},
+  #     private_methods: {},
+  #     definition_finish: {}
+  #   }
+  # end
+  ############################################
+end

data/app/services/find_method_from_event.rb

@@ -0,0 +1,65 @@
+# require 'fast'
+
+class FindMethodFromEvent < Parser::AST::Processor
+  include RuboCop::AST::Traversal
+
+  def self.call(event)
+    new.call(event)
+  end
+
+  # Have a "Exists?" method that checks to see if something exists
+  # If it doesn't use an Insert class and define which section it should go into
+  # If it does, work out the differences(?) and update them
+
+  def call(event)
+    code = File.readlines(event.path.path).join
+    source = RuboCop::ProcessedSource.new(code, 2.7)
+
+    return unless source.present?
+
+    node = FindMethod.call(
+      type: :def,
+      name: event.method.to_sym,
+      source: source
+    )
+
+    return unless node.present?
+
+    DisplayMethod
+      .call(node: node, code: code)
+      .split("\n")
+  end
+
+  private
+
+  class FindMethod
+    include Callable
+    expects :type, :name, :source
+
+    def call
+      source.ast
+            .each_node
+            .map { |n| n if n.type == type && n.method_name == name }
+            .compact
+    end
+  end
+
+  class DisplayMethod
+    include Callable
+    expects :code, :node
+
+    def call
+      code[begin_pos...end_pos]
+    end
+
+    private
+
+    delegate :begin_pos, :end_pos, to: :expression
+
+    def expression
+      node.first
+          .loc
+          .expression
+    end
+  end
+end

data/app/services/find_method_in_path.rb

@@ -0,0 +1,98 @@
+# require 'fast'
+
+class FindMethodInPath < Parser::AST::Processor
+  include RuboCop::AST::Traversal
+
+  def self.call(path_id)
+    new.call(path_id)
+  end
+
+  # Have a "Exists?" method that checks to see if something exists
+  # If it doesn't use an Insert class and define which section it should go into
+  # If it does, work out the differences(?) and update them
+
+  def call(path_id)
+    path = Path.find(path_id)
+    code = File.readlines(path.path).join
+    source = RuboCop::ProcessedSource.new(code, 2.7)
+
+    path.events.call.each_with_object({}) do |event, methods|
+      methods[event.method.to_sym] = ''
+
+      node = FindMethod.call(
+        type: :def,
+        name: event.method.to_sym,
+        source: source
+      )
+
+      next unless node.present?
+
+      methods[event.method.to_sym] = DisplayMethod.call(node: node, code: code)
+    end
+  end
+
+  private
+
+  class FindMethod
+    include Callable
+    expects :type, :name, :source
+
+    def call
+      binding.pry
+
+      source.ast
+            .each_node
+            .map { |n| n if n.type == type && n.method_name == name }
+            .compact
+    end
+  end
+
+  class AddMethod
+    include Callable
+    expects :code, :pos
+
+    def call
+      code.insert(pos, "def code \n inserted.here! \n end")
+    end
+  end
+
+  class Replace
+    include Callable
+    expects :code, :node, :with
+
+    def call
+      code[begin_pos...end_pos] = with
+    end
+
+    private
+
+    delegate :begin_pos, :end_pos, to: :expression
+
+    def expression
+      node.first
+          .arguments
+          .first
+          .loc
+          .expression
+    end
+  end
+
+  class DisplayMethod
+    include Callable
+    expects :code, :node
+
+    def call
+      code[begin_pos...end_pos]
+    end
+
+    private
+
+    delegate :begin_pos, :end_pos, to: :expression
+
+    def expression
+      node.first
+          .loc
+          .expression
+    end
+  end
+end

data/app/services/generate_buffer.rb

@@ -0,0 +1,116 @@
+class GenerateBuffer < Parser::AST::Processor
+  include RuboCop::AST::Traversal
+  include Callable
+  
+  expects :params
+
+  DEFAULT_BUFFER = <<~NODE
+    module Fresco
+      class Dev
+      end
+    end
+  NODE
+
+  def call
+    @code = DEFAULT_BUFFER
+    @buffer = RuboCop::ProcessedSource.new(@code, 2.7)
+
+    fields.each do |field|
+      @buffer = "#{self.class}::#{field.classify}"
+                  .constantize
+                  .call(buffer: @buffer, params: params)
+    end
+
+    @buffer
+  end
+
+  private
+
+  def fields
+    params.slice(:url).keys
+  end
+
+  class Url
+    include Callable
+    expects :buffer, :params
+
+    def call
+      node = FindMethod.call(
+        meth_name: :module,
+        source: buffer
+      )
+  
+      Replace.call(
+        buffer: code,
+        node: node,
+        with: InitializeModuleClass.call(url: params[:url])
+      )
+    end
+  end
+
+  class InitializeModuleClass
+    include Callable
+    expects :url
+
+    def call
+      return {} unless url.present?
+
+      [start, finish].flatten.join("\n")
+    end
+
+    private
+
+    def start
+      levels.map.with_index(1) do |level, index|
+        if index == count
+          "class #{level.capitalize}Controller < ApplicationController"
+        else
+          "module #{level.capitalize}"
+        end
+      end
+    end
+
+    def levels
+      url.split('/').select(&:present?)
+    end
+
+    def count
+      levels.count
+    end
+
+    def finish
+      levels.map { 'end' }
+    end
+  end
+
+  class FindMethod
+    include Callable
+    expects :meth_name, :source
+
+    def call
+      source.ast
+            .each_node
+            .map { |n| n if n.type == :send && n.method_name == meth_name }
+            .compact
+    end
+  end
+
+  class Replace
+    include Callable
+    expects :code, :node, :with
+
+    def call
+      code[start...finish] = with
+    end
+
+    private
+
+    def start
+      node.first.arguments.first.loc.expression.begin_pos
+    end
+
+    def finish
+      node.first.arguments.first.loc.expression.end_pos
+    end
+  end
+end

data/app/services/import_events.rb

@@ -0,0 +1,56 @@
+# ["#{tp.path}:#{tp.lineno}", tp.defined_class, tp.event, tp.method_id, rv]
+
+require 'csv'
+
+class ImportEvents
+  def self.call
+    # Connect to a Redis server
+    redis = Redis.new(url: 'redis://localhost:6379')
+
+    begin
+      # Subscribe to a Redis channel
+      redis.subscribe('events') do |on|
+        on.message do |channel, message|
+          puts "Received message on channel #{channel}: #{message}"
+
+          event = Hashie::Mash.new(JSON.parse(message))
+
+          run = Hyperlayer::Run.where(process: event.spec.process).first_or_create
+          path = Hyperlayer::Path.where(path: event.path).first_or_create
+
+          spec_file = event.spec.tree.reverse.first
+          spec = run.specs.where(
+            location: spec_file.file_path,
+            description: spec_file.description, # sometimes a class, could also be a string for a feature spec,
+            data: spec_file.except(:file_path, :description)
+          ).first_or_create
+
+          example_groups = event.spec.tree.reverse[1..]
+          groups = example_groups.map do |example_group|
+            spec.example_groups.where(
+              location: example_group.location,
+              description: example_group.description,
+              data: example_group.except(:location, :description)
+            ).first_or_create
+          end
+
+          example_group = groups.last
+          example_group.events.create(
+            path: path,
+            line_number: event.line_number,
+            defined_class: event.defined_class,
+            event_type: event.event,
+            method: event.method_id,
+            return_value: event.return_value,
+            arguments: event.arguments,
+            variables: event.variables
+          )
+        end
+      end
+    rescue Redis::BaseConnectionError => error
+      puts "#{error}, retrying in 1s"
+      sleep 1
+      retry
+    end
+  end
+end

data/app/services/split_methods.rb

@@ -0,0 +1,50 @@
+# require 'fast'
+
+class SplitMethods < Parser::AST::Processor
+  include RuboCop::AST::Traversal
+
+  def self.call(event)
+    new.call(event)
+  end
+
+  def call(event)
+    raw_code = File.readlines(event.path.path)
+    code = raw_code.join
+    source = RuboCop::ProcessedSource.new(code, 3.2)
+
+    method_name = event.method.to_sym
+
+    method = source.ast
+                    .each_node
+                    .select do |n|
+                      # Will need to add method name here, and the delegate param
+                      #
+                      n.type == :def && method_name == n.method_name # || n.type == :send && n.method_name == :delegate
+                    end
+
+    method = method.first
+
+    DisplayMethod.call(code: code, node: method)
+  rescue => e
+    Rails.logger.info("Missing method: #{method_name}")
+  end
+
+  private
+
+  class DisplayMethod
+    include Callable
+    expects :code, :node
+
+    def call
+      code[begin_pos...end_pos]
+    end
+
+    private
+
+    delegate :begin_pos, :end_pos, to: :expression
+
+    def expression
+      node.loc.expression
+    end
+  end
+end

data/app/services/test_one.rb

@@ -0,0 +1,34 @@
+class TestOne
+  include Callable
+  expects :path
+
+  def call
+    @file = []
+    @raw_file = File.readlines(path.path).join
+
+    return @raw_file
+
+    path.events.where(event_type: 'return').each do |event|
+      href = "<a href='#'>#{event.method}</a>"
+
+      matches = @raw_file.gsub!(/#{event.method}/, href)
+    end
+
+    return @raw_file
+      
+      
+      
+      @display_file = @raw_file.map.with_index(1) do |line, index|
+      @file << line
+
+      events = path.events.where(event_type: 'return', line_number: index)
+
+      events.map do |event|
+        @file << ">>> #{event.return_value.inspect} (#{event.method})"
+        @file << "\n"
+      end
+    end
+
+    @file
+  end
+end