brain_damage 0.1.0

data/lib/generators/brain_damage/lib/ruby_simple_parser/block.rb

@@ -0,0 +1,33 @@
+module RubySimpleParser
+  class Block
+    attr_reader :parent
+    attr_reader :lines
+    attr_reader :name
+
+    def initialize(definition, parent = nil)
+      @parent = parent
+      @lines = []
+
+      if definition
+        @name = "[#{definition.strip[0, 20]}...]"
+        RubySimpleParser::CodeLine.new(definition, self)
+      else
+        @name = :undefined_block
+      end
+
+      parent.add_line self if parent
+    end
+
+    def add_line(line)
+      if line.is_a? String
+        CodeLine.new line, self
+      else
+        @lines << line
+      end
+    end
+
+    def print
+      @lines.map(&:print).join "\n"
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/class_definition.rb

@@ -0,0 +1,19 @@
+module RubySimpleParser
+  class ClassDefinition < Block
+    CLASS_REGEX = /class\s+(?<class_name>\w+)/
+
+    def initialize(definition, visibility, parent = nil)
+      super definition, parent
+      @visibility = visibility
+      @name = ClassDefinition.extract_class_name definition
+    end
+
+    def self.extract_class_name(code)
+      (code.match CLASS_REGEX)[:class_name].to_sym
+    end
+
+    def definition
+      @lines.first.print
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/code_line.rb

@@ -0,0 +1,16 @@
+module RubySimpleParser
+  class CodeLine
+    attr_accessor :line
+    attr_reader :parent
+
+    def initialize(line, parent = nil)
+      @parent = parent
+      @line = line
+      @parent.add_line self if @parent
+    end
+
+    def print
+      @line
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/global_context.rb

@@ -0,0 +1,8 @@
+module RubySimpleParser
+  class GlobalContext < Block
+    def initialize
+      super(nil, nil)
+      @name = 'Global'
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/line_classifier.rb

@@ -0,0 +1,107 @@
+module RubySimpleParser
+  class LineClassifier
+    BLOCK_SPANNING_CONSTRUCTS = ['if', 'unless', 'each', 'while', 'until', 'loop', 'for', 'begin', 'do', 'then']
+
+    def classify(original_code_line, apply_normalize: true)
+      code_line = if apply_normalize then normalize original_code_line else original_code_line end
+
+      if code_line =~ /def (self\.)?\w+/
+        return METHOD_START
+
+      elsif code_line =~ /^\s*class\s*/
+        return CLASS_START
+
+      elsif code_line == ''
+        return EMPTY
+
+      elsif is_false_block_spanning_construct? code_line
+        return CODE_WITHOUT_BLOCK
+
+      elsif code_line == 'private'
+        return PRIVATE_BLOCK
+
+      end
+
+      block_balance = block_balance code_line, apply_normalize: false
+
+      if block_balance > 0
+        CODE_WITH_BLOCK
+      elsif block_balance < 0
+        BLOCK_END
+      else
+        CODE_WITHOUT_BLOCK
+      end
+    end
+
+    def normalize(original_line)
+      line = original_line.strip
+
+      return line if line == ''
+
+      substrings = line.scan(/".*?"|'.*?'/)
+      map = {}
+      count = 0
+
+      substrings.each do |substring|
+        placeholder = "RUBY_SIMPLE_PARSER_STRING_#{count}"
+        count += 1
+        line.gsub!(substring, placeholder)
+        map[placeholder] = substring
+      end
+
+      line.split('#').first.strip
+    end
+
+    def is_false_block_spanning_construct?(code_line)
+      keywords_regex_part = inline_block_spanning_constructs_regex_part
+
+      return false if code_line =~ /.+\s*=\s*#{keywords_regex_part}/ # variable = if condition
+
+      # return if condition then 'a' else 'b' end
+      return true if code_line =~ /\breturn\b\s*#{keywords_regex_part}\s+.+\bthen\b.+\bend\b/
+
+      # return if condition then
+      #   'a' else 'b' end
+      return false if code_line =~ /\breturn\b\s*#{keywords_regex_part}.+\bthen\b.*/
+
+      # return [something] if condition
+      return true if code_line =~ /\breturn\b.*#{keywords_regex_part}/
+
+      return true if code_line =~ /[^\s]+.*#{keywords_regex_part}/ # something if condition
+    end
+
+    def inline_block_spanning_constructs_regex_part
+      '(\b' + ['if', 'unless', 'while', 'until'].join('\b|\b') + '\b)'
+    end
+
+    def block_spanning_constructs_regex
+      Regexp.new '\b' + BLOCK_SPANNING_CONSTRUCTS.join('\b|\b') + '\b'
+    end
+
+    def block_wrappers_regex
+      Regexp.new('\b' +  BLOCK_SPANNING_CONSTRUCTS.join('\b|\b') + '\b|\bend\b|\{|\}|\[|\]')
+    end
+
+    def strip_block_wrappers(original_code_line, apply_normalize: true)
+      code_line = if apply_normalize then normalize original_code_line else original_code_line end
+      code_line.strip.scan block_wrappers_regex
+    end
+
+    def block_balance(original_code_line, apply_normalize: true)
+      code_line = if apply_normalize then normalize original_code_line else original_code_line end
+      balance = 0
+
+      block_wrappers_tokens = strip_block_wrappers code_line, apply_normalize: false
+
+      block_wrappers_tokens.each do |token|
+        if BLOCK_SPANNING_CONSTRUCTS.include? token or token == '{' or token == '['
+          balance += 1
+        elsif ['end', '}', ']'].include? token
+          balance -= 1
+        end
+      end
+
+      balance
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/method.rb

@@ -0,0 +1,23 @@
+module RubySimpleParser
+  class Method < Block
+    METHOD_REGEX = /def\s+(?<method_name>(self\.)?\w+[?!]?)/
+
+    def initialize(definition, visibility, parent = nil)
+      super definition, parent
+      @visibility = visibility
+      @name = Method.extract_method_name definition
+    end
+
+    def private?
+      @visibility == :private
+    end
+
+    def public?
+      @visibility == :public
+    end
+
+    def self.extract_method_name(code)
+      (code.match METHOD_REGEX)[:method_name].to_sym
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/parser.rb

@@ -0,0 +1,114 @@
+require_relative 'ruby_simple_parser'
+require_relative 'block'
+require_relative 'class_definition'
+require_relative 'code_line'
+require_relative 'global_context'
+require_relative 'method'
+require_relative 'line_classifier'
+
+module RubySimpleParser
+  class Parser
+    attr_accessor :class_method_calls
+    attr_reader :class_definition
+
+    def initialize(code = '')
+      @code = code
+      @line_classifier = LineClassifier.new
+      parse if code
+    end
+
+    def public_methods
+      @methods[:public]
+    end
+
+    def private_methods
+      @methods[:private]
+    end
+
+    def parse
+      prepare_to_parse
+
+      @code_lines.each_index do |line_number|
+        line_code = @code_lines[line_number]
+        line_class = @line_classifier.classify line_code
+        new_block = nil
+
+        if line_class == CLASS_START
+          new_block = RubySimpleParser::ClassDefinition.new line_code, @context
+          @context = new_block
+          @class_definition = new_block
+          # puts "Entered context: #{@context.name}"
+
+        elsif line_class == CODE_WITH_BLOCK
+          new_block = RubySimpleParser::Block.new line_code, @context
+          @context = new_block
+
+        elsif line_class == METHOD_START
+          new_block = RubySimpleParser::Method.new line_code, @method_scope, @context
+          @context = new_block
+          @methods[@method_scope][new_block.name] = new_block
+          @last_method = new_block.name
+          # puts "Entered context: #{@context.name}"
+
+        elsif line_class == PRIVATE_BLOCK
+          @method_scope = :private
+          RubySimpleParser::CodeLine.new line_code, @context
+
+        else
+          new_block = RubySimpleParser::CodeLine.new line_code, @context
+
+          if line_class == BLOCK_END
+            if @context.parent
+              # puts "Left context: #{@context.name} (line_class: #{line_class})"
+              @context = @context.parent
+            end
+          end
+        end
+
+        if new_block and (![EMPTY, BLOCK_END].include? line_class) and !new_block.is_a? ClassDefinition and
+          (( line_class == CODE_WITH_BLOCK and @context.parent.is_a? ClassDefinition ) or
+           @context.is_a? ClassDefinition )
+
+          if @last_method
+            @class_method_calls[@last_method] ||= []
+            @class_method_calls[@last_method] << new_block
+          else
+            @class_method_calls[:after_class_definition] << new_block
+          end
+        end
+      end
+    end
+
+    def class_method_calls_after(method)
+      if @class_method_calls.has_key? method
+        @class_method_calls[method]
+      else
+        []
+      end
+    end
+
+    def print
+      @global_context.print
+    end
+
+    private
+    def prepare_to_parse
+      @code_lines = @code.split("\n")
+      @parsed_code = {}
+      @global_context = GlobalContext.new
+      @context = @global_context
+
+      @methods = {
+        public: {},
+        private: {}
+      }
+
+      @last_method = nil
+
+      @class_method_calls = { after_class_definition: [] }
+      @class_definition = nil
+
+      @method_scope = :public
+    end
+  end
+end

data/lib/generators/brain_damage/lib/ruby_simple_parser/ruby_simple_parser.rb

@@ -0,0 +1,11 @@
+module RubySimpleParser
+  CLASS_START = 'ClassDefinition'
+  METHOD_START = 'Method'
+  CODE_WITH_BLOCK = 'Block'
+
+  CODE_WITHOUT_BLOCK = :class_code_without_block
+  EMPTY = :empty
+  OTHER = :other
+  BLOCK_END = :block_end
+  PRIVATE_BLOCK = :private_block
+end

data/lib/generators/brain_damage/lib/templateable/base.rb

@@ -0,0 +1,53 @@
+require 'erb'
+require 'erubis'
+require 'pathname'
+
+require_relative '../ruby_simple_parser/parser'
+
+module BrainDamage
+  module Templateable
+    class Base
+      attr_reader :options
+      attr_reader :inner_html
+      attr_accessor :template_file
+
+      def initialize(resource, options = {})
+        @options = options
+        @resource = resource
+
+        @template_file = options[:template_file] || "#{self.class.to_s.split('::').last.underscore}.html.haml" unless @template_file
+      end
+
+      def render_erb_file(file)
+        raise "Trying to render a file that doesn't exist: #{file}" unless File.file? file
+        render_erb_string(File.open(file).read)
+      end
+
+      def render_erb_string(string)
+        return Erubis::Eruby.new(string).result(binding).strip.gsub(/\n\n\n+/, "\n").gsub(/NEW_LINE_\d+/, "").split("\n").map(&:rstrip).join("\n") if string.is_a? String
+        ''
+      end
+
+      def render_template_file(template_file = @template_file)
+        if Pathname.new(template_file).absolute?
+          render_erb_file template_file
+        else
+          render_erb_file "#{dir}/templates/#{template_file}"
+        end
+      end
+
+      def render(template_file = @template_file)
+        render_template_file template_file
+      end
+
+      def indent(level = nil)
+        level ||= @html_args[:indentation]
+        @inner_html.indent! level if level
+      end
+
+      def method_missing(method, *args, &block)
+        @resource.send method, *args, &block
+      end
+    end
+  end
+end

data/lib/generators/brain_damage/lib/templateable/class_templateable.rb

@@ -0,0 +1,88 @@
+require_relative 'base'
+
+module BrainDamage
+  module Templateable
+    class ClassTemplateable < Templateable::Base
+      attr_reader :current_file_name
+
+      def initialize(resource, options = {})
+        super
+        @public_methods_templates = "#{dir}/templates/public_methods/*"
+        @private_methods_templates = "#{dir}/templates/private_methods/*"
+
+        @removed_methods = []
+      end
+
+      def remove_methods(*methods)
+        @removed_methods += methods
+      end
+
+      def public_methods
+        methods :public
+      end
+
+      def private_methods
+        methods :private
+      end
+
+      def setup(file_name)
+        @current_file_name = file_name
+        @current_code = File.read @current_file_name if File.exists? @current_file_name
+        extract_definitions
+      end
+
+      def generate
+        render
+      end
+
+      def leading_class_method_calls
+        if @parser
+          @parser.class_method_calls[:after_class_definition].map(&:print).uniq.join("\n")
+
+        else
+          ''
+        end
+      end
+
+      def methods(visibility)
+        definitions = {}
+
+        identation = if visibility == :public then 1 else 2 end
+
+        Dir[instance_variable_get("@#{visibility}_methods_templates")].map { |template_file|
+          method_code = render_erb_file(template_file).indent identation
+          method_name = RubySimpleParser::Method.extract_method_name method_code
+          definitions[method_name] = method_code unless @removed_methods.include? method_name
+        }
+
+        if @parser
+          @parser.send("#{visibility}_methods").each do |method_name, method|
+            definitions[method_name] = method.print unless overwrite_method? method_name
+          end
+        end
+
+        definitions.values.join("\n\n")
+      end
+
+      def extract_definitions
+        if @current_code
+          @parser = RubySimpleParser::Parser.new @current_code
+        else
+          @parser = RubySimpleParser::Parser.new
+        end
+      end
+
+      def class_definition
+        @parser.class_definition.definition if @parser
+      end
+
+      def overwrite_method?(method_name)
+        always_overwrite_methods.include? method_name
+      end
+
+      def always_overwrite_methods
+        []
+      end
+    end
+  end
+end