localtower 0.5.0 → 2.0.0

data/lib/localtower/generators/service_objects/insert_array.rb

@@ -0,0 +1,25 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertArray
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            line_str = Localtower::Tools.line_for_attribute(attribute)[0]
+            if line_str.present?
+              content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, array: true")
+              File.write(Localtower::Tools.last_migration_pending, content)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end

data/lib/localtower/generators/service_objects/insert_defaults.rb

@@ -2,62 +2,104 @@ module Localtower
   module Generators
     module ServiceObjects
       class InsertDefaults
+        DEFAULTS = {
+          '(no default value)' => '',
+          "empty string ('')" => "''",
+          'zero (0)' => '0',
+          'true' => 'true',
+          'false' => 'false',
+          'empty array ([])' => '[]',
+          'empty hash ({})' => '{}',
+          'nil' => 'nil',
+        }
+
+        DEFAULT_VALUES = {
+          'NULL' => { value: '', label: 'NULL', example: 'NULL' },
+          'EMPTY_STRING' => { value: "''", label: 'Empty string', example: "''" },
+          'NOW_DATETIME' => { value: "'now()'", label: 'Current datetime', example: 'now()' },
+          'NOW_DATE' => { value: "'now()'", label: 'Current date', example: 'now()' },
+          'ZERO' => { value: "0", label: 'Zero', example: '0' },
+          'JSON' => { value: "{}", label: 'Empty JSON', example: '{}' }
+        }
+
+        DEFAULTS_BY_TYPE = {
+          string: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['EMPTY_STRING']
+          ],
+          text: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['EMPTY_STRING']
+          ],
+          datetime: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['NOW_DATETIME']
+          ],
+          date: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['NOW_DATE']
+          ],
+          uuid: [
+            DEFAULT_VALUES['NULL']
+          ],
+          integer: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          bigint: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          float: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          numeric: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          decimal: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['ZERO']
+          ],
+          json: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['JSON']
+          ],
+          jsonb: [
+            DEFAULT_VALUES['NULL'],
+            DEFAULT_VALUES['JSON']
+          ],
+          boolean: [
+            DEFAULT_VALUES['NULL'],
+            { value: 'true', label: 'True', example: 'true' },
+            { value: 'false', label: 'False', example: 'false' }
+          ],
+          array: [
+            DEFAULT_VALUES['NULL'],
+            { value: '[]', label: 'Empty array', example: '[]' }
+          ]
+        }
 
         def initialize(attributes)
           @attributes = attributes
         end
 
         def call
-          insert_defaults
-        end
-
-        private
-
-        attr_reader :attributes
-
-        def insert_defaults
           attributes.each do |attribute|
             attribute.each do |attr_key, attr_value|
-              process_migration_file(attr_key, attr_value)
+              line_str = Localtower::Tools.line_for_attribute(attr_key)[0]
+              if line_str.present?
+                content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, default: #{attr_value}")
+                File.write(Localtower::Tools.last_migration_pending, content)
+              end
             end
           end
-          build_file(file_lines)
-        end
-
-        def process_migration_file(attr_key, attr_value)
-          file_lines.map do |line|
-            attach_default_value(line, attr_key, attr_value)
-          end
         end
 
-        def attach_default_value(line, attr_key, attr_value)
-          if table_attribute_line?(line) and line.include? attr_key
-            build_line(line, attr_value)
-          else
-            line
-          end
-        end
-
-        def build_file(lines)
-          File.open(latest_migration, 'w') { |f| f.puts lines }
-        end
-
-        def build_line(line, attr_value)
-          line.gsub!("\n", "") << ", default: " << "#{attr_value}" << "\n"
-        end
-
-        def latest_migration
-          @latest_migration ||= Dir["#{Rails.root}/db/migrate/*"].last
-        end
-
-        def file_lines
-          @file_lines ||= File.readlines(latest_migration)
-        end
-
-        def table_attribute_line?(line)
-          line.squish.start_with? "t."
-        end
+        private
 
+        attr_reader :attributes
       end
     end
   end

data/lib/localtower/generators/service_objects/insert_foreign_keys.rb

@@ -0,0 +1,35 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertForeignKeys
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            attribute.each do |attr_key, options|
+              line_str = Localtower::Tools.line_for_attribute(attr_key)[0]
+              if line_str.present?
+                if options['foreign_key'].present?
+                  if line_str['foreign_key: true']
+                    content = File.read(Localtower::Tools.last_migration_pending)
+                  else
+                    content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, foreign_key: true")
+                  end
+                else
+                  content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, line_str.gsub(', foreign_key: true', ''))
+                end
+                File.write(Localtower::Tools.last_migration_pending, content)
+              end
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end

data/lib/localtower/generators/service_objects/insert_indexes.rb

@@ -0,0 +1,103 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertIndexes
+        USING = [
+          {
+            label: 'default',
+            name: 'default',
+            example: 'using: :btree'
+          },
+          {
+            name: 'hash',
+            example: 'using: :hash'
+          },
+          {
+            name: 'gin',
+            example: 'using: :gin'
+          },
+          {
+            name: 'gist',
+            example: 'using: :gist'
+          },
+          {
+            name: 'spgist',
+            example: 'using: :spgist'
+          },
+          {
+            name: 'brin',
+            example: 'using: :brin'
+          },
+          {
+            name: 'bloom',
+            example: 'using: :bloom'
+          }
+        ]
+
+        UNIQUE = [
+          false,
+          true
+        ]
+
+        ALGO = %w[
+          concurrently
+        ]
+
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            attribute.each do |attr_key, options|
+              line_str_original = File.read(Localtower::Tools.last_migration_pending).match(/((.*)add_index :(.*), :#{attr_key})/)[0]
+              line_str = line_str_original.clone
+
+              line_str = inser_using(line_str, options)
+              line_str = inser_algorithm(line_str, options)
+              line_str = inser_unique(line_str, options)
+
+              content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str_original, line_str)
+              content = add_disable_ddl_transaction(content, options)
+
+              File.write(Localtower::Tools.last_migration_pending, content)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+
+        def inser_using(line_str, options)
+          return line_str if options['using'].blank?
+          return line_str if options['using'] == 'default'
+
+          line_str << ", using: :#{options['using']}"
+        end
+
+        def inser_unique(line_str, options)
+          return line_str if options['unique'].blank?
+
+          line_str << ", unique: true"
+        end
+
+        def inser_algorithm(line_str, options)
+          return line_str if options['algorithm'].blank?
+          return line_str if options['algorithm'] == 'default'
+
+          line_str << ", algorithm: :#{options['algorithm']}"
+        end
+
+        def add_disable_ddl_transaction(content, options)
+          return content if options['algorithm'] != 'concurrently'
+
+          # Add disable_ddl_transaction! if the algorythm is 'concurrently'
+          content = content.gsub(/^class (.*)$/, "class \\1\n  disable_ddl_transaction!\n") if content['disable_ddl_transaction'].blank?
+
+          content
+        end
+      end
+    end
+  end
+end

data/lib/localtower/generators/service_objects/insert_nullable.rb

@@ -0,0 +1,25 @@
+module Localtower
+  module Generators
+    module ServiceObjects
+      class InsertNullable
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def call
+          attributes.each do |attribute|
+            line_str = Localtower::Tools.line_for_attribute(attribute)[0]
+            if line_str.present?
+              content = File.read(Localtower::Tools.last_migration_pending).gsub(line_str, "#{line_str}, null: false")
+              File.write(Localtower::Tools.last_migration_pending, content)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :attributes
+      end
+    end
+  end
+end

data/lib/localtower/status.rb

@@ -8,20 +8,22 @@ module Localtower
         []
       end
 
-      db_migrations = db_migrations.map { |e| e["version"].to_s }.sort.reverse
+      db_migrations = db_migrations.map { |e| e["version"].to_s }
 
       files.map do |file_full_path|
         name = file_full_path.split("/")[-1] # add_email_to_user.rb
         time = name.split("_")[0] # 201203890987
         status = db_migrations.include?(time) ? :done : :todo
         content = File.open(file_full_path).read
+        relative_path = file_full_path.gsub(Rails.root.to_s, '')
 
         {
           "file_full_path" => file_full_path,
           "name" => name,
           "time" => time.to_i,
           "status" => status,
-          "content" => content
+          "content" => content,
+          "relative_path" => relative_path
         }
       end
     end

data/lib/localtower/tools.rb

@@ -33,10 +33,6 @@ module Localtower
         root_klass.subclasses - [ActiveRecord::SchemaMigration]
       end
 
-      def enought_models_for_relation?
-        models.size >= 2
-      end
-
       def models_presented
         self.force_reload!
 
@@ -72,6 +68,7 @@ module Localtower
 
           list << {
             name: model.name,
+            underscore: model.name.underscore,
             table_name: model.table_name,
             attributes_list: attributes_list,
           }
@@ -100,14 +97,14 @@ module Localtower
         list
       end
 
-      def indexes_for_model_and_attribute(model, attribute_name)
+      def indexes_for_model_and_attribute(model, column_name)
         indexes = self.indexes_for_model(model)
 
         list = []
         done = []
 
         indexes.each do |index|
-          conditions = index[:columns].include?(attribute_name.to_s) and not done.include?(index[:name])
+          conditions = index[:columns].include?(column_name.to_s) and not done.include?(index[:name])
           next unless conditions
           infos = {
             unique: index[:unique],
@@ -116,7 +113,7 @@ module Localtower
             max_size: index[:max_size]
           }
 
-          done << attribute_name
+          done << column_name
           list << infos
         end
 
@@ -135,22 +132,18 @@ module Localtower
         end.flatten.uniq.sort
       end
 
-      def perform_migration(str, standalone = false)
-        self.perform_cmd("rails g migration #{str}", false)
-
-        if not standalone
-          self.perform_cmd('rake db:migrate')
-        end
+      def perform_migration(str)
+        self.perform_cmd("rails g migration #{str}")
       end
 
-      def perform_cmd(cmd_str, standalone = true)
-        self.perform_raw_cmd("bundle exec #{cmd_str}", standalone)
+      def perform_cmd(cmd_str)
+        self.perform_raw_cmd("bundle exec #{cmd_str}")
       end
 
-      def perform_raw_cmd(cmd_str, standalone = false, root_dir = false)
-        root_dir ||= ::Rails.root
+      def perform_raw_cmd(cmd_str)
+        root_dir = ::Rails.root
 
-        cmd = standalone ? cmd_str : "cd \"#{root_dir}\" && #{cmd_str}"
+        cmd = "cd \"#{root_dir}\" && #{cmd_str}"
         cmd = cmd.strip
 
         self.log("DOING...: #{cmd}")
@@ -174,17 +167,32 @@ module Localtower
       end
 
       def log_file
-        Rails.root.join('log', 'localtower.log')
+        @log_file ||= Rails.root.join('log', 'localtower.log')
+      end
+
+      def last_migration_pending
+        last_not_run_migration = Localtower::Status.new.run.select {|i| i['status'] == :todo}.sort { |a, b| a['time'] <=> b['time'] }.last
+
+        return nil if last_not_run_migration.blank?
+        return nil unless File.exist?(last_not_run_migration["file_full_path"])
+
+
+        last_not_run_migration["file_full_path"]
+      end
+
+      def pending_migrations
+        Localtower::Status.new.run.select {|i| i['status'] == :todo}
+      end
+
+      def line_for_attribute(attribute)
+        (File.read(last_migration_pending).match(/^\s*t\.(.*)\s*:#{attribute}.*$/) || [])
       end
 
       # PRIVATE ==============
       def create_log
         return nil if File.exist?(self.log_file)
-        File.open(self.log_file, 'w') { |f| f.write('') }
-      end
 
-      def word_in_file?(file, word_or_exp)
-        File.readlines(file).grep(word_or_exp).size > 0
+        File.open(self.log_file, 'w') { |f| f.write('') }
       end
     end
   end

data/lib/localtower/version.rb

@@ -1,3 +1,3 @@
 module Localtower
-  VERSION = '0.5.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/localtower.rb

@@ -5,12 +5,6 @@ end
 require 'thor'
 require 'active_link_to'
 
-begin
-  require "pry"
-rescue Exception => e
-  # Nothing
-end
-
 root = File.expand_path(File.dirname(__FILE__))
 Dir["#{root}/localtower/*.rb"].sort.each { |file| require file }
 Dir["#{root}/localtower/*/**/*.rb"].each { |file| require file }

data/public/fonts/Circular/Read Me.txt

@@ -0,0 +1,5 @@
+Downloaded from 
+
+www.Dfonts.org
+
+Thousands of Premium Fonts For Free

data/public/fonts/Circular/www.dfonts.org.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://www.dfonts.org/