ptero 1.0.0

data/lib/ptero/cli.rb

@@ -0,0 +1,35 @@
+# 
+# 
+# cli.rb
+# ======
+# 
+# Superclass and container for all Thor command-line tools in Ptero
+# 
+
+require 'thor'
+
+module Ptero
+  # The superclass of all Ptero command-line interfaces
+  class CLI < Thor
+    
+    
+    
+    
+    
+    
+    # eigenclass for autoloading
+    class << self
+      
+      # autoload and return any cli that is missing
+      # @param const_name [Symbol] the name of the constant to be found
+      def const_missing(const_name)
+        # Load the cli
+        require "#{__dir__}/cli/#{const_name.downcase}.rb"
+        return const_get const_name
+      rescue LoadError
+        super
+      end
+      
+    end
+  end
+end

data/lib/ptero/cli/root.rb

@@ -0,0 +1,282 @@
+# 
+# 
+# root.rb
+# =======
+# The root CLI that is run with arguments passed to the ptero tool
+# 
+# 
+
+require 'colorize'
+
+# The principal Ptero CLI, the one that is called with the 'ptero' command
+class Ptero::CLI::Root < Ptero::CLI
+  desc 'new NAME', 'Create a new application called NAME'
+  long_desc <<-LONGDESC
+    `$ ptero new NAME` will create a new directory called NAME in the current working directory and
+    set up a new Dinosaur PHP project inside the directory. The ptero tool:
+    
+    \n\n* Creates a new directory, called NAME, in the current pwd
+    \n\n* Initializes a basic composer.json file in the root of the new project that includes all Dinosaur dependencies, as well as project metadata for future use
+    \n\n* After checking for the presence of PHP, installs the composer.phar executable and uses it to install all Dinosaur dependencies
+    \n\n* Generates basic templates for models, views, and controllers for the beginning of the project
+    
+    \n\nAfter this command is executed, you can use further `$ ptero generate` commands to create your project content once in the root of your project
+  LONGDESC
+  # Seed a new Application, then download composer.phar and all dependencies
+  # @param name [String] the name of the new application
+  def new(name)
+    seed(name)
+    Dir.chdir name do
+      composer()
+      install()
+    end
+    puts "Change your working directory to '#{Dir.pwd}/#{name}' and starting generating files with 'ptero generate' to start your application"
+  end
+  
+  desc 'seed NAME', 'Seed a new application'
+  long_desc <<-LONGDESC
+    `$ ptero seed NAME` generates the necessary files for a new application in a new directory called NAME. It generates all default models, views, and controllers
+     without accessing the internet. This means that it does not download composer and does not install composer dependencies, but performs all other application setup.
+     The execution of new consists of calling seed NAME, then changing to the new project's directory and calling composer, then install.
+  LONGDESC
+  # Seed a new Application by generating a new application directory and generating all necessary files, without accessing the internet or getting dependencies
+  # @param name [String] the name of the new application
+  def seed(name)
+    Ptero::Application.create(name) do |app|
+      
+      # PHP
+      Dir.mkdir 'php'
+      app.generate('PHP_Info')
+      app.generate_setup(app.name.downcase)
+      app.generate_routes
+      
+      Dir.mkdir 'php/controllers'
+      app.generate_controller('Application','\Dinosaur\\')
+      app.generate_load_all('php/controllers','ApplicationController')
+      
+      Dir.mkdir 'php/models'
+      app.generate_load_all('php/models')
+      
+      # Configuration
+      Dir.mkdir 'config'
+      app.generate_config
+      
+      # Templates
+      Dir.mkdir 'views'
+      app.generate_layout
+      app.generate_page_not_found
+      
+      # Document Root
+      Dir.mkdir 'www'
+      app.generate('HTAccess')
+      app.generate_landing
+
+      # CSS, Javascripts, Images
+      Dir.mkdir 'www/assets'
+      
+      # CSS
+      Dir.mkdir 'www/assets/css'
+      app.generate_application_stylesheet('application','This is the main CSS stylesheet for application-wide styles. It is included in all pages by default.')
+      
+      # JS
+      Dir.mkdir 'www/assets/js'
+      app.generate_application_javascript('application','This is the main file that is loaded along with every page. Put application-wide behavior here.')
+      
+      # Images
+      Dir.mkdir 'www/assets/images'
+      
+    end
+  end
+  
+  desc 'route PATH, CONTROLLER', 'add a new route'
+  long_desc <<-LONGDESC
+    'ptero route PATH, CONTROLLER' saves all current routes to a new RoutesGenerator object, adds the new route specified by PATH => CONTROLLER to this generator,
+    then removes and regenerates the routes.php file with the new route in place.
+  LONGDESC
+  # Add a new route to the Application routes file
+  # @param path [String] the path to route
+  # @param controller [String] the name of the controller to route
+  def route(path,controller)
+    verify do
+      app.route(path,controller)
+    end
+  end
+  
+  desc 'unroute PATH', 'remove the PATH route in the routes.php file'
+  long_desc <<-LONGDESC
+    'ptero unroute PATH' performs the inverse of the 'ptero route PATH, CONTROLLER' command. It captures all existing routes in a RoutesGenerator object,
+    removes the route specified by PATH from this list, then removes and regenerates the routes.php file without the named route.
+  LONGDESC
+  # Remove a route from the Application routes file
+  # @param path [String] the path to unroute
+  def unroute(path)
+    verify do
+      app.unroute(path)
+    end
+  end
+  
+  desc 'verify DIR', "Verify that DIR is a dinosaur project"
+  long_desc <<-LONGDESC
+    `$ ptero verify DIR` checks the dinosaur.root property DIR/composer.json for a non-null, non-false value that signifies that DIR is the root directory of a dinosaur project.
+    \n\nIf no DIR is specified, the current working directory is used, so running `$ ptero verify` is a quick way to check if the current directory is a dinosaur project
+  LONGDESC
+  # Tell the user whether or not the specified directory is a Ptero directory.
+  # Print "#{dir} is a dinosaur directory" if so or call ptero_dir_message if not
+  # If a block is given and dir is a dinosaur directory, yield control to the block (without arguments) rather than displaying output
+  # @param dir [String,Pathname] the directory to check
+  def verify(dir=Dir.pwd)
+    a = Ptero::Application.new(dir)
+    if a.verify
+      if block_given?
+        yield
+      else
+        puts "#{dir} is a dinosaur project root.".green
+      end
+      true
+    else
+      ptero_dir_message
+      false
+    end
+  end
+  
+  desc 'destroy DIR', "Delete DIR"
+  long_desc <<-LONGDESC
+    After asking for confirmation, ptero destroy DIR will recursively remove an entire dinosaur application folder. DIR is set to the current working directory by default
+  LONGDESC
+  # Destroy dir if dir is a dinosaur directory
+  # This method will ask for confirmation by prompting to the user to type "Yes" (case sensitive) before destroying the directory.
+  # If the user types this exactly, destroy will recursively delete dir and
+  # print "Removed dir".green. If the user types anything else, the method will exit without output.
+  # If the call to verify fails and the application is not a dinosaur directory, destroy prints "Cannot destroy dir because it is not a dinosaur directory".red
+  # and exits.
+  # @param dir [String,Pathname] the directory to destroy
+  def destroy(dir = Dir.pwd)
+    a = Ptero::Application.new(dir)
+    if a.verify
+      puts "Are you sure you want to destroy #{dir}? Type 'Yes' to authorize".yellow
+      print '>> '
+      return unless $stdin.gets.chomp == 'Yes'
+      a.destroy
+      puts "Removed #{dir}".green
+      
+    else
+      puts "Cannot destroy #{dir} because it is not a dinosaur directory.".red
+    end
+  end
+  
+  desc 'install', 'Install dependencies'
+  long_desc <<-LONGDESC
+    Use the composer.json file to install dependencies
+  LONGDESC
+  # Call the appropriate Application methods on the current Application to install Composer dependencies.
+  # If verify returns false, install quits with the ptero_dir_message text
+  def install
+    verify do
+      app.install_dependencies
+    end
+  end
+  
+  desc 'composer', 'Download composer.phar'
+  long_desc <<-LONGDESC
+    Download the compser.phar file in order to facilitate future downloads
+  LONGDESC
+  # Call the appropriate Application methods on the current Application to download composer.phar.
+  # If verify returns false, composer quits with the ptero_dir_message text
+  def composer
+    verify do
+      app.get_composer
+    end
+  end
+  
+  
+  desc 'generate TYPE, *ARGS', 'Generate a file of type TYPE with ARGS'
+  long_desc <<-LONGDESC
+    The generate command creates a new file from ptero-generator TYPE, names it name, and passes it the following arguments as generator params.
+    This often results in the creation of a file called NAME + TYPE in a specific directory, as determined by the generator. For a more concrete example:
+    \n\n `$ ptero generate controller blog`
+    \n\n results in the creation of the file ./php/controllers/BlogController.php. Default output from the generate command will tell you what file was generated.
+  LONGDESC
+  # Use the appropriate Application methods to generate new files and components.
+  # As with other methods, this one runs a check with the verify method before undertaking any action
+  # @param type [String] the type of file to generate
+  # @param *args other parameters for the generator
+  def generate(type,*args)
+    verify do
+      app.generate(type,*args)
+    end
+  end
+  
+  
+  desc 'reload TYPE, *ARGS', 'Remove and regenerate TYPE,*ARGS'
+  long_desc <<-LONGDESC
+    The reload command removes and regenerates generator TYPE with *ARGS.
+    ** USE WITH CAUTION ON UNCOMMITTED FILES, THIS WILL OVERWRITE EXISTING CHANGES **
+  LONGDESC
+  # Use the Application object to remove and regenerate a file or component
+  # As with other methods, this one runs a check with the verify method before undertaking any action
+  # @param type [String] the type of file to reload
+  # @param *args other parameters
+  def reload(type,*args)
+    verify do
+      app.reload(type,*args)
+    end
+  end
+  
+  desc 'remove TYPE, NAME', 'Remove a file'
+  long_desc <<-LONGDESC
+    The remove command is the inverse of the generate command. (see $ ptero help generate) It locates the file that would be generated from a $ ptero generate command and
+    deletes it. Like the generate command, the remove command will tell you what file(s) it has removed.
+  LONGDESC
+  # Reload is the inverse of generate. Use the Application object to remove a file.
+  # It runs verify on the Application before taking any action.
+  # @param type [String] the type of file to remove
+  # @param *args other arguments to remove the file
+  def remove(type,*args)
+    verify do
+      app.remove(type,*args)
+    end
+  end
+  
+  
+  desc 'routes', 'Display current routes'
+  long_desc <<-LONGDESC
+    The routes command takes no arguments and displays all current routes in the application.
+  LONGDESC
+  # If verify succeeds, display all routes of the current application
+  def routes
+    verify do
+      app.routes.each_pair do |key,value|
+        puts "#{key} => #{value}Controller"
+      end
+    end
+  end
+  
+  desc 'version', 'Display Ptero version number'
+  long_desc <<-LONGDESC
+    Use the Ptero::VERSION constant to represent the version number
+  LONGDESC
+  # Print the Ptero version number
+  def version
+    puts Ptero::VERSION
+  end
+  
+  private
+  @@cache = {}
+  def app
+    if @@cache[Pathname.new(Dir.pwd)]
+      @@cache[Pathname.new(Dir.pwd)]
+    else
+      @@cache[Pathname.new(Dir.pwd)] = Ptero::Application.new(Dir.pwd)
+    end
+  end
+
+  def ptero_dir_message
+    puts
+    puts 'The current directory is not a dinosaur root directory.'
+    puts 'Run the following command:'
+    puts '    $ ptero new NAME'
+    puts 'Then run the desired command inside the NAME directory.'
+    puts
+  end
+  
+end

data/lib/ptero/composer_default.json

@@ -0,0 +1,8 @@
+{
+	"require": {
+		"luminousrubyist/dinosaur": "dev-master"
+	},
+	
+	"minimum-stability": "dev",
+	
+}

data/lib/ptero/exception.rb

@@ -0,0 +1,26 @@
+# 
+# exception.rb
+# ============
+# The superclass of all Ptero-related exceptions
+# 
+# 
+
+# The superclass of Ptero-related Exceptions
+class Ptero::Exception < StandardError
+  
+  
+  class << self
+    # Autoload exceptions
+    def const_missing(const_name)
+      # Require the exception
+      require "#{__dir__}/exceptions/#{const_name.downcase}.rb"
+      return const_get const_name
+    # If we couldn't load the file, throw an error
+    rescue LoadError
+      super
+    end
+  end
+  
+  
+  
+end

data/lib/ptero/exceptions/applicationexception.rb

@@ -0,0 +1,9 @@
+# 
+# applicationexception.rb
+# =======================
+# 
+
+# An Application-related exception
+class Ptero::Exception::ApplicationException < Ptero::Exception
+  
+end

data/lib/ptero/exceptions/generatorexception.rb

@@ -0,0 +1,9 @@
+# 
+# pteroexception.rb
+# =================
+# 
+
+# A Generator-related exception
+class Ptero::Exception::GeneratorException < Ptero::Exception
+  
+end

data/lib/ptero/generator.rb

@@ -0,0 +1,146 @@
+# 
+# 
+# Generator.rb
+# ============
+# 
+# Generates files from templates
+# 
+require 'ptero'
+require 'erubis'
+require 'pathname'
+require 'colorize'
+require 'mute'
+
+module Ptero
+  # An object that generates files for an application
+  class Generator
+    
+    # Input the generator's name and the Application to generate for
+    # @param name [String] the generator's name
+    # @param app [Application] the application in which to generate files
+    def initialize(name,app=Application.app_for(Dir.pwd))
+      @name = name
+      @dir = Pathname.new(app.dir)
+      @app = app
+    end
+    
+    attr_reader :name, :app, :dir
+    
+    # The filename of the generated file
+    # @return [String] an unqualifed filename, name and extension
+    def filename
+      "#{@name}.#{extension}"
+    end
+    
+    # The extension of the file to be generated
+    # @return [String] "txt"
+    def extension
+      'txt'
+    end
+    
+    # The unqualified name of the class, e.g. 'Controller' for an object of class Ptero::Generator::ControllerGenerator
+    # @return [String] the unqualified name of the class
+    def type
+      self.class.name.split('::').last
+    end
+    
+    # Simple string representation of this object, represented by the unqualified class name and filename of the current object
+    # @return [String] a string representation of this object, of type "[type - filename]"
+    def to_s
+      "[#{type} - #{filename}]"
+    end
+    
+    # Default path to write to, used along with filename to determine the destination of the generated file\
+    # @return [String] the empty string
+    def path
+      ''
+    end
+    
+    # The fully-qualified filename of the file to be generated by this object.
+    # @return [String] a fully-qualified pathname to the file to be generated by this object.
+    def location
+      dir.join(path).join(filename)
+    end
+    
+    # The path to the directory where Ptero templates are stored
+    # @return [String] the aforementioned path
+    def template_path
+      Pathname.new("#{Ptero::TEMPLATE_PATH}/#{self.class.name.split('::').last.downcase}.#{extension}.erb")
+    end
+    
+    # Generate a file and print the location of the generated file
+    # @return [Generator] self
+    def generate
+      loc = location
+      raise Ptero::Exception::GeneratorException, "Generator is already generated: #{self}" if generated?
+      unless loc.dirname.exist?
+        loc.dirname.descend do |dir|
+          Dir.mkdir dir unless dir.exist?
+        end
+      end
+      File.open(loc,'w') do |file|
+        file.puts content
+      end
+      puts "GENERATE - #{self}".green
+      self
+
+    end
+    
+    # Remove the file corresponding to self and print its location
+    # @return [Generator] self
+    def remove
+      loc = location
+      raise Ptero::Exception::GeneratorException, "Cannot remove because generator is already generated: #{self}" unless generated?
+      File.unlink(loc);
+      puts "REMOVE - #{self}".red
+      self
+    end
+    
+    # Find out if this Generator's file is generated
+    # @return [Boolean] Does the file exist?
+    def generated?
+      File.exist? location
+    end
+    
+    # Remove and regenerate and print the regenerated file
+    # @return [Generator] self
+    def reload
+      Mute::IO.capture_stdout do
+        remove if generated?
+        generate
+      end
+      puts "RELOAD - #{self}".blue
+      self
+    end
+
+    # Return the content of the file to be generated by inputting content_params into an erubis template
+    # @return [String] the content of the file to be generated
+    def content
+      File.open(template_path, 'r') do |file|
+        eruby = Erubis::Eruby.new(file.read)
+        eruby.evaluate(content_params)
+      end
+    end
+    # The context for generating a template, default to self
+    # @return [Generator] self
+    def content_params
+      self
+    end
+    
+    
+  
+    class << self
+      # Autoload Generators
+      def const_missing(const_name)
+        # Require the generator
+        require "#{__dir__}/generators/#{const_name.downcase}.rb"
+        return const_get const_name
+      # If we couldn't load the file, throw an error
+      rescue LoadError
+        super
+      end
+    end
+  end
+  
+  
+end