brain_damage 0.1.0

data/lib/generators/brain_damage/lib/field_white_list.rb

@@ -0,0 +1,21 @@
+module BrainDamage
+  class FieldWhiteList
+    def initialize(field, white_list)
+      @field = field
+      @white_list = white_list
+    end
+
+    def list
+      if @white_list
+        return ":#{@white_list.keys.first} => #{@white_list.values.first.inspect}" if @white_list.is_a? Hash
+        return @white_list.map{ |item| ":#{item}" }.join ', ' if @white_list.is_a? Array
+        return nil if @white_list == ''
+        return ":#{@white_list.to_s}"
+      end
+
+      return @field.relation.white_list if @field.relation
+
+      return ":#{@field.name}"
+    end
+  end
+end

data/lib/generators/brain_damage/lib/includes.rb

@@ -0,0 +1,12 @@
+require_relative 'relation/base'
+require_relative 'relation/belongs_to'
+require_relative 'relation/has_and_belongs_to_many'
+require_relative 'relation/has_many'
+require_relative 'relation/has_one'
+
+require_relative 'parametizer'
+require_relative 'migration'
+require_relative 'field'
+require_relative 'controller/controller_generator'
+require_relative 'model/model_generator'
+require_relative 'views/views_generator'

data/lib/generators/brain_damage/lib/migration.rb

@@ -0,0 +1,76 @@
+module BrainDamage
+  class Migration
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def migration_file_exists?
+      file_name = migration_file_full_path
+      file_name && File.exists?(file_name)
+    end
+
+    def migration_file_full_path
+      Dir["db/migrate/*"].select { |file_name|
+        file_name.split('/').last =~ /\d+_create_#{@resource.name.underscore.pluralize}.rb/
+      }.first
+    end
+
+    alias_method :skip?, :migration_file_exists?
+
+    def improve_code(migration_code)
+      @migration_lines = migration_code.split "\n"
+
+      return migration_code if @migration_lines.length == 2
+
+      add_options_to_lines
+      remake_migration
+    end
+
+    def is_column_line? line
+      line =~ /t\..*:\w+/
+    end
+
+    def add_options_to_lines
+      @migration_lines.map! { |line|
+        if is_column_line? line
+          related_column = line.scan(/:(\w+)/).first.first.to_sym
+          column_options = @resource.columns[related_column] || {}
+
+          add_options line, related_column, column_options
+        else
+          line
+        end
+      }
+    end
+
+    def add_options(line, related_field, field_options)
+      options = belongs_to_options line, related_field, field_options
+
+      field_options.slice(:default, :precision, :scale).each do |key, value|
+        options << "#{key}: #{value.inspect}"
+      end
+
+      options_string = options.join ', '
+
+      if options.length > 0 and !line.include? options_string
+        return "#{line}, #{options_string}"
+      end
+
+      line
+    end
+
+    def belongs_to_options(line, related_field, field_options)
+      return [] unless is_belongs_to_line? line
+      return ["references: :#{field_options[:class_name].underscore.pluralize}"] if field_options[:class_name]
+      []
+    end
+
+    def is_belongs_to_line? line
+      line.include? 't.belongs_to'
+    end
+
+    def remake_migration
+      @migration_lines.join "\n"
+    end
+  end
+end

data/lib/generators/brain_damage/lib/model/model_generator.rb

@@ -0,0 +1,115 @@
+require_relative '../templateable/class_templateable'
+
+module BrainDamage
+  class ModelGenerator < Templateable::ClassTemplateable
+    def initialize(resource, options = {})
+      @template_file = 'model.rb'
+      super
+    end
+
+    def generate
+      improve_belongs_to_lines
+      add_lines_from_fields
+      prettify_lines
+      super
+    end
+
+    def prettify_lines
+      return if @parser.class_method_calls[:after_class_definition].empty?
+
+      infos = @parser.class_method_calls[:after_class_definition].map { |line|
+        code = line.print.strip
+
+        order = if code.starts_with? 'include'
+                  0
+                elsif code.strip[0, 3].upcase == code.strip[0, 3]
+                  unless ['[', '{'].include? code.split("\n").first[-1]
+                    1
+                  else
+                    2
+                  end
+                elsif code.starts_with? 'default_scope'
+                  3
+                elsif code.starts_with? 'scope :'
+                  4
+                elsif code.starts_with? 'validates '
+                  5
+                elsif code =~ /^(has_many)|(has_and_bel)|(belongs_to)/
+                  6
+                elsif code.starts_with? 'accepts_nested_attributes_for'
+                  7
+                elsif code.starts_with? 'validates_associated'
+                  8
+                else
+                  9
+                end
+
+        { code: code, line: line, order: order }
+
+      }.sort { |info_a, info_b|
+        order = info_a[:order] <=> info_b[:order]
+        if order != 0 then order else info_a[:code] <=> info_b[:code] end
+      }
+
+      @parser.class_method_calls[:after_class_definition] = []
+      current_info = infos.first
+      new_line_number = 0
+
+      infos.each do |info|
+        if info[:order] != current_info[:order]
+          @parser.class_method_calls[:after_class_definition] << RubySimpleParser::CodeLine.new("NEW_LINE_#{new_line_number}")
+          new_line_number += 1
+          current_info = info
+        end
+
+        @parser.class_method_calls[:after_class_definition] << info[:line]
+      end
+    end
+
+    def attribute_white_list
+      @resource.fields.values.map(&:attr_white_list).reject(&:nil?).join ', '
+    end
+
+    def improve_belongs_to_lines
+      return unless @parser and @parser.class_method_calls[:after_class_definition]
+
+      belongs_to_lines = @parser.class_method_calls[:after_class_definition].each_with_index.map { |line, index|
+        [index, line.print]
+      }.select{ |pair|
+        pair.second =~ /belongs_to :(\w+)\s*$/
+      }.map { |pair|
+        [pair.first, add_options_to_belongs_to_line(pair.second) ]
+      }.each { |pair|
+        @parser.class_method_calls[:after_class_definition][pair.first].line = pair.second
+      }
+    end
+
+    def add_lines_from_fields
+      @parser.class_method_calls[:after_class_definition] += @resource.fields.values.map(&:model_lines).flatten.reject(&:nil?).reject(&:empty?).map { |line|
+        RubySimpleParser::CodeLine.new line
+
+      }
+    end
+
+    def add_options_to_belongs_to_line(line)
+      related_field = line.scan(/:(\w+)/).first.first.to_sym
+      options = @resource.columns[related_field].dup
+      options.delete :type
+
+      options = options.map { |key, value|
+        "#{key}: '#{value}'"
+      }
+
+      if options.any?
+        "#{line}, #{options.join(', ')}"
+      else
+        line
+      end
+    end
+
+    private
+    def dir
+      __dir__
+    end
+  end
+end

data/lib/generators/brain_damage/lib/model/templates/model.rb

@@ -0,0 +1,12 @@
+<%= class_definition %>
+<%= leading_class_method_calls -%>
+
+<%= public_methods -%>
+<% private_methods_code = private_methods %>
+
+<% if private_methods_code.present? %>
+  private
+<%= private_methods %>
+<% end %>
+
+end

data/lib/generators/brain_damage/lib/parametizer.rb

@@ -0,0 +1,19 @@
+module BrainDamage
+  class Parametizer
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def as_cmd_parameters
+      [@resource.name] + columns_as_parameters
+    end
+
+    def columns_as_parameters
+      @resource.columns.map { |column_name, options| column_as_parameter column_name, options }
+    end
+
+    def column_as_parameter(column_name, options)
+      "#{column_name.to_s}:#{options[:type].to_s}"
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module BrainDamage
+  class Relation
+    VALID_RELATION_TYPES = [ :belongs_to, :has_and_belongs_to_many, :has_many, :has_one ]
+
+    def initialize
+      raise "class Relation is an abstract class and can't be instantiated"
+    end
+
+    def resource_name_according_to_foreign
+      @options[:as] or @options[:inverse_of] or singular_table_name
+    end
+
+    def nested_on
+      resource_name_according_to_foreign
+    end
+
+    def class_name
+      return @options[:class_name] if @options[:class_name]
+      @options[:field].name.to_s.singularize.camelize
+    end
+
+    def model_lines
+      []
+    end
+
+    def add_options_to_line(line, options)
+      return line unless options
+      ([line] + options.map { |name, value|
+        if value.is_a? Symbol
+          "#{name}: :#{value}"
+        else
+          "#{name}: '#{value}'"
+        end
+      }).join ', '
+    end
+
+    def self.is_valid_relation? type
+      VALID_RELATION_TYPES.include? type
+    end
+
+    def self.create(type, options)
+      return nil unless Relation.is_valid_relation? type
+      "BrainDamage::#{type.to_s.camelize}".constantize.new options
+    end
+
+    def white_list
+      nil
+    end
+  end
+end

data/lib/generators/brain_damage/lib/relation/belongs_to.rb

@@ -0,0 +1,29 @@
+require_relative 'base'
+
+module BrainDamage
+  class BelongsTo < Relation
+    def initialize(options = {})
+      @options = options
+    end
+
+    def white_list
+      if @options[:white_list]
+        if @options[:white_list] == ''
+          return nil
+        elsif @options[:white_list].is_a? Array
+          return @options[:white_list].map { |field| ":#{field}" }.join ', '
+        else
+          return @options[:white_list].inspect
+        end
+      else
+        field_name = @options[:field].name.to_s
+
+        unless @options[:polymorphic]
+          return ":#{field_name}_id"
+        else
+          return ":#{field_name}_id, :#{field_name}_type"
+        end
+      end
+    end
+  end
+end

data/lib/generators/brain_damage/lib/relation/has_and_belongs_to_many.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+
+module BrainDamage
+  class HasAndBelongsToMany < Relation
+    def initialize(options = {})
+      @options = options
+    end
+
+    def model_lines
+      [relationship_line]
+    end
+
+    def relationship_line
+      line = "has_and_belongs_to_many :#{@options[:field].name}".indent
+      add_options_to_line line, @options.slice(:class_name, :join_table)
+    end
+
+    def white_list
+      return ":#{@options[:field].name.to_s.singularize}_ids => []"
+    end
+  end
+end

data/lib/generators/brain_damage/lib/relation/has_many.rb

@@ -0,0 +1,35 @@
+require_relative 'base'
+
+module BrainDamage
+  class HasMany < Relation
+    def initialize(options = {})
+      @options = options
+      @name = @options[:field].name
+    end
+
+    def model_lines
+      [relationship_line, nested_attributes_line, validates_associated_line ]
+    end
+
+    def relationship_line
+      line = "has_many :#{@name}".indent
+      add_options_to_line line, @options.slice(:class_name, :join_table, :as, :dependent, :foreign_key, :through)
+    end
+
+    def nested_attributes_line
+      "accepts_nested_attributes_for :#{@name}, reject_if: proc { |attributes| attributes.values.uniq.first == '' }".indent unless @options[:skip_nested_form]
+    end
+
+    def validates_associated_line
+      "validates_associated :#{@name}".indent unless @options[:skip_nested_form]
+    end
+
+    def white_list
+      if @options[:white_list]
+        return ":#{@name.to_s.pluralize}_attributes => #{@options[:white_list].inspect}"
+      else
+        return ":#{@name.to_s.singularize}_ids => []"
+      end
+    end
+  end
+end

data/lib/generators/brain_damage/lib/relation/has_one.rb

@@ -0,0 +1,18 @@
+require_relative 'base'
+
+module BrainDamage
+  class HasOne < Relation
+    def initialize(options = {})
+      @options = options
+    end
+
+    def model_lines
+      [relationship_line]
+    end
+
+    def relationship_line
+      line = "has_one :#{@options[:field].name}".indent
+      add_options_to_line line, @options.slice(:class_name, :join_table, :dependent)
+    end
+  end
+end

data/lib/generators/brain_damage/lib/resource.rb

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+require_relative 'includes'
+
+module BrainDamage
+  class Resource
+    attr_accessor :name
+
+    attr_reader :root
+    attr_reader :columns
+    attr_reader :controller
+    attr_reader :fields
+    attr_reader :model
+    attr_reader :views
+    attr_reader :migration
+    attr_reader :parametizer
+
+    def initialize(initializers, options = {})
+      @columns = {}
+      @fields = {}
+      @root = options[:root]
+
+      @parametizer = BrainDamage::Parametizer.new self
+      @migration = BrainDamage::Migration.new self
+      @controller = BrainDamage::ControllerGenerator.new self
+      @model = BrainDamage::ModelGenerator.new self
+      @views = BrainDamage::ViewsGenerator.new self
+      @closed_for_field_description = false
+
+      initializers.each do |initializer|
+        instance_eval initializer.read, initializer.path if initializer.is_a? File
+      end
+
+      ensure_every_column_is_described
+    end
+
+    def setup(generator)
+      @generator = generator
+      ensure_every_column_has_its_generated_attribute_object
+    end
+
+    def column_relation_type(column_name)
+      return @columns[column_name][:type] if @columns[column_name] and Relation.is_valid_relation? @columns[column_name][:type]
+      nil
+    end
+
+    def columns=(column_hash)
+      column_hash.each do |name, options|
+        if options.is_a? Symbol
+          @columns[name] = { type: options }
+        else
+          @columns[name] = options
+        end
+      end
+    end
+
+    def describe(name)
+      self.name = name
+      yield self if block_given?
+    end
+
+    def describe_field(name)
+      if @closed_for_field_description
+        puts "ERROR: Trying to describe field #{name} after field description has been closed.
+      Are you trying to describe a field after describing the views?"
+        return
+      end
+
+      @fields[name] = Field.new(name: name, resource: self) unless @fields[name]
+      yield @fields[name] if block_given?
+
+      unless @fields[name].relation
+        @fields[name].relation = {}
+      end
+    end
+
+    def describe_controller
+      yield @controller if block_given?
+    end
+
+    def describe_model
+      yield @model if block_given?
+    end
+
+    def describe_views
+      ensure_every_column_is_described
+      yield @views if block_given?
+    end
+
+    def inputable_fields(identifier = :default)
+      sort_fields(fields.values.select{ |field|
+                    field.inputable? identifier
+                  })
+    end
+
+    def uninputable_fields
+      fields.values.reject(&:inputable?)
+    end
+
+    def undisplayable_fields
+      fields.values.reject(&:displayable?)
+    end
+
+    def displayable_fields(identifier = :default)
+      sort_fields(fields.values.select{ |field|
+                    field.displayable? identifier
+                  })
+    end
+
+    def sort_fields(fields)
+      names = @columns.keys
+      fields.sort { |field_a, field_b|
+        (names.index(field_a.name) || 999) <=>
+          (names.index(field_b.name) || 999)
+      }
+    end
+
+    def displayable_and_inputable_fields(identifier = :default)
+      inputable_fields(identifier) & displayable_fields(identifier)
+    end
+
+    def ensure_every_column_is_described
+      (@columns.keys - @fields.keys).each do |column_name|
+        describe_field column_name do |field|
+          field.display = :default
+          field.input = :default
+        end
+      end
+
+      uninputable_fields.each do |field|
+        field.input = :default unless field.input(:default) == false
+      end
+
+      undisplayable_fields.each do |field|
+        field.display = :default unless field.display(:default) == false
+      end
+
+      @closed_for_field_description = true
+    end
+
+    def ensure_every_column_has_its_generated_attribute_object
+      attributes.each do |attribute|
+        @fields[attribute.name.to_sym].generated_attribute = attribute
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @generator.send method, *args, &block
+    end
+  end
+end