turbo_test_static_analysis 0.1.0

data/README.md

@@ -0,0 +1,27 @@
+![Tests](https://github.com/dunkelbraun/turbo_test_static_analysis/workflows/Tests/badge.svg?branch=main)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b80b14e60467094e6c92/maintainability)](https://codeclimate.com/github/dunkelbraun/turbo_test_static_analysis/maintainability)
+[![Coverage Status](https://coveralls.io/repos/github/dunkelbraun/turbo_test_static_analysis/badge.svg?branch=main)](https://coveralls.io/github/dunkelbraun/turbo_test_static_analysis?branch=main)
+
+# TurboTestStaticAnalysis
+
+
+Pending description.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dunkelbraun/turbo_test_static_analysis. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/dunkelbraun/turbo_test_static_analysis/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TurboTestStaticAnalysis project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/dunkelbraun/turbo_test_static_analysis/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+ENV["TESTOPTS"] = "#{ENV['TESTOPTS']} --verbose"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test
+
+if ENV["CI"]
+  require "coveralls/rake/task"
+  Coveralls::RakeTask.new
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "turbo_test_events"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/turbo_test_static_analysis.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "turbo_test_static_analysis/version"
+
+require_relative "turbo_test_static_analysis/active_record_schema"
+require_relative "turbo_test_static_analysis/constants"

data/lib/turbo_test_static_analysis/active_record_schema.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "active_record_schema/diff"
+require_relative "active_record_schema/map"
+require_relative "active_record_schema/snapshot"
+require_relative "active_record_schema/diff_compute"
+require_relative "active_record_schema/constructor"
+require_relative "active_record_schema/sexp_builder/line_column_stack"
+require_relative "active_record_schema/sexp_builder/sexp_builder"
+require_relative "active_record_schema/sexp_builder/line_stack_sexp_builder"
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class << self
+        def schema_changes(new_schema, old_schema)
+          current_snapshot = SexpBuilder.snapshot_from_source(new_schema)
+          previous_snapshot = SexpBuilder.snapshot_from_source(old_schema)
+          changes = DiffCompute.new(current_snapshot, previous_snapshot).calc
+          {
+            extensions: changes[:extensions].to_h,
+            tables: changes[:tables].to_h
+          }
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/constructor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class Constructor
+        def initialize
+          @schema = Snapshot.new
+          @fingerprints = {}
+        end
+
+        def enable_extension(name, content)
+          extensions[name] = Digest::MD5.hexdigest(content)
+        end
+
+        def fingerprint(table_name, content)
+          @fingerprints[table_name] ||= []
+          @fingerprints[table_name] << content
+        end
+
+        alias add_index fingerprint
+        alias add_foreign_key fingerprint
+        alias create_table fingerprint
+        alias create_trigger fingerprint
+
+        remove_method :fingerprint
+
+        def snapshot
+          add_fingerprints
+          @schema
+        end
+
+        private
+
+        def extensions
+          @schema[:extensions]
+        end
+
+        def tables
+          @schema[:tables]
+        end
+
+        def add_fingerprints
+          @fingerprints.each_pair.each_with_object(tables) do |(key, val), memo|
+            memo[key] = Digest::MD5.hexdigest(val.sort.join)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/diff.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      Diff = Struct.new(:changed, :added, :deleted) do
+        def initialize(*)
+          super
+          self.changed ||= []
+          self.added ||= []
+          self.deleted ||= []
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/diff_compute.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class DiffCompute
+        def initialize(new_snapshot, old_snapshot)
+          @data = { new: new_snapshot, old: old_snapshot }
+        end
+
+        def calc
+          empty_diff.tap do |diff|
+            compute(:extensions, diff[:extensions])
+            compute(:tables, diff[:tables])
+          end
+        end
+
+        private
+
+        def empty_diff
+          {
+            extensions: Diff.new,
+            tables: Diff.new
+          }
+        end
+
+        def compute(type, diff)
+          compute_added_changed type, diff
+          compute_deleted type, diff
+        end
+
+        def compute_added_changed(type, diff)
+          iterator = @data.dig(:new, type).each_pair
+          iterator.each_with_object(diff) do |(name, fgpt), memo|
+            old_data = @data.dig(:old, type)
+            unless old_data[name]
+              memo.added << name
+              next memo
+            end
+            memo.changed << name if fgpt != old_data[name]
+          end
+        end
+
+        def compute_deleted(type, diff)
+          @data.dig(:old, type).each_key.each_with_object(diff) do |name, memo|
+            memo.deleted << name unless @data.dig(:new, type)[name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/map.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      Map = Struct.new(:extensions, :tables) do
+        def initialize(*)
+          super
+          self.extensions ||= []
+          self.tables ||= []
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/sexp_builder/line_column_stack.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class LineColumnStack
+        extend Forwardable
+
+        def_delegators :@_stack, :pop, :last, :any?
+
+        def initialize
+          @_stack = []
+        end
+
+        def push(line, column)
+          line_column = [line, column]
+          @_stack.push line_column unless @_stack.last == line_column
+        end
+
+        def remove_greater_than(line_column)
+          first_pop = nil
+          while last && greater(last, line_column)
+            line = pop
+            first_pop ||= line
+          end
+          first_pop
+        end
+
+        private
+
+        def greater(line_column_a, line_column_b)
+          line_column_a[0] > line_column_b[0] ||
+            (line_column_a[0] == line_column_b[0] &&
+              line_column_a[1] >= line_column_b[1])
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/sexp_builder/line_stack_sexp_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class LineStackSexpBuilder < Ripper::SexpBuilder
+        EVENTS_TO_REJECT = [:magic_comment].freeze
+
+        ARITIES = ["()", "(a)", "(a,b)", "(a,b,c)", "(a,b,c,d)",
+                   "(a,b,c,d,e)", "(a,b,c,d,e,f)", "(a,b,c,d,e,f,g)",
+                   "(a,b,c,d,e,f,g,h)"].freeze
+
+        Ripper::PARSER_EVENT_TABLE.each do |method, arity|
+          next if EVENTS_TO_REJECT.include?(method)
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def on_#{method}#{ARITIES[arity]}
+              super.tap do |result|
+                stack_line
+              end
+            end
+          RUBY
+        end
+
+        attr_reader :stack
+
+        def initialize(path, filename = "-", lineno = 1)
+          super
+          @stack = LineColumnStack.new
+        end
+
+        def stack_line
+          @stack.push lineno, column
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/active_record_schema/sexp_builder/sexp_builder.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "digest"
+require "sorcerer"
+require_relative "line_stack_sexp_builder"
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      class SexpBuilder < LineStackSexpBuilder
+        COMMANDS = %w[add_index add_foreign_key enable_extension].freeze
+        TABLE_REGEXP = /create_table\s"(\w+)"/.freeze
+        TRIGGER_REGEXP = /create_trigger\("(\w+)".+on\("(\w+)"/.freeze
+        COMMAND_REGEXP = /\b(\w+)\b/.freeze
+
+        attr_accessor :schema
+
+        def initialize(path, filename = "-", lineno = 1)
+          super
+          @schema_file = path.split("\n")
+          @schema = Constructor.new
+        end
+
+        def self.snapshot_from_file(path)
+          builder = new(File.read(path), path)
+          builder.parse
+          builder.snapshot
+        end
+
+        def self.snapshot_from_source(source)
+          builder = new(source)
+          builder.parse
+          builder.snapshot
+        end
+
+        def snapshot
+          @schema.snapshot
+        end
+
+        def on_command(token_one, token_two)
+          super.tap do |_result|
+            name = token_one[1]
+            next unless COMMANDS.include? name
+
+            last_line = @stack.remove_greater_than([lineno, column])
+            content = method_content(lineno, last_line[0])
+            @schema.send(name.to_sym, table_name(:command, token_two), content)
+          end
+        end
+
+        def on_method_add_block(token_one, token_two)
+          super.tap do |_result|
+            next unless (type = type_for_token(token_one[0]))
+
+            first_line, last_line = send("#{type}_lines", token_one)
+            handle_create(type, token_one, first_line, last_line)
+          end
+        end
+
+        private
+
+        def type_for_token(token)
+          case token
+          when :command
+            :table
+          when :method_add_arg
+            :trigger
+          end
+        end
+
+        def table_lines(token)
+          return unless token[1][1] == "create_table"
+
+          last_line = @stack.remove_greater_than(token[1][2])
+          [token[1][2][0], last_line[0]]
+        end
+
+        def trigger_lines(token)
+          fcall = extract_fcall(token[1])
+          return unless fcall[0] == "create_trigger"
+
+          first_line = fcall[1]
+          last_line = @stack.remove_greater_than(first_line)
+          [first_line[0], last_line[0]]
+        end
+
+        def handle_create(type, token, line_start, line_end)
+          return unless line_start && line_end
+
+          table = table_name(type, token)
+          content = method_content(line_start, line_end)
+          @schema.send("create_#{type}".to_sym, table, content)
+        end
+
+        def table_name(type, token)
+          regexp = self.class.const_get "#{type.upcase}_REGEXP"
+          match = Sorcerer.source(token).match(regexp)
+          case type
+          when :trigger
+            match[1..2][1]
+          else
+            match[1]
+          end
+        end
+
+        def method_content(start_line, end_line)
+          lines_str(start_line, end_line)
+        end
+
+        def extract_fcall(token)
+          case token[0]
+          when :fcall
+            [token[1][1], token[1][2]]
+          when :call
+            extract_fcall(token[1][1])
+          else
+            []
+          end
+        end
+
+        def lines_str(from, to)
+          from -= 1
+          to -= 1
+          @schema_file[from..to].join("")
+        end
+      end
+    end
+  end
+end