codeminer 0.1.0

data/lib/codeminer/processors/argument_processor.rb

@@ -0,0 +1,25 @@
+module CodeMiner
+
+  module ArgumentProcessor
+
+    def on_args_new
+      ArgumentsExpression.new(SourceExtract::Partial.new(@src, lineno(), column()))
+    end
+
+    def on_args_add_block(exp, block)
+      exp.block = block
+      exp
+    end
+
+    def on_args_add(args, exp)
+      args.adjust_src(exp.src_extract)
+      args.add(exp)
+    end
+
+    def on_args_add_star(args, exp)
+      args.add(SplatExpression.new(exp, extract_src(exp.line, exp.column - 1, exp.end_line, exp.end_column)))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/array_processor.rb

@@ -0,0 +1,86 @@
+module CodeMiner
+
+  module ArrayProcessor
+
+    def on_array(args)
+      ArrayExpression.new(args, extract_src_from_args(args))
+    end
+
+    def on_qwords_new
+      ArgumentsExpression.new(SourceExtract::Partial.new(@src, lineno(), column()), @qwords.pop)
+    end
+
+    def on_qwords_add(args, str)
+      args.add(str)
+    end
+
+    def on_qsymbols_new
+      ArgumentsExpression.new(SourceExtract::Partial.new(@src, lineno(), column()), @qsymbols.pop)
+    end
+
+    def on_qsymbols_add(args, string)
+      args.add(SymbolExpression.convert(string))
+    end
+
+    def on_symbols_new
+      ArgumentsExpression.new(SourceExtract::Partial.new(@src, lineno(), column()), @symbols.pop)
+    end
+
+    def on_symbols_add(args, string)
+      args.add(SymbolExpression.convert(string))
+    end
+
+    def on_word_add(words, word)
+      word
+    end
+
+    def on_word_new
+
+    end
+
+    def on_words_add(words, word)
+      words.add(StringExpression.convert(word))
+    end
+
+    def on_words_new
+      ArgumentsExpression.new(SourceExtract::Partial.new(@src, lineno(), column()), @words.pop)
+    end
+
+    def on_qwords_beg(*)
+      super.tap do |token|
+        @qwords << token
+      end
+    end
+
+    def on_qsymbols_beg(*)
+      super.tap do |token|
+        @qsymbols << token
+      end
+    end
+
+    def on_symbols_beg(*)
+      super.tap do |token|
+        @symbols << token
+      end
+    end
+
+    def on_words_beg(*)
+      super.tap do |token|
+        @words << token
+      end
+    end
+
+    private
+
+    def extract_src_from_args(args)
+      if args
+        size = args.token ? args.token.value.length : 1
+        extract_src(args.line, args.column - size)
+      else
+        extract_src(lineno(), column() - 2)
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/assignment_processor.rb

@@ -0,0 +1,42 @@
+module CodeMiner
+
+  module AssignmentProcessor
+
+    def on_assign(exp, body)
+      klass = case exp.type
+                when :local_variable
+                  LocalAssignExpression
+                when :global_variable
+                  GlobalVariableAssignExpression
+                when :instance_variable
+                  InstanceVariableAssignExpression
+                when :class_variable
+                  ClassVariableAssignExpression
+                when :field
+                  AttributeAssignExpression
+                when :constant
+                  ConstantAssignExpression
+                when :aref_field
+                  ArefAssignExpression
+                when :colon2
+                  Colon2AssignExpression
+                when :colon3
+                  Colon3AssignExpression
+                else
+                  assert(false, "#{exp.type} is not a valid assignment")
+              end
+      klass.new(exp, body, extract_src_by_tokens(exp, body))
+    end
+
+    def on_massign(container, values)
+      value_container = ExpressionContainer.wrap(values, :values)
+      MultipleAssignmentExpression.new(container, value_container, extract_src_by_tokens(container, values))
+    end
+
+    def on_opassign(variable, op, body)
+      OpAssignExpression.new(variable, op, body, extract_src_by_tokens(variable, body))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/binary_processor.rb

@@ -0,0 +1,12 @@
+module CodeMiner
+
+  module BinaryProcessor
+
+    def on_binary(left, value, right)
+      token = Token.new(:op, value.to_s, extract_src_by_value(value))
+      BinaryExpression.new(token, left, right, extract_src_by_tokens(left, right))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/call_processor.rb

@@ -0,0 +1,32 @@
+module CodeMiner
+
+  module CallProcessor
+
+    def on_vcall(token)
+      CallExpression.new(token, extract_src_by_token(token, token.line, token.end_column))
+    end
+
+    def on_call(receiver, delimiter, token)
+      if token == :call
+        token = Token.new(:ident, token.to_s, extract_src_by_value(delimiter))
+      end
+      receiver.delimiter = delimiter
+      CallExpression.new(token, extract_src_by_tokens(receiver, token), receiver: receiver)
+    end
+
+    def on_fcall(token)
+      CallExpression.new(token, extract_src_by_token(token))
+    end
+
+    def on_aref(receiver, args)
+      args.src = extract_src(@lbracket.line, @lbracket.column + 1, lineno(), column() - 1)
+      CallExpression.new(@lbracket, extract_src_by_token(receiver), receiver: receiver, arguments: args)
+    end
+
+    def on_aref_field(receiver, args)
+      ArefFieldExpression.new(@lbracket, receiver, args, extract_src_by_tokens(receiver, args))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/class_processor.rb

@@ -0,0 +1,19 @@
+module CodeMiner
+
+  module ClassProcessor
+
+    def on_class(token, parent, body)
+      ClassExpression.new(token, parent, body, extract_src_by_token(pop_keyword('class')))
+    end
+
+    def on_sclass(context, body)
+      SClassExpression.new(context, body, extract_src_by_token(pop_keyword('class')))
+    end
+
+    def on_module(token, body)
+      ModuleExpression.new(token, body, extract_src_by_token(pop_keyword('module')))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/command_processor.rb

@@ -0,0 +1,15 @@
+module CodeMiner
+
+  module CommandProcessor
+
+    def on_command(token, args)
+      CommandExpression.new(token, args, extract_src_by_tokens(token, args))
+    end
+
+    def on_command_call(receiver, delimiter, token, args)
+      CommandExpression.new(token, args, extract_src_by_tokens(receiver, args), receiver)
+    end
+
+  end
+
+end

data/lib/codeminer/processors/condition_processor.rb

@@ -0,0 +1,59 @@
+module CodeMiner
+
+  module ConditionProcessor
+
+    def on_if(test, consequence, else_statement)
+      token = pop_keyword('if')
+      ConditionExpression.new(test, consequence, else_statement, token, extract_src_by_token(token))
+    end
+
+    def on_elsif(test, consequence, else_statement)
+      token = pop_keyword('elsif')
+      ConditionExpression.new(test, consequence, else_statement, token, extract_src_by_token(token))
+    end
+
+    def on_unless(test, consequence, else_statement)
+      token = pop_keyword('unless')
+      ConditionExpression.new(test, else_statement, consequence, token, extract_src_by_token(token))
+    end
+
+    def on_else(body)
+      ElseExpression.new(body, extract_src_by_tokens(pop_keyword('else'), body))
+    end
+
+    def on_if_mod(test, consequence)
+      consequence_body = BodyExpression.from(consequence)
+      ConditionExpression.new(test, consequence_body, nil, pop_keyword('if'), extract_src(consequence.line, consequence.column))
+    end
+
+    def on_unless_mod(test, else_expression)
+      else_body = BodyExpression.from(else_expression)
+      ConditionExpression.new(test, nil, else_body, pop_keyword('unless'), extract_src_by_token(else_expression))
+    end
+
+    def on_ifop(test, consequence, else_statement)
+      ConditionExpression.new(test, BodyExpression.from(consequence), BodyExpression.from(else_statement), nil, extract_src_by_tokens(test, else_statement))
+    end
+
+    def on_case(test, whens)
+      CaseExpression.new(test, extract_whens(whens), extract_src_by_token(pop_keyword('case')))
+    end
+
+    def on_when(arg, body, else_exp)
+      WhenExpression.new(arg, body, else_exp, extract_src_by_tokens(pop_keyword('when'), body))
+    end
+
+    private
+
+    def extract_whens(when_exp)
+      [when_exp].tap do |whens|
+        until when_exp.else.nil? || when_exp.else.type == :else
+          whens << when_exp.else
+          when_exp = when_exp.else
+        end
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/default_processor.rb

@@ -0,0 +1,33 @@
+module CodeMiner
+
+  require 'ripper'
+
+  module DefaultProcessor
+
+    Ripper::SCANNER_EVENTS.each do |event|
+      define_method :"on_#{event}" do |value|
+        Token.new(event.to_sym, value, extract_src_by_value(value))
+      end
+    end
+
+    Ripper::PARSER_EVENT_TABLE.each do |event, arity|
+      next if event == :parse_error
+      if /_new\z/ =~ event.to_s and arity == 0
+        define_method :"on_#{event}" do
+          []
+        end
+      elsif /_add\z/ =~ event.to_s
+        define_method :"on_#{event}" do |list, item|
+          list.tap { |l| l << item }
+        end
+      else
+        define_method :"on_#{event}" do |*args|
+          src = extract_src_by_token(args.first) if args.first
+          UnknownExpression.new(event.to_sym, nil, src, [], lineno(), column())
+        end
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/hash_processor.rb

@@ -0,0 +1,27 @@
+module CodeMiner
+
+  module HashProcessor
+
+    def on_hash(pairs)
+      HashExpression.new(pairs.to_a, extract_src_by_token(@lbrace.pop))
+    end
+
+    def on_bare_assoc_hash(pairs)
+      HashExpression.new(pairs.to_a, extract_src_by_tokens(pairs.first, pairs.last))
+    end
+
+    def on_assoclist_from_args(pairs)
+      pairs
+    end
+
+    def on_assoc_new(key, value)
+      HashPairExpression.new(key, value, extract_src_by_token(key, value.end_line, value.end_column))
+    end
+
+    def on_label(value)
+      Token.new(:symbol, value.chomp(':'), extract_src_by_value(value))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/loop_processor.rb

@@ -0,0 +1,30 @@
+module CodeMiner
+
+  module LoopProcessor
+
+    def on_until_mod(test, body)
+      pop_keyword('until')
+      UntilExpression.new(test, body, extract_src_by_token(body))
+    end
+
+    def on_until(test, body)
+      UntilExpression.new(test, body, extract_src_by_token(pop_keyword('until')))
+    end
+
+    def on_while(test, body)
+      WhileExpression.new(test, body, extract_src_by_token(pop_keyword('while')))
+    end
+
+    def on_while_mod(test, body)
+      pop_keyword('while')
+      WhileExpression.new(test, body, extract_src_by_token(body))
+    end
+
+    def on_for(params, receiver, body)
+      params_container = ExpressionContainer.wrap(params, :positional)
+      ForExpression.new(params_container, receiver, body, extract_src_by_token(pop_keyword('for')))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/method_processor.rb

@@ -0,0 +1,58 @@
+module CodeMiner
+
+  module MethodProcessor
+
+    def on_defs(receiver, delimiter, token, params, body)
+      DefsExpression.new(receiver, token, params, body, extract_src_by_token(pop_keyword('def')))
+    end
+
+    def on_def(token, params, body)
+      DefnExpression.new(token.value, params, body, extract_src_by_token(pop_keyword('def')))
+    end
+
+    def on_method_add_block(exp, block)
+      exp.block = block
+      exp.adjust_src(block.src_extract)
+      exp
+    end
+
+    def on_method_add_arg(exp, args)
+      if args
+        exp.args = args
+        exp.adjust_src(extract_src_by_tokens(exp, args))
+      end
+      exp
+    end
+
+    def on_arg_paren(args)
+      args ||= ArgumentsExpression.new
+      args.src = extract_src_by_token(@parens_begin.pop)
+      args
+    end
+
+    def on_brace_block(params, body)
+      BlockExpression.new(body, params, extract_src_by_token(@lbrace.pop))
+    end
+
+    def on_do_block(params, body)
+      BlockExpression.new(body, params, extract_src_by_token(pop_keyword('do')))
+    end
+
+    def on_lambda(args, body)
+      LambdaExpression.new(args, body, extract_src_by_token(@lambda.pop))
+    end
+
+    def on_blockarg(token)
+      token.column -= 1
+      BlockParamExpression.new(token, extract_src_by_tokens(token))
+    end
+
+    def on_tlambda(*)
+      super.tap do |token|
+        @lambda << token
+      end
+    end
+
+  end
+
+end