cubic 0.1.0

data/lib/cubic/generators/app.rb

@@ -0,0 +1,68 @@
+require 'fileutils'
+
+module Cubic
+  module Generator
+    # App is the last stop in the generation process. Once all generator
+    # instances have successfully dealt with the information given
+    # to them, they are sent here so they can turn that information
+    # into files, which are inserted into the generated application.
+    class App < Base
+      extend FileUtils
+
+      class << self
+        def create(*generators)
+          directories
+          static_files
+          insert_generated_files(generators)
+          extra_files
+        end
+
+        private
+
+        # Creates default structure of appliction
+        def directories
+          structure = ['/app/views/layout', '/bin', '/config', '/db/migrations',
+                       '/public/stylesheets', '/public/javascripts', '/spec']
+          structure.each { |f| mkdir_p(Config[:root_path] + f) }
+        end
+
+        # Calls on all generators to turn their stored data into files
+        def insert_generated_files(generators)
+          generators.each(&:generate)
+        end
+
+        # Fills the application with nondynamic files, which can be
+        # found in the templates directory
+        def static_files
+          wd = File.expand_path('../', __FILE__)
+
+          file_and_path = { 'cubic'            => 'bin',
+                            'config.ru'        => '/',
+                            'application.haml' => '/app/views/layout',
+                            'application.rb'   => '/config',
+                            'boot.rb'          => '/config',
+                            'Rakefile'         => '/',
+                            'database.rb'      => '/db',
+                            'application.css'  => '/public/stylesheets',
+                            'application.js'   => '/public/javascripts' }
+
+          file_and_path.keys.each do |k|
+            path = File.join(Config[:root_path], file_and_path[k])
+            if File.exist?("#{wd}/templates/#{k}")
+              FileUtils.cp("#{wd}/templates/#{k}", File.join(path, k))
+            else
+              File.open(File.join(path, k), 'w').close
+            end
+          end
+        end
+
+        # Creates Gemfile
+        def extra_files
+          gemfile = Gemfile.new
+          gemfile.design
+          gemfile.generate
+        end
+      end
+    end
+  end
+end

data/lib/cubic/generators/base.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module Cubic
+  module Generator
+    # All generators (model, view, controller) inherit from the base class.
+    class Base
+      attr_reader :files
+
+      def initialize
+        @files = []
+      end
+
+      # If callback is not defined within a generator, this method
+      # will be called to avoid a 'NoMethodError'.
+      def callback; end
+
+      # Generate takes an array of hashes from each generator,
+      # then creates a file from those params.
+      # If a generator requires a unique file generation,
+      # this method will be overwritten in that file.
+      def generate
+        @files.each do |info|
+          path = File.join(Config[:root_path], info[:path])
+
+          FileUtils.mkdir_p(path) unless File.directory?(path)
+
+          full_path = File.join(path, info[:name])
+          File.open(full_path, 'w') { |f| f.write(info[:content]) }
+        end
+        callback
+      end
+    end
+  end
+end

data/lib/cubic/generators/config.rb

@@ -0,0 +1,67 @@
+module Cubic
+  module Generator
+    # Config stores data needed throughout the generation process.
+    class Config
+
+      @settings = {}
+
+      class << self
+
+        def all
+          @settings
+        end
+
+        def [](key)
+          all[key] || defaults(key)
+        end
+
+        def root_path(path)
+          @settings[:root_path] = path
+        end
+
+        # Name of the application
+        def name(name)
+          @settings[:name] = name
+        end
+
+        # Prefered testing framework.
+        def test_type(type)
+          @settings[:test_type] = type || 'Rspec'
+        end
+
+        def orm(orm)
+          @settings[:orm] = orm || 'Sequel'
+        end
+
+        def db(db)
+          @settings[:db] = db || 'sqlite3'
+        end
+
+        # Consider renaming to 'template engine'
+        def html_type(type)
+          @settings[:html_type] = type || 'haml'
+        end
+
+        def css_type(type)
+          @settings[:css_type] = type || 'css'
+        end
+
+        # Gems to be added to Gemfile
+        def gems(gems)
+          @settings[:gems] = gems
+        end
+
+        # Default options.
+        def defaults(name)
+          { root_path: Dir.getwd,
+            name: 'No Name',
+            test_type: 'rspec',
+            orm: 'Sequel',
+            db: 'sqlite3',
+            html_type: 'haml',
+            css_type: 'css' }[name]
+        end
+      end
+    end
+  end
+end

data/lib/cubic/generators/controller.rb

@@ -0,0 +1,64 @@
+module Cubic
+  module Generator
+    # Controller fulfils the C in the MVC pattern. Files the Model generator
+    # creates will include a class inheriting from the CubicController.
+    class Controller < Base
+
+      def initialize
+        @view = View.new
+        super()
+      end
+
+      # Creates a hash that will be used for file generation purposes
+      def design(name, options = {})
+        if options[:actions] && options[:actions].any?
+          actions = options[:actions]
+          create_views(name, actions)
+        else
+          actions = []
+        end
+
+        @files << { name: "#{name}_controller.rb",
+                    path: '/app/controllers/',
+                    content: build_controller(name, actions) }
+        self
+      end
+
+      private
+
+      def create_views(name, actions)
+        actions.each do |a|
+          @view.design(name, a)
+        end
+      end
+
+      # Called after the Controller generated has created its files.
+      def callback
+        @view.generate
+      end
+
+      def build_controller(name, actions)
+        "#{controller_name(name)} < Cubic::CubicController\n#{build_actions(name, actions)}\nend"
+      end
+
+      def build_method(name, a)
+        "\n#{tab}get '#{a}' do\n#{tab}\s\shaml '#{name}/#{a}'\n#{tab}end\n"
+      end
+
+      def controller_name(name)
+        "class #{name.to_s.split('_').map(&:capitalize).join('')}Controller"
+      end
+
+      def build_actions(name, actions)
+        actions.map! do |a|
+          build_method(name, a)
+        end
+        "\s\snamespace '#{name}' do\n#{actions.join}\n\s\send"
+      end
+
+      def tab
+        "\s" * 4
+      end
+    end
+  end
+end

data/lib/cubic/generators/gemfile.rb

@@ -0,0 +1,23 @@
+module Cubic
+  module Generator
+    # Creates a Gemfiles in the root directory of the generated application.
+    class Gemfile < Base
+
+      # Creates a hash that will be used for file generation purposes
+      def design
+        group = ['source "https://rubygems.org"',
+                 'gem "sinatra"',
+                 'gem "rake"',
+                 'gem "sequel"',
+                 'gem "haml"']
+
+        gems = [Config[:gems], Config[:orm], Config[:db]].flatten.compact
+        gems.map! { |gem| "gem '#{gem}'" }
+
+        @files << { name: 'Gemfile',
+                    path: '/',
+                    content: gems.unshift(group).flatten!.join("\n") }
+      end
+    end
+  end
+end

data/lib/cubic/generators/migrations.rb

@@ -0,0 +1,24 @@
+module Cubic
+  module Generator
+    # Generates the migrations for columns and rows attached to a model.
+    class Migrations < Base
+
+      # Creates a hash that will be used for file generation purposes
+      def design(name, options)
+        @files << { name: "create_#{name}.rb",
+                    path: '/db/migrations/',
+                    content: "DB.create_table :#{name.to_s.concat('s')} do
+                      primary_key :id
+                      #{pair(options)}
+                    end" }
+      end
+
+      private
+
+      # Example: {email: :string} turns into 't.string :email'
+      def pair(options)
+        options.keys.map { |f| "#{options[f].capitalize} :#{f}" }.join("\n")
+      end
+    end
+  end
+end

data/lib/cubic/generators/model.rb

@@ -0,0 +1,64 @@
+module Cubic
+  module Generator
+    # Model fulfils the M in the MVC pattern. Files the Model generator
+    # creates will include a class inheriting from the class your ORM
+    # suggests.
+    class Model < Base
+
+      def initialize
+        @migration = Migrations.new
+        super()
+      end
+
+      # Creates a hash that will be used for file generation purposes
+      def design(name, options = {})
+        @migration.design(name, options)
+
+        @files << { name: "#{name}.rb",
+                    path: '/app/models',
+                    content: format_model(name) }
+        self
+      end
+
+      # Called after a file is successfully generated from hash
+      # created by design method.
+      def callback
+        @migration.generate
+      end
+
+      # Allows user to specify code that should be included in
+      # generated model file.
+      # Example: add('has_many :users')
+      def add(*code)
+        code *= "\n"
+        @files.last[:content] = insert_code(@files.last[:content], code)
+      end
+
+      private
+
+      def format_model(name)
+        "class #{model_name(name)} < #{orm_class}\n\nend".chomp
+      end
+
+      def model_name(name)
+        name.to_s.split('_').map(&:capitalize).join('')
+      end
+
+      # Inserts code into the file to be generated.
+      def insert_code(model, code)
+        model.split(/(?<=#{orm_class})/).insert(1, code).join("\n")
+      end
+
+      # Returns what class should be inherted from based on ORM
+      # specified in sitemap file.
+      def orm_class
+        case Config[:orm]
+        when 'Sequel' || 'sequel'
+          'Sequel::Model'
+        else
+          Config[:orm]
+        end
+      end
+    end
+  end
+end

data/lib/cubic/generators/templates/Rakefile

@@ -0,0 +1,14 @@
+desc 'migrate database'
+task :migrate do
+  require './db/database'
+
+  migrations = File.join('.', %w(db migrations *))
+  Dir.glob(migrations).each do |lf|
+    begin
+      require lf
+      puts 'Successfully migrated: '.concat(lf)
+    rescue
+      next
+    end
+  end
+end

data/lib/cubic/generators/templates/application.haml

@@ -0,0 +1,8 @@
+!!!
+%html
+  %head
+    %link{ :rel => "stylesheet", :href => "/stylesheets/application.css" }
+    %script{ :src => "/javascripts/application.js" }
+    %title test
+  %body
+    = yield

data/lib/cubic/generators/templates/application.rb

@@ -0,0 +1,14 @@
+APP_PATH = File.expand_path('../..', __FILE__)
+ENV['NAME'] = 'development'
+
+require File.join(APP_PATH, 'db/database')
+
+require 'cubic'
+
+Cubic.application.load_app
+
+module TestApp
+  class Application < Cubic::Application
+
+  end
+end

data/lib/cubic/generators/templates/boot.rb

@@ -0,0 +1,4 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+
+require 'bundler/setup'
+Bundler.require(ENV['BUNDLE_GEMFILE'])

data/lib/cubic/generators/templates/config.ru

@@ -0,0 +1,7 @@
+require File.expand_path('../config/application', __FILE__)
+pathh = File.join(APP_PATH, 'public')
+
+# Default middleware
+use Cubic::Static, url: ['/stylesheets', '/javascripts'], root: pathh
+
+run Cubic.application

data/lib/cubic/generators/templates/cubic

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby.exe
+require 'cubic'
+require_relative '../config/boot.rb'
+
+APP_PATH = File.expand_path('../../config/application', __FILE__)
+Cubic::Options.new(ARGV).run

data/lib/cubic/generators/templates/database.rb

@@ -0,0 +1,2 @@
+require 'sequel'
+DB = Sequel.connect('sqlite://application.db')

data/lib/cubic/generators/templates/sitemap.rb

@@ -0,0 +1,42 @@
+Cubic.run do |construct|
+
+  construct.config do |config|
+    # Your configuration block will set the defaults for
+    # your application.These options are not set in stone,
+    # but this file is an easy way to get an overview
+    # of your app, so it is best to try and follow
+    # what you have specified here!
+
+    # Below are the default options when generating your application.
+    #
+    # Your root_path will set the directory you wish
+    # your application generated within.
+    config.root_path  = Dir.getwd
+
+    # As of now, only Sequel and ActiveRecord are the only ORMs supported.
+    config.orm        = 'Sequel'
+
+    # Select your prefered database.
+    config.db         = 'sqlite3'
+
+    # Choose your templating engine.
+    config.html_type  = 'haml'
+    config.css_type   = 'css'
+
+    # Add gems you will require
+    config.gems       = []
+  end
+
+  construct.models do |model|
+    # Create -or 'design'- your models within this block.
+    # model.design(:user, {some: 'structure'}).add('has_secure_password')
+  end
+
+  construct.controllers do |c|
+    # List your controllers to be generated.
+    c.design(:home).routes(:index)
+    c.design(:user).routes(:new)
+    c.design(:sessions)
+    c.design(:static)
+  end
+end