zapata 0.0.1

data/lib/zapata/primitive/hash.rb

@@ -0,0 +1,31 @@
+module Zapata
+  module Primitive
+    class Hash < Base
+      def node
+        body = @code
+        type = @code.type
+        OpenStruct.new(type: type, body: body)
+      end
+
+      def to_a
+        value.to_a.flatten
+      end
+
+      def dive_deeper
+      end
+
+      def to_raw
+        result = {}
+
+        node.body.to_a.each do |pair|
+          key_node, value_node = pair.to_a
+          key = Diver.dive(key_node).to_raw
+          value = Diver.dive(value_node).to_raw
+          result[key] = value
+        end
+
+        Raw.new(:hash, result)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/ivar.rb

@@ -0,0 +1,6 @@
+module Zapata
+  module Primitive
+    class Ivar < Basic
+    end
+  end
+end

data/lib/zapata/primitive/klass.rb

@@ -0,0 +1,34 @@
+module Zapata
+  module Primitive
+    class Klass < Base
+      def initialize(code)
+        @code = code
+        @moduls = Diver.current_moduls.dup
+        Diver.access_level = :public
+        Diver.current_klass = self
+        dive_deeper
+        Diver.current_klass = nil
+      end
+
+      def parent_modul_names
+        @moduls.map { |mod| mod and mod.name }.compact
+      end
+
+      def node
+        const, inherited_from_klass, body = @code.to_a
+        immediate_modul, klass = const.to_a
+        chain = parent_modul_names + [immediate_modul, klass]
+        name = chain.compact.join('::')
+        type = @code.type
+
+        OpenStruct.new(
+          type: type,
+          immediate_modul: immediate_modul,
+          klass: klass,
+          name: name,
+          body: body
+        )
+      end
+    end
+  end
+end

data/lib/zapata/primitive/lvar.rb

@@ -0,0 +1,24 @@
+module Zapata
+  module Primitive
+    class Lvar < 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)
+
+        if chosen_value.node.body == node.body
+          Raw.new(:missing, node.body.to_a.last)
+        else
+          chosen_value.to_raw
+        end
+      end
+    end
+  end
+end

data/lib/zapata/primitive/missing.rb

@@ -0,0 +1,17 @@
+module Zapata
+  module Primitive
+    class Missing
+      def initialize(name)
+        @name = name
+      end
+
+      def node
+        OpenStruct.new(type: :missing)
+      end
+
+      def to_raw
+        Raw.new(:missing, @name)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/modul.rb

@@ -0,0 +1,20 @@
+module Zapata
+  module Primitive
+    class Modul < Base
+      def initialize(code)
+        @code = code
+        Diver.current_moduls << self
+        dive_deeper
+        Diver.current_moduls.pop
+      end
+
+      def node
+        const, body = @code.to_a
+        modul, name = const.to_a
+        type = @code.type
+
+        OpenStruct.new(type: type, modul: modul, name: name, body: body)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/nil.rb

@@ -0,0 +1,16 @@
+module Zapata
+  module Primitive
+    class Nil < Basic
+      def initialize
+      end
+
+      def node
+        OpenStruct.new(type: :nil)
+      end
+
+      def to_raw
+        Raw.new(:nil, nil)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/optarg.rb

@@ -0,0 +1,18 @@
+module Zapata
+  module Primitive
+    class Optarg < Base
+      def node
+        name, body = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, name: name, body: body)
+      end
+
+      def dive_deeper
+      end
+
+      def to_raw
+        Diver.dive(node.body).to_raw
+      end
+    end
+  end
+end

data/lib/zapata/primitive/raw.rb

@@ -0,0 +1,16 @@
+module Zapata
+  module Primitive
+    class Raw
+      attr_accessor :type, :value
+
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+
+      def to_raw
+        self
+      end
+    end
+  end
+end

data/lib/zapata/primitive/send.rb

@@ -0,0 +1,48 @@
+module Zapata
+  module Primitive
+    class Send < Base
+      def initialize(code)
+        super
+
+        if node.name == :private
+          Diver.access_level = :private
+        elsif node.name == :protected
+          Diver.access_level = :protected
+        elsif node.name == :public
+          Diver.access_level = :public
+        end
+      end
+
+      def to_a
+        [value]
+      end
+
+      def node
+        receiver, name, args = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, name: name, args: args, receiver: receiver)
+      end
+
+      def raw_receiver
+        return unless node.receiver
+        Diver.dive(node.receiver).to_raw
+      end
+
+      def to_raw
+        if raw_receiver and raw_receiver.type == :const
+          Raw.new(:const_send, "#{Printer.print(raw_receiver)}.#{node.name}#{Predictor::Args.literal(node.args)}")
+        elsif %i(+ - * /).include?(node.name)
+          Raw.new(:super, node.name)
+        else
+          predicted = Predictor::Args.choose_value(node.name, self).to_raw
+
+          if predicted.type == :missing
+            Raw.new(:super, node.name)
+          else
+            predicted
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zapata/primitive/sklass.rb

@@ -0,0 +1,20 @@
+module Zapata
+  module Primitive
+    class Sklass < Base
+      def initialize(code)
+        @code = code
+
+        Diver.current_sklass = self
+        dive_deeper
+        Diver.current_sklass = nil
+      end
+
+      def node
+        receiver_self, body = @code.to_a
+        type = @code.type
+
+        OpenStruct.new(type: type, body: body)
+      end
+    end
+  end
+end

data/lib/zapata/primitive/var.rb

@@ -0,0 +1,25 @@
+module Zapata
+  module Primitive
+    class Var < Base
+      def node
+        name, body = @code.to_a
+        type = @code.type
+        OpenStruct.new(type: type, name: name, body: body)
+      end
+
+      def literal
+        Diver.dive(node.body).literal
+      end
+
+      def to_raw
+        raw = Diver.dive(node.body).to_raw
+
+        if raw.type == :super
+          Missing.new(node.name).to_raw
+        else
+          raw
+        end
+      end
+    end
+  end
+end

data/lib/zapata/printer.rb

@@ -0,0 +1,93 @@
+module Zapata
+  class Printer
+    class << self
+      def print(raw)
+        case raw.type
+        when :const, :send, :int, :const_send, :literal, :float
+          raw.value
+        when :str
+          # decide which one to use
+          # "\"#{raw.value}\""
+          "'#{raw.value}'"
+        when :sym
+          ":#{raw.value}"
+        when :true
+          true
+        when :false
+          false
+        when :array
+          array(raw.value)
+        when :hash
+          hash(raw.value)
+        when :nil
+          'nil'
+        when :missing
+          print(Primitive::Raw.new(:str, "Missing \"#{raw.value}\""))
+        when :ivar
+          RZpec::Writer.ivars << raw
+          to_var_name(raw.value)
+        else
+          raise "Not yet implemented #{raw}"
+        end
+      end
+
+      def array(given_array)
+        unnested_array = given_array.map { |el| unnest(el) }
+        "[#{unnested_array.join(', ')}]"
+      end
+
+      def args(given_args, klass)
+        return unless given_args.present?
+
+        if klass == Array
+          array_without_closers = given_args[1...-1]
+          return unless array_without_closers.present?
+
+          "(#{array_without_closers})"
+        elsif [Fixnum, Symbol].include?(klass)
+          "(#{given_args})"
+        elsif klass == Hash
+          "(#{given_args})"
+        else
+          raise "Not yet implemented"
+        end
+      end
+
+      def hash(obj)
+        unnested_hash = obj.each_with_object({}) do |(key, val), obj|
+          unnested_key = unnest(key)
+          unnested_val = unnest(val)
+          obj[unnested_key] = unnested_val
+        end
+
+        all_keys_symbols = unnested_hash.keys.all? do |key|
+          Parser::CurrentRuby.parse(key.to_s).type == :sym
+        end
+
+        values = unnested_hash.map do |key, val|
+          if all_keys_symbols
+            "#{key[1..-1]}: #{val}"
+          else
+            "#{key} => #{val}"
+          end
+        end
+
+        "{ #{values.join(', ')} }"
+      end
+
+      def unnest(raw)
+        return raw unless raw.respond_to?(:value)
+
+        if raw.value.is_a?(Primitive::Raw)
+          print(unnest(raw.value))
+        else
+          print(raw)
+        end
+      end
+
+      def to_var_name(name)
+        name.to_s.split('::').last.underscore.delete('@')
+      end
+    end
+  end
+end

data/lib/zapata/rzpec/runner.rb

@@ -0,0 +1,67 @@
+module Zapata
+  module RZpec
+    class Runner
+      attr_reader :ran
+
+      def initialize(spec_filename)
+        @spec_filename = spec_filename
+        run
+        # silence { run }
+      end
+
+      def silence
+        original_stderr = $stderr.dup
+        original_stdout = $stdout.dup
+
+        $stdout.reopen('/dev/null', 'w')
+        $stdout.reopen('/dev/null', 'w')
+
+        yield
+
+        $stderr = original_stderr
+        $stdout = original_stdout
+      end
+
+      def methodz
+        examples.index_by { |ex| ex['description'].delete('#').to_sym }
+      end
+
+      def result_message(method_name)
+        methodz[method_name]['exception']['message']
+      end
+
+      def expected(method_name)
+        report_lines = result_message(method_name).to_s.split(/\n/)
+        expected_line = report_lines.detect { |line| line.match('got:') }
+
+        if expected_line
+          clean_expected_line = expected_line[10..-1]
+
+          if (matches = clean_expected_line.match(/\#\<(.+):(.+)\>/))
+            "'Returned instance object #{matches[1]}'"
+          else
+            Printer.print(Diver.dive(Parser::CurrentRuby.parse(clean_expected_line)).to_raw)
+          end
+        else
+         "'Exception in RSpec'"
+        end
+      end
+
+      def run
+        @ran = true
+
+        @stdin, @stdout, @stderr = Bundler.with_clean_env do
+          Open3.popen3("bundle exec rspec #{@spec_filename} --format j")
+        end
+      end
+
+      def examples
+        parsed_json_result['examples']
+      end
+
+      def parsed_json_result
+        @json ||= JSON.parse(@stdout.readlines.last)
+      end
+    end
+  end
+end