zapata 0.0.1

data/lib/zapata/db.rb

@@ -0,0 +1,32 @@
+module Zapata
+  class DB
+    @records = []
+    @locs = []
+
+    class << self
+      def create(record)
+        loc = record.code.loc
+
+        unless @locs.include?(loc)
+          @records << record
+          @locs << loc
+          record
+        end
+      end
+
+      def all
+        @records
+      end
+
+      def destroy_all
+        @records = []
+      end
+    end
+  end
+
+  class SaveManager
+    def self.clean(name)
+      name.to_s.delete('@').to_sym
+    end
+  end
+end

data/lib/zapata/diver.rb

@@ -0,0 +1,81 @@
+module Zapata
+  RETURN_TYPES = %i(missing raw const_send sym float str int ivar true false const nil)
+  DIVE_TYPES = %i(args begin block defined? nth_ref splat kwsplat class
+    block_pass sclass masgn or and irange erange when and
+    return array kwbegin yield while dstr ensure pair)
+  ASSIGN_TYPES = %i(ivasgn lvasgn or_asgn casgn optarg)
+  DEF_TYPES = %i(def defs)
+  HARD_TYPES = %i(if dsym resbody mlhs next self break zsuper
+    super retry rescue match_with_lvasgn case op_asgn regopt regexp)
+  TYPES_BY_SEARCH_FOR = {
+    klass: %i(class),
+    var: ASSIGN_TYPES,
+    def: DEF_TYPES,
+    send: %i(send),
+  }
+
+  PRIMITIVE_TYPES = {
+    Def: %i(def),
+    Defs: %i(defs),
+    Send: %i(send),
+    Array: %i(args array),
+    Hash: %i(hash),
+    Ivar: %i(ivar),
+    Lvar: %i(lvar),
+    Klass: %i(class),
+    Sklass: %i(sclass),
+    Modul: %i(module),
+    Const: %i(const),
+    Optarg: %i(optarg),
+    Arg: %i(arg),
+    Basic: RETURN_TYPES,
+    Casgn: %i(casgn),
+    Var: ASSIGN_TYPES,
+  }.freeze
+
+  class Diver
+    class << self
+      attr_accessor :current_moduls, :current_klass, :current_sklass, :access_level
+
+      def search_for(what)
+        @search_for = what
+        @current_moduls ||= []
+      end
+
+      def dive(code)
+        unless code
+          return Primitive::Nil.new
+        end
+
+        current_type = code.type
+        return Primitive::Raw.new(:missing, :hard_type) if HARD_TYPES.include?(current_type)
+
+        subklass_pair = PRIMITIVE_TYPES.detect do |_, types|
+          types.include?(current_type)
+        end
+
+        if subklass_pair
+          klass = "Zapata::Primitive::#{subklass_pair.first}".constantize
+          result = klass.new(code)
+
+          DB.create(result) if search_for_types.include?(current_type)
+        else
+        end
+
+        deeper_dives(code) if DIVE_TYPES.include?(current_type)
+
+        result || Primitive::Raw.new(:super, nil)
+      end
+
+      def search_for_types
+        TYPES_BY_SEARCH_FOR[@search_for]
+      end
+
+      def deeper_dives(code)
+        code.to_a.compact.each do |part|
+          dive(part)
+        end
+      end
+    end
+  end
+end

data/lib/zapata/predictor/args.rb

@@ -0,0 +1,94 @@
+module Zapata
+  module Predictor
+    class Args
+      class << self
+        def literal(args_node)
+          raw_args = Diver.dive(args_node).to_raw
+          chosen_args = choose_values(raw_args)
+
+          args_in_string = case chosen_args
+          when Array
+            rebuilt = chosen_args.map do |primitive|
+              Printer.print(primitive)
+            end
+
+            raw_array = Primitive::Raw.new(:array, rebuilt)
+            Printer.print(raw_array)
+          when Hash
+            rebuilt = chosen_args.each_with_object({}) do |(key, val), obj|
+              obj[Printer.print(key)] = Printer.print(val)
+            end
+
+            raw_hash = Primitive::Raw.new(:hash, rebuilt)
+            Printer.print(raw_hash)
+          when Integer
+            raw_int = Primitive::Raw.new(:int, chosen_args)
+            Printer.print(raw_int)
+          when NilClass
+            nil
+          when Symbol
+            raw_sym = Primitive::Raw.new(:sym, chosen_args)
+            Printer.print(raw_sym)
+          else
+            raise "Not yet implemented"
+          end
+
+          Printer.args(args_in_string, chosen_args.class)
+        end
+
+        def choose_values(raw_args)
+          case raw_args.type
+          when :array
+            raw_args.value.map do |arg|
+              if (RETURN_TYPES + [:array, :hash]).include?(arg.type)
+                arg
+              else
+                choose_value(arg.value, arg).to_raw
+              end
+            end
+          when :hash
+            raw_args.value.each_with_object({}) do |(rkey, rval), obj|
+              key = if RETURN_TYPES.include?(rkey.type)
+                rkey
+              else
+                choose_value(rkey.value, rkey).to_raw
+              end
+
+              val = if RETURN_TYPES.include?(rval.type)
+                rval
+              else
+                choose_value(rval.value, rval).to_raw
+              end
+
+              obj[key] = val
+            end
+          when :int, :missing, :nil
+            raw_args.value
+          else
+            raise "Not yet implemented"
+          end
+        end
+
+        def choose_value(name, finder = nil)
+          return Primitive::Raw.new(:nil, nil) if name.nil?
+          return finder if finder and RETURN_TYPES.include?(finder.type)
+
+          possible_values = Revolutionist.analysis_as_array.select do |element|
+            !is_a_finder?(element, finder) and element.name == name
+          end
+
+          if possible_values.empty?
+            return Primitive::Raw.new(:super, name)
+          end
+
+          Chooser.new(possible_values).by_probability
+        end
+
+        def is_a_finder?(primitive, finder)
+          return false unless finder
+          primitive.class == finder.class and primitive.name == finder.name
+        end
+      end
+    end
+  end
+end

data/lib/zapata/predictor/chooser.rb

@@ -0,0 +1,27 @@
+module Zapata
+  module Predictor
+    class Chooser
+      def initialize(possible_values)
+        @possible_values = possible_values.dup
+      end
+
+      def by_probability
+        return if @possible_values.empty?
+
+        by_count
+      end
+
+      private
+
+      def by_count
+        group_with_counts(@possible_values).max_by { |_, v| v }.first
+      end
+
+      def group_with_counts(values)
+        values.each_with_object(Hash.new(0)) do |value, obj|
+          obj[value] += 1
+        end
+      end
+    end
+  end
+end

data/lib/zapata/primitive/arg.rb

@@ -0,0 +1,24 @@
+module Zapata
+  module Primitive
+    class Arg < Base
+      def node
+        name = @code.to_a.first
+        type = @code.type
+        OpenStruct.new(type: type, name: name, body: @code)
+      end
+
+      def dive_deeper
+      end
+
+      def to_raw
+        chosen_value = Predictor::Args.choose_value(node.name, self).to_raw
+
+        if chosen_value.type == :super
+          Missing.new(node.name).to_raw
+        else
+          chosen_value
+        end
+      end
+    end
+  end
+end

data/lib/zapata/primitive/array.rb

@@ -0,0 +1,39 @@
+module Zapata
+  module Primitive
+    class Array < Base
+      def node
+        body = @code
+        type = @code.type
+        OpenStruct.new(type: type, body: body)
+      end
+
+      def dive_deeper
+      end
+
+      def to_a
+        value
+      end
+
+      def to_raw
+        value = node.body.to_a.map do |node|
+          primitive = Diver.dive(node)
+          raw = primitive.to_raw
+
+          if raw.type == :super
+            predicted = Predictor::Args.choose_value(raw.value).to_raw
+
+            if predicted.type == :super
+              Missing.new(primitive.name).to_raw
+            else
+              predicted
+            end
+          else
+            raw
+          end
+        end
+
+        Raw.new(:array, value)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/base.rb

@@ -0,0 +1,28 @@
+module Zapata
+  module Primitive
+    class Base
+      attr_accessor :code, :type
+
+      def initialize(code)
+        @code = code
+        @type = code.type
+        dive_deeper
+      end
+
+      def name
+        SaveManager.clean(node.name)
+      end
+
+      def dive_deeper
+        unless RETURN_TYPES.include?(node.type)
+          Diver.dive(node.args)
+          Diver.dive(node.body)
+        end
+      end
+
+      def to_raw
+        Diver.dive(node.body).to_raw
+      end
+    end
+  end
+end

data/lib/zapata/primitive/basic.rb

@@ -0,0 +1,22 @@
+module Zapata
+  module Primitive
+    class Basic < Primitive::Base
+      def to_a
+        [value]
+      end
+
+      def node
+        body = @code
+        type = @code.type
+        OpenStruct.new(type: type, body: body)
+      end
+
+      def dive_deeper
+      end
+
+      def to_raw
+        Raw.new(node.body.type, node.body.to_a.last)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/casgn.rb

@@ -0,0 +1,15 @@
+module Zapata
+  module Primitive
+    class Casgn < Base
+      def node
+        modul, name, body = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, modul: modul, name: name, body: body)
+      end
+
+      def literal
+        Diver.dive(node.body).literal
+      end
+    end
+  end
+end

data/lib/zapata/primitive/const.rb

@@ -0,0 +1,15 @@
+module Zapata
+  module Primitive
+    class Const < Primitive::Basic
+      def node
+        modul, klass = @code.to_a
+        type = @code.type
+        OpenStruct.new(modul: modul, klass: klass, type: type)
+      end
+
+      def to_raw
+        Raw.new(:const, [node.modul, node.klass].compact.join('::'))
+      end
+    end
+  end
+end

data/lib/zapata/primitive/def.rb

@@ -0,0 +1,33 @@
+module Zapata
+  module Primitive
+    class Def < Base
+      attr_accessor :klass
+
+      def initialize(code)
+        @code = code
+        @klass = Diver.current_klass
+        @self = Diver.current_sklass
+        @access_level = Diver.access_level
+        dive_deeper
+      end
+
+      def self?
+        !!@self
+      end
+
+      def public?
+        @access_level == :public
+      end
+
+      def node
+        name, args, body = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, name: name, args: args, body: body)
+      end
+
+      def literal_predicted_args
+        Predictor::Args.literal(node.args)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/defs.rb

@@ -0,0 +1,32 @@
+module Zapata
+  module Primitive
+    class Defs < Base
+      attr_accessor :klass
+
+      def initialize(code)
+        @code = code
+        @klass = Diver.current_klass
+        @access_level = Diver.access_level
+        dive_deeper
+      end
+
+      def self?
+        true
+      end
+
+      def public?
+        @access_level == :public
+      end
+
+      def node
+        receiver, name, args, body = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, name: name, args: args, body: body)
+      end
+
+      def literal_predicted_args
+        Predictor::Args.literal(node.args)
+      end
+    end
+  end
+end