codeminer 0.1.0

data/lib/codeminer/processors/params_processor.rb

@@ -0,0 +1,97 @@
+module CodeMiner
+
+  module ParamsProcessor
+
+    def on_params(positional, optional, splat, _, keyword, _, block)
+      ParamsExpression.new(positional_params(positional), optional_params(optional), keyword_params(keyword), splat_param(splat), block).tap do |params|
+        params.src = extract_src_by_tokens(params) if params.line
+      end
+    end
+
+    def on_rest_param(token)
+      if token
+        token.column -= 1
+        src = extract_src(token.line, token.column, token.end_line, token.end_column)
+      else
+        src = extract_src(lineno(), column() - 1, lineno(), column())
+      end
+      SplatExpression.new(token, src)
+    end
+
+    def on_paren(params)
+      params.src = extract_src(params.line, params.column - 1, params.end_line, params.end_column + 1) if params && params.src_extract
+      params
+    end
+
+    def on_block_var(params, _)
+      params
+    end
+
+    def on_mlhs_new
+      ExpressionContainer.new([], :mlhs)
+    end
+
+    def on_mrhs_new
+      ExpressionContainer.new([], :values)
+    end
+
+    def on_mlhs_add(params, param)
+      params.add(param)
+    end
+
+    def on_mlhs_paren(exp)
+      if exp.kind_of?(Token)
+        DestructuredParamExpression.new(exp, exp.src_extract)
+      else
+        exp.src = extract_src_by_token(@parens_begin.pop)
+        exp
+      end
+    end
+
+    def on_mrhs_new_from_args(args)
+      ExpressionContainer.new(args.each, :values, args.src_extract)
+    end
+
+    def on_mrhs_add(params, exp)
+      params.add(exp)
+    end
+
+    def on_mrhs_add_star(params, exp)
+      params.add(SplatExpression.new(exp, extract_src(exp.line, exp.column - 1, exp.end_line, exp.end_column)))
+    end
+
+    alias :on_mlhs_add_star :on_mrhs_add_star
+
+    private
+
+    def positional_params(positional)
+      positional_expressions = positional.to_a.map do |exp|
+        PositionalParamExpression.convert(exp, extract_src_by_token(exp, exp.end_line, exp.end_column))
+      end
+      src = extract_src_by_token(positional.first, positional.last.end_line, positional.last.end_column) if positional
+      ExpressionContainer.new(positional_expressions, :positional, src)
+    end
+
+    def optional_params(optional)
+      optional_expressions = optional.to_a.map do |token, value|
+        OptionalParamExpression.new(token, value, extract_src_by_token(token, value.end_line, value.end_column))
+      end
+      src = extract_src_by_token(optional.first.first, optional.last.last.end_line, optional.last.last.end_column) if optional
+      ExpressionContainer.new(optional_expressions, :optional, src)
+    end
+
+    def keyword_params(keyword)
+      keyword_expressions = keyword.to_a.map do |token, value|
+        KeywordParamExpression.new(token, value || nil, extract_src_by_tokens(token, value || token))
+      end
+      src = extract_src_by_tokens(keyword_expressions.first, keyword_expressions.last) unless keyword_expressions.empty?
+      ExpressionContainer.new(keyword_expressions, :keyword, src)
+    end
+
+    def splat_param(splat)
+      splat unless splat == 0
+    end
+
+  end
+
+end

data/lib/codeminer/processors/range_processor.rb

@@ -0,0 +1,15 @@
+module CodeMiner
+
+  module RangeProcessor
+
+    def on_dot2(left, right)
+      RangeExpression.new(left, right, true, extract_src_by_tokens(left, right))
+    end
+
+    def on_dot3(left, right)
+      RangeExpression.new(left, right, false, extract_src_by_tokens(left, right))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/regexp_processor.rb

@@ -0,0 +1,27 @@
+module CodeMiner
+
+  module RegexpProcessor
+
+    def on_regexp_literal(regexp, regex_end)
+      regexp.tap do |r|
+        r.src = extract_src_by_token(@begin_regex.pop, regex_end.line, regex_end.end_column)
+      end
+    end
+
+    def on_regexp_beg(value)
+      super.tap do |token|
+        @begin_regex << token
+      end
+    end
+
+    def on_regexp_add(regexp_content, regex)
+      regexp_content.add(regex)
+    end
+
+    def on_regexp_new
+      RegexpExpression.new
+    end
+
+  end
+
+end

data/lib/codeminer/processors/return_processor.rb

@@ -0,0 +1,15 @@
+module CodeMiner
+
+  module ReturnProcessor
+
+    def on_return(body)
+      ReturnExpression.new(body, extract_src_by_token(pop_keyword('return')))
+    end
+
+    def on_return0
+      ReturnExpression.new(nil, extract_src_by_token(pop_keyword('return')))
+    end
+
+  end
+
+end

data/lib/codeminer/processors/string_processor.rb

@@ -0,0 +1,79 @@
+module CodeMiner
+
+  module StringProcessor
+
+    def on_tstring_content(value)
+      Token.new(:string, value, extract_src_by_value(value))
+    end
+
+    def on_string_add(string_content, string)
+      string_content.add(string, extract_src_by_tokens(string))
+    end
+
+    def on_string_content
+      StringContentExpression.new
+    end
+
+    def on_string_concat(str1, str2)
+      dynamic_string = DynamicStringExpression.wrap(str1)
+      dynamic_string.add(str2)
+    end
+
+    def on_xstring_literal(token)
+      token.column -= 1
+      token.end_column += 1
+      XStringExpression.new(token, extract_src_by_tokens(token))
+    end
+
+    def on_string_embexpr(body)
+      body.each.last.delimiter = '}'
+      embedded_expression_src = extract_src_by_token(@embexpr.pop)
+      StringEmbeddedExpression.new(body, embedded_expression_src)
+    end
+
+    def on_string_literal(string_content)
+      string_content.src = extract_src_by_tokens(@string_begin.pop, @string_end.pop)
+      string_content
+    end
+
+    def on_xstring_new
+      StringContentExpression.new
+    end
+
+    def on_xstring_add(body, string)
+      body.add(string, extract_src_by_tokens(string))
+    end
+
+    def on_tstring_beg(*)
+      super.tap do |token|
+        @string_begin << token
+      end
+    end
+
+    def on_tstring_end(*)
+      super.tap do |token|
+        @string_end << token
+      end
+    end
+
+    def on_embexpr_beg(*)
+      super.tap do |token|
+        @embexpr << token
+      end
+    end
+
+    def on_heredoc_beg(*)
+      super.tap do |token|
+        @string_begin << token
+      end
+    end
+
+    def on_heredoc_end(*)
+      super.tap do |token|
+        @string_end << token
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/symbol_processor.rb

@@ -0,0 +1,31 @@
+module CodeMiner
+
+  module SymbolProcessor
+
+    def on_symbol_literal(symbol)
+      SymbolExpression.convert(symbol)
+    end
+
+    def on_symbol(token)
+      SymbolExpression.new(token, extract_src_by_token(@symbol_begin.pop))
+    end
+
+    def on_dyna_symbol(*body)
+      body.first.src = extract_src_by_tokens(@string_begin.pop, @string_end.pop)
+      DynamicSymbolExpression.new(*body, extract_src_by_tokens(@symbol_begin.pop, body.last))
+    end
+
+    def on_symbeg(value)
+      super.tap do |token|
+        if value.end_with?('"', "'")
+          @symbol_begin << Token.new(:symbeg, value.chomp('"').chomp("'"), extract_src_by_token(token, token.end_line, token.end_column - 1))
+          @string_begin << Token.new(:tstring_beg, value.slice(1..-1), extract_src(token.line, token.column + 1, token.end_line, token.end_column - 1))
+        else
+          @symbol_begin << token
+        end
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/token_processor.rb

@@ -0,0 +1,41 @@
+module CodeMiner
+
+  module TokenProcessor
+
+    def self.tokens(*attrs)
+      attrs.each do |attr|
+        define_method :"on_#{attr}" do |token|
+          token
+        end
+      end
+    end
+
+    tokens :const_ref
+
+    def on_lbrace(token)
+      @lbrace << super
+      token
+    end
+
+    def on_kw(kw)
+      super.tap do |token|
+        if %w(do class def if else unless return alias yield break next super begin rescue case when redo retry undef elsif
+              until while for module defined? ensure).include?(kw.gsub(/[^a-z?]/, ''))
+          @keywords.unshift(token)
+        end
+      end
+    end
+
+    def on_lbracket(value)
+      @lbracket = super
+    end
+
+    def on_lparen(*)
+      super.tap do |token|
+        @parens_begin << token
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/processors/variable_processor.rb

@@ -0,0 +1,70 @@
+module CodeMiner
+
+  module VariableProcessor
+
+    def on_var_ref(exp)
+      if exp.kind_of?(Token)
+        cast_variable_to_type(exp)
+      else
+        exp
+      end
+    end
+
+    alias on_var_field on_var_ref
+
+    def on_gvar(value)
+      GlobalVariableExpression.new(value, extract_src_by_value(value))
+    end
+
+    def on_ivar(value)
+      InstanceVariableExpression.new(value, extract_src_by_value(value))
+    end
+
+    def on_cvar(value)
+      ClassVariableExpression.new(value, extract_src_by_value(value))
+    end
+
+    def on_backref(value)
+      BackrefVariableExpression.new(value.slice(1..-1), extract_src_by_value(value))
+    end
+
+    def on_field(receiver, delimiter, token)
+      FieldExpression.new(receiver, token, extract_src_by_tokens(receiver, token))
+    end
+
+    def on_const_path_ref(const, token)
+      Colon2Expression.new(token, const, extract_src_by_tokens(const, token))
+    end
+
+    alias on_const_path_field on_const_path_ref
+
+    def on_top_const_ref(token)
+      Colon3Expression.new(token, extract_src(token.line, token.column - 2, token.end_line, token.end_column))
+    end
+
+    alias on_top_const_field on_top_const_ref
+
+    private
+
+    def cast_variable_to_type(exp)
+      if exp.type == :const
+        ConstantVariableExpression.new(exp, exp.src_extract)
+      else
+        case exp.value
+          when 'nil'
+            NilExpression.new(exp, extract_src_by_tokens(exp))
+          when 'self'
+            SelfExpression.new(exp, extract_src_by_tokens(exp))
+          when 'false'
+            FalseExpression.new(exp, extract_src_by_tokens(exp))
+          when 'true'
+            TrueExpression.new(exp, extract_src_by_tokens(exp))
+          else
+            LocalVariableExpression.new(exp, exp.src_extract)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/codeminer/source_extract.rb

@@ -0,0 +1,120 @@
+module CodeMiner
+
+  class SourceExtract
+
+    attr_accessor :line, :column
+    attr_accessor :end_line, :end_column
+
+    class Partial
+
+      attr_reader :end_line, :end_column, :line, :column
+
+      def initialize(src, end_line, end_column)
+        @src = src
+        @end_line = end_line
+        @end_column = end_column
+        @line = end_line
+        @column = end_column
+      end
+
+      def adjust(other)
+        SourceExtract.new(@src, other.line, other.column, end_line, end_column)
+      end
+
+      def extract
+        ''
+      end
+
+    end
+
+    module Usage
+
+      def line
+        src_extract.line
+      end
+
+      def column
+        src_extract.column
+      end
+
+      def end_line
+        src_extract.end_line
+      end
+
+      def end_column
+        src_extract.end_column
+      end
+
+      def line=(line)
+        src_extract.line = line
+      end
+
+      def column=(column)
+        src_extract.column = column
+      end
+
+      def end_line=(line)
+        src_extract.end_line = line
+      end
+
+      def end_column=(column)
+        src_extract.end_column = column
+      end
+
+      def src
+        extracted_source = src_extract.extract
+        if delimiter
+          extracted_source.chomp(delimiter.to_s)
+        else
+          extracted_source
+        end
+      end
+
+      def adjust_src(other)
+        if @src
+          @src = @src.adjust(other)
+        else
+          @src = other
+        end
+      end
+
+      def src_extract
+        @src || @src_fallback
+      end
+
+    end
+
+    def self.extract_by_token(src, token, end_line, end_column)
+      new(src, token.line, token.column, end_line, end_column)
+    end
+
+    def self.extract_by_tokens(src, token, end_token)
+      new(src, token.line, token.column, end_token.end_line, end_token.end_column)
+    end
+
+    def initialize(src, line, column, end_line=nil, end_column=nil)
+      @src = src
+      @line = line
+      @column = column
+      @end_line = end_line
+      @end_column = end_column
+    end
+
+    def extract
+      lines = extract_lines(line-1..end_line-1).join
+      lines.slice(column, lines.length - (lines.lines.last.length - end_column) - column).to_s.chomp
+    end
+
+    def adjust(other)
+      self.class.new(@src, line, column, other.end_line, other.end_column)
+    end
+
+    private
+
+    def extract_lines(range)
+      @src.lines.slice(range)
+    end
+
+  end
+
+end