ella 0.1.2

data/lib/ella/controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require_relative 'reloader'
+
+module Ella
+  # Sinatra was not specifically designed to have different modular controller
+  # files. Some of the magic needs to go here, and maintaining a specific
+  # loading order is important: seemingly insignificant changes can break the
+  # little hacks that allow Sinatra to be used as a macro-framework.
+  class Controller < Sinatra::Base
+    set :views, Dir.pwd + '/views' # TODO This can be more dynamic.
+    set :public_folder, Dir.pwd + '/public'
+
+    configure :development do
+      register Sinatra::Reloader
+      also_reload File.join(Dir.pwd, 'models/*')
+      also_reload File.join(Dir.pwd, 'controllers/*')
+      after_reload do
+        puts('Reloading')
+      end
+    end
+
+    # TODO: Some fancy-pants metaprogramming to allow for all user-defined
+    # pipelines.
+    def js_path
+      filename = Dir.glob("public/js/*").max_by {|f| File.mtime(f)}
+      filename.sub('public', '')
+    end
+
+    def css_path
+      filename = Dir.glob("public/css/*").max_by {|f| File.mtime(f)}
+      filename.sub('public', '')
+    end
+  end
+end

data/lib/ella/generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ella
+  # This is an abstract class for the numerous generators that make up the bulk
+  # of this project. It cannot be run on its own.
+  # TODO: The first parameter should be part of the hash, for clarity.
+  class Generator
+    def initialize(directory: nil, files: [], templates: [], template_vars: {})
+      @directory = NameFormatter.new(directory) if directory
+      @files = files
+      @templates = templates
+      @template_vars = template_vars
+    end
+
+    def run
+      raise NotImplementedError, 'Subclasses must define \'run\'.'
+    end
+
+    private
+
+    def generator_type
+      self.class.name.gsub(/^.*::(.*)Generator$/, '\1').downcase + 's'
+    end
+
+    def make_directory(special_name = nil)
+      target = special_name || generator_type
+      return if Dir.exist?(target)
+
+      Log.create(target + '/')
+      Dir.mkdir(target)
+    end
+
+    def make_test_directory
+      make_directory('tests')
+      make_directory("tests/#{generator_type}")
+    end
+
+    def target_name
+      @directory ? @directory.snake_case : @directory
+    end
+  end
+end

data/lib/ella/generator/config_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ella
+  # This class generates Ella project config files, which are needed to nicely
+  # configure Puma and Sinatra.
+  class ConfigGenerator < Generator
+    def run
+      Ella.find_root
+      make_directory('log') # necessary for Puma config
+      make_directory # make config directory
+      Ella::Template.new('configs/puma.rb').write
+      Ella::Template.new('configs/css.rb').write
+      Ella::Template.new('configs/js.rb').write
+    end
+  end
+end

data/lib/ella/generator/controller_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ella
+  # Generator for controllers.
+  class ControllerGenerator < Generator
+    def run
+      # In the case of a controller, 'directory' and 'files' corresponds to the
+      # views being controlled. Every controller file represents a directory,
+      # and every controller route represents a file.
+      Ella.find_root
+      make_directory
+      @template_vars[:name] = @directory
+      @template_vars[:files] = @files
+      generate_controllers
+      generate_tests
+    end
+
+    private
+
+    # The root controller is a special case and does not use the generic template.
+    def generate_controllers
+      path = "controllers/#{@directory.snake_case}.rb"
+      template = (@directory.snake_case == 'root' ? nil : 'controller')
+      Ella::Template.new(path, generic_template: template, template_vars: @template_vars).write
+    end
+
+    def generate_tests
+      make_test_directory
+      path = "tests/controllers/#{@directory.snake_case}_test.rb"
+      @template_vars[:controller] = true
+      Ella::Template.new(path, generic_template: 'test', template_vars: @template_vars).write
+    end
+  end
+end

data/lib/ella/generator/destroyer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ella
+  # This reverses the results of the m/v/c and test generators. Right now it
+  # destroys everything of a certain name if found. While that seems fairly
+  # blunt, there does not currenlty seem to be a reason to make it more
+  # specific.
+  # Although this is the opposite of a generator, the initialization requires
+  # the exact same things, and it makes sense to have the same interface, so it
+  # inherits from Generator.
+  class Destroyer < Generator
+    def run
+      @something_destroyed = false
+
+      attempt_to_destroy('models')
+      attempt_to_destroy('views')
+      attempt_to_destroy('controllers')
+      # TODO: destroy tests, once rspec is set up
+
+      Log.info('Nothing to destroy.') unless @something_destroyed
+    end
+
+    private
+
+    def destroy_dir(path)
+      Log.destroy(path)
+      Dir.delete(path)
+      @something_destroyed = true
+    end
+
+    def destroy_file(path)
+      Log.destroy(path)
+      File.delete(path)
+      @something_destroyed = true
+    end
+
+    def attempt_to_destroy(type)
+      dir_path = File.join(Dir.pwd, "#{type}/#{@directory.snake_case}")
+      file_path = File.join(Dir.pwd, "#{type}/#{@directory.file_name}")
+      destroy_dir(dir_path) if Dir.exist?(dir_path)
+      destroy_file(file_path) if File.exist?(file_path)
+    end
+  end
+end

data/lib/ella/generator/gemfile_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ella
+  # Generates a Gemfile with the necessary dependencies for an ella project, and runs Bundle to
+  # install those dependencies.
+  class GemfileGenerator < Generator
+    def run
+      Ella.find_root
+      Ella::Template.new('Gemfile').write
+      Log.newline
+      Log.info('Running Bundle')
+      # Log.say(`bundle update`)
+    end
+  end
+end

data/lib/ella/generator/model_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ella
+  # Generator for models.
+  class ModelGenerator < Generator
+    def run
+      Ella.find_root
+      make_directory
+      @template_vars[:name] = @directory
+      generate_models
+      generate_tests
+    end
+
+    private
+
+    def generate_models
+      path = "models/#{@directory.snake_case}.rb"
+      Ella::Template.new(path, generic_template: 'model', template_vars: @template_vars).write
+    end
+
+    def generate_tests
+      make_test_directory
+      path = "tests/models/#{@directory.snake_case}_test.rb"
+      Ella::Template.new(path, generic_template: 'test', template_vars: @template_vars).write
+    end
+  end
+end

data/lib/ella/generator/project_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Ella
+  # This beast of a subclass generates a new Ella project from scratch.
+  # --------
+  # Ella requires a main project file for almost everything. Consider this,
+  # anyone who might want to change the order of this method.
+  class ProjectGenerator < Generator
+    def run
+      Log.yell("Generating New Ella Project: \"#{@directory.human}\"")
+
+      prepare_project_directory
+      create_main_project_file
+      initialize_git
+      generate_pipeline_directories
+      initialize_config
+      generate_model_directory
+      generate_views
+      generate_controllers
+      initialize_bundle
+    end
+
+    private
+
+    def prepare_project_directory
+      if Dir.entries('.').include?(@directory.snake_case)
+        Log.error('A directory with that name already exists. Aborting.')
+        abort
+      end
+      Log.newline
+      Log.info('Creating project core')
+      make_directory(@directory.snake_case)
+      Dir.chdir(@directory.snake_case)
+      make_directory('temp')
+    end
+
+    def create_main_project_file
+      Ella::Template.new('main.rb', template_vars: { name: @directory }).write
+      Log.newline
+    end
+
+    def initialize_git
+      Log.info('Initializing git')
+      `git init`
+    end
+
+    def generate_pipeline_directories
+      Log.info('Generating pipeline directories')
+      make_directory('assets')
+      make_directory('assets/css')
+      make_directory('assets/js')
+      make_directory('public')
+      make_directory('public/css')
+      make_directory('public/js')
+      Log.newline
+    end
+
+    def initialize_config
+      Log.info('Generating configuration files')
+      ConfigGenerator.new.run
+      Log.newline
+    end
+
+    def generate_model_directory
+      make_directory('models')
+      Log.newline
+    end
+
+    def generate_views
+      Log.info('Generating views')
+      ViewGenerator.new(templates: ['layout'], template_vars: { name: @directory }).run
+      ViewGenerator.new(directory: 'root', templates: ['index']).run
+      Log.newline
+    end
+
+    def generate_controllers
+      Log.info('Generating root controller')
+      ControllerGenerator.new(directory: 'root').run
+      Log.newline
+    end
+
+    def initialize_bundle
+      Log.info('Creating Gemfile')
+      GemfileGenerator.new.run
+      Log.newline
+    end
+  end
+end

data/lib/ella/generator/rackfile_generator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Ella
+  # The nature of Sinatra and Puma means that the config.ru file must initialize
+  # certain files. To make Ella work, this must be updated before the server is
+  # started.
+  # This is essentially a hack to deal with the fact that Sinatra was designed,
+  # apparently, to run one single controller file.
+  class RackfileGenerator < Generator
+    def run(mode = 'development')
+      @mode = mode
+      Ella.find_root
+      Log.info('Generating rack.ru...')
+      write
+    end
+
+    private
+
+    def main_project_file_content
+      Ella.abort('Warning: "main.rb" not found. Aborting.') unless File.exist?('main.rb')
+      @main_file_content ||= File.open('main.rb').read
+      @main_file_content
+    end
+
+    # This looks bad, but adds a good deal of flexibility for the user, should they ever be
+    # desperate to change the project name of an already-generated project.
+    def project_name
+      raw_project_name = main_project_file_content.scan(/class (.*) < Ella::Controller/).first.first
+      NameFormatter.new(raw_project_name)
+    end
+
+    def get_controllers
+      @controllers = Dir.entries('controllers').select { |e| e =~ /\.rb$/ }.map { |e| e[0..-4] }
+    rescue SystemCallError
+      make_directory('controllers')
+      retry
+    end
+
+    def get_models
+      @models = Dir.entries('models').select { |e| e =~ /\.rb$/ }.map { |e| e[0..-4] }
+    rescue SystemCallError
+      make_directory('models')
+      retry
+    end
+
+    def require_all_models
+      get_models
+      @models && @models.map { |e| "require_relative 'models/#{e}'" }.join("\n")
+    end
+
+    def require_all_controllers
+      get_controllers
+      @controllers && @controllers.map { |e| "require_relative 'controllers/#{e}'" }.join("\n")
+    end
+
+    def use_all_controllers
+      @controllers && @controllers.map { |e| "use #{e.capitalize}Controller" }.join("\n")
+    end
+
+    def write
+      File.open('rack.ru', 'w') { |f| f.puts(generate) }
+    end
+
+    def generate
+      "# WARNING: This file is autmatically generated by Ella, and may be rewritten\n" \
+        "# at any time. Any changes you make here may vanish. The appropriate place for\n" \
+        "# general changes is 'main.rb', which will never be overritten by Ella.)\n" \
+        "require 'ella'\n\n" \
+        "require './main'\n\n" \
+        "#{require_all_models}\n" \
+        "#{require_all_controllers}\n\n" \
+        "#{use_all_controllers}\n\n" \
+        "run #{project_name.pascal_case}\n"
+    end
+  end
+end

data/lib/ella/generator/view_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ella
+  # Generates views for Ella projects.
+  class ViewGenerator < Generator
+    def run
+      Ella.find_root
+      make_directory
+      @path = "views/#{target_name}#{target_name ? '/' : ''}"
+      create_subdirectory if target_name && !Dir.exist?(@path)
+      create_files
+      copy_templates
+    end
+
+    private
+
+    def full_filename(filename)
+      "#{@path}#{filename}.erb"
+    end
+
+    def create_file(filename)
+      Ella::Template.new(full_filename(filename), generic_template: :blank).write
+    end
+
+    def copy_template(filename)
+      Ella::Template.new(full_filename(filename), template_vars: @template_vars).write
+    end
+
+    def copy_templates
+      @templates.each { |filename| copy_template(filename) } if @templates
+    end
+
+    def create_files
+      @files.each { |filename| create_file(filename) } if @files
+    end
+
+    def create_subdirectory
+      Log.create(@path)
+      Dir.mkdir(@path)
+    end
+  end
+end

data/lib/ella/log.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'colorize'
+
+module Ella
+  # A convenient minor reworking of Ruby's logger.
+  class Log
+    # The first three methods do not have timestamps and may be colour coded.
+    # They should not be anything less trivial than a heads up for the user.
+    def self.error(message)
+      say('ERROR: '.red + message.bold)
+    end
+
+    def self.newline
+      say("\n")
+    end
+
+    def self.info(message)
+      say("  ELLA: ".bold.blue + message.split(' ').map(&:capitalize).join(' ').bold)
+    end
+
+    def self.yell(message)
+      say(message.bold.blue)
+    end
+
+    def self.exit_message(message)
+      say(message.bold.yellow)
+    end
+
+    # Misc. It would be best to phase this out in the long run.
+    def self.say(message)
+      puts message
+    end
+
+    def self.unknown(message)
+      log_error.unknown(message)
+    end
+
+    def self.fatal(message)
+      say('FATAL: '.red + message.bold)
+    end
+
+    def self.warn(message)
+      log_info.warn(message)
+    end
+
+    def self.debug(message)
+      log_info.info(message)
+    end
+
+    def self.create(message)
+      output_str = ' ' * 8 +  'CREATE  '.green.bold + message
+      say(output_str)
+    end
+
+    def self.destroy(message)
+      output_str = ' ' * 8 + 'DESTROY  '.red.bold + message
+      say(output_str)
+    end
+
+    def self.log_info
+      Logger.new(STDOUT)
+    end
+
+    def self.log_error
+      Logger.new(STDERR)
+    end
+  end
+end