my_enginery 0.2.8

data/app/migrations/tracking_table/ActiveRecord.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Migration.verbose = false
+
+module Enginery
+  class Migrator
+    class TracksMigrator < ActiveRecord::Migration
+      def up
+        return if table_exists?(TRACKING_TABLE)
+        create_table TRACKING_TABLE do |t|
+          TRACKING_TABLE__COLUMNS.each {|c| t.string(c, limit: 255)}
+        end
+        TRACKING_TABLE__INDEXES.each {|c| add_index(TRACKING_TABLE, c)}
+      end
+    end
+
+    class TracksModel < ActiveRecord::Base
+      self.table_name = TRACKING_TABLE
+    end
+  end
+end

data/app/migrations/tracking_table/DataMapper.rb

@@ -0,0 +1,26 @@
+require 'dm-migrations'
+
+module Enginery
+  class Migrator
+    TracksMigrator = DataMapper::Migration.new 0, TRACKING_TABLE do
+      @verbose = false
+      up do
+        unless DataMapper.repository(repository).adapter.storage_exists?(TRACKING_TABLE.to_s)
+          create_table TRACKING_TABLE do
+            column :id, Integer, serial: true
+            TRACKING_TABLE__COLUMNS.each {|c| column c, String, length: 255}
+          end
+          TRACKING_TABLE__INDEXES.each {|c| create_index(TRACKING_TABLE, c)}
+        end
+      end
+    end
+
+    class TracksModel
+      include DataMapper::Resource
+      repositories.each {|r| storage_names[r.name] = TRACKING_TABLE}
+      property :id, Serial
+      TRACKING_TABLE__COLUMNS.each {|c| property c, String, length: 255}
+    end
+    DataMapper.finalize
+  end
+end

data/app/migrations/tracking_table/Sequel.rb

@@ -0,0 +1,18 @@
+Sequel.extension :migration
+
+module Enginery
+  class Migrator
+    TracksMigrator = Sequel.migration do
+      up do
+        create_table? TRACKING_TABLE do
+          primary_key :id
+          TRACKING_TABLE__COLUMNS.each {|c| column c, String, size: 255}
+          TRACKING_TABLE__INDEXES.each {|c| index c}
+        end
+      end
+    end
+
+    class TracksModel < Sequel::Model(TRACKING_TABLE)
+    end
+  end
+end

data/app/rakefiles/DataMapper.rb

@@ -0,0 +1 @@
+require 'enginery/rake-tasks/data_mapper'

data/app/rakefiles/Specular.rb

@@ -0,0 +1 @@
+require 'enginery/rake-tasks/specular'

data/app/specfiles/Specular.erb

@@ -0,0 +1,7 @@
+
+Spec.new "#{ @spec }" do
+  map #{ @controller }[:#{ @action }]
+
+  get
+  is(last_response).ok?
+end

data/bin/my_enginery

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'enginery'
+require 'enginery/usage'
+
+root, operation = Dir.pwd, $*[0].to_s
+
+OptionParser.new do |o|
+  o.on '-h' do
+    puts Enginery.usage
+    exit 0
+  end
+  o.on '-v' do
+    puts EngineryVersion::FULL
+    exit 0
+  end
+  o.on '-c', "Display controllers in YAML format" do
+    puts Enginery::Registry.new(root).controllers
+    exit 0
+  end
+  o.on '-m', "Display models in YAML format" do
+    puts Enginery::Registry.new(root).models
+    exit 0
+  end
+end.parse!
+
+cli = Enginery::CLI.new
+result = catch :enginery_failures do
+
+  case
+  when operation[0] == 'g'
+
+    unit = operation.sub(/\Ag(enerate)?\W?/, '')
+    args, setups, string_setups = Enginery::Helpers.parse_input(*$*[1..-1])
+    generator = Enginery::Generator.new(root, setups)
+
+    if args
+      if unit.empty? # generating application
+        if generator.generate_project(args[0])
+          Dir.chdir generator.dst_root do
+            cli.bundle :install
+            cli.new_controller 'Index', 'r:/' # generating Index controller
+          end
+        end
+      else
+
+        generator.fail_unless_in_app_folder!
+        generator.load_boot_rb # loading application
+
+        case
+        when unit =~ /\Ac(ontroller)?/
+          if args.size > 1 # generate multiple controllers
+            args.each {|c| cli.new_controller(c, string_setups)}
+          else
+            # generating controller
+            if generator.generate_controller(args[0])
+              # generating helper file
+              cli.new_helper args[0]
+              
+              # generating index route
+              cli.new_route args[0], :index
+            end
+          end
+
+        when unit =~ /\Ar(oute)?/
+          if args.size > 2 # generate multiple routes
+            args[1..-1].each {|r| cli.new_route(args[0], r, string_setups)}
+          else
+            if generator.generate_route(*args)
+              # generating view file
+              cli.new_view *args[0..1]
+              
+              # generating spec file
+              cli.new_spec *args[0..1]
+            end
+          end
+
+        when unit =~ /\As(pec)?/
+          if args.size > 2 # generate multiple specs
+            args[1..-1].each {|s| cli.new_spec(args[0], s, string_setups)}
+          else
+            generator.generate_spec(*args)
+          end
+
+        when unit =~ /\Ah(elper)?/
+          generator.generate_helper(*args)
+
+        when unit =~ /\Av(iew)?/
+          generator.generate_view(args[0], args[1])
+
+        when unit =~ /\Aa(dmin)?(_c(ontroller)?)?/
+          generator.generate_rear_controller(args[0])
+
+        when unit =~ /\Am(odel)?/
+          if args.size > 1 # generate multiple models
+            args.each {|m| cli.new_model(m, string_setups)}
+          else
+            if generator.generate_model(args[0])
+              cli.new_migration "initializing-#{args[0]}-model", "create_table_for:#{args[0]}", string_setups
+              cli.new_admin args[0]
+            end
+          end
+        end
+
+      end
+    end
+
+  when operation[0] == 'm'
+
+    operation = operation.sub(/\Am(igrat(e)?(ion)?)?(\W+)?/, '')
+    args, setups, string_setups = Enginery::Helpers.parse_input(*$*[1..-1])
+    migrator = Enginery::Migrator.new(root, setups)
+
+    migrator.fail_unless_in_app_folder!
+    migrator.load_boot_rb # loading application
+
+    if operation.empty? || operation =~ /\An(ew)?/ # new migration
+      migrator.new args[0]
+    elsif operation =~ /\Al(ist)?/
+      migrator.list
+    else
+      vector, extra = operation.scan(/(\w+)\:?(\w+)?/).flatten
+      force_run, force_yes = extra ? [extra.match(/\Af/i), extra.match(/\Ay/i)] : []
+      
+      if file = setups[:file]
+        migrator.run(vector, file, force_run)
+      else
+        files = migrator.serials_to_files(vector, *args)
+        
+        if files.empty?
+          outstanding_files = migrator.outstanding_migrations(vector)
+          
+          if force_yes
+            files = outstanding_files
+          else
+            puts 'This will run all outstanding migrations in the following order:'
+            puts
+            puts outstanding_files.map {|f| f[/\A\d+/]}*' '
+            puts
+            puts '  Type Y and press enter to continue'
+            puts '  Press enter to cancel'
+            puts '  Use :yes options to get rid of this prompt - enginery m:%s:yes ...' % vector
+            answer = STDIN.gets.strip
+            files  = outstanding_files if answer.match(/\Ay/i)
+          end
+        end
+        
+        if files.empty?
+          puts
+          puts 'Nothing to run, exiting'
+          puts
+          exit 0
+        end
+
+        failed = false
+        files.each do |file|
+          (puts('', '  %s skipped due to previous errors' % file, ''); next) if failed
+          passed = cli.run_migration(vector, force_run, file, string_setups)
+          failed = true unless passed
+        end
+        puts
+        exit(1) if failed
+
+      end
+    end
+
+  when operation[0..5] == 'delete'
+
+    operation = operation.sub(/\Ad(elete)?(\W+)?/, '')
+    unit, extra = operation.scan(/(\w+)\:?(\w+)?/).flatten
+    force_run, force_yes = extra ? [extra.match(/\Af/i), extra.match(/\Ay/i)] : []
+    args, setups, string_setups = Enginery::Helpers.parse_input(*$*[1..-1])
+
+    case
+    when unit =~ /\Ac(ontroller)?/
+      delete_meth, delete_args, required_args = :controller, args[0..0], 1
+    when unit =~ /\Ar(oute)?/
+      delete_meth, delete_args, required_args = :route, args[0..1], 2
+    when unit =~ /\Av(iew)?/
+      delete_meth, delete_args, required_args = :view, args[0..1], 2
+    when unit =~ /\As(pec)?/
+      delete_meth, delete_args, required_args = :spec, args[0..1], 2
+    when unit =~ /\Ah(elper)?/
+      delete_meth, delete_args, required_args = :helper, args[0..0], 1
+    when unit =~ /\Aa(dmin)?(_c(ontroller)?)?/
+      delete_meth, delete_args, required_args = :rear_controller, args[0..0], 1
+    when unit =~ /\Amo(del)?/
+      delete_meth, delete_args, required_args = :model, args[0..0], 1
+    when unit =~ /\Ami(gration)?/
+      delete_meth, delete_args, required_args = :migration, args[0..0], 1
+    else
+      delete_meth = nil
+    end
+
+    if delete_meth
+      delete_args.size == required_args ||
+        Enginery::Helpers.fail('Please provide %s name' % delete_meth)
+
+      unless run = force_run || force_yes
+        puts
+        puts '  You are about to delete "%s" %s!' % [delete_args*"#", delete_meth]
+        puts
+        puts '  This action can not be undone!'
+        puts
+        puts '  Type Y and press enter to Continue'
+        puts '  Press enter to Abort'
+        puts '  Use :yes options to get rid of this prompt - enginery d:%s:yes ...' % unit
+        answer = STDIN.gets.strip
+        run = true if answer.match(/\Ay/i)
+      end
+      if run
+        delete = Enginery::Delete.new(root)
+        delete.load_boot_rb
+        delete.send delete_meth, *delete_args
+      end
+    else
+      Enginery::Helpers.fail '--- Unknown unit "%s" ---' % unit
+    end
+
+  else
+    puts "\n--- Unknown modifier %s ---\n" % operation.split(':').first
+    puts "use one of g[enerate], m[igration], delete\n"
+    puts Enginery.usage
+    exit 1
+  end
+end
+
+if result.is_a?(Enginery::Failure)
+  puts '', '  *** Operation FAILED ***'
+  result.failures.each {|f| puts '  %s' % f}
+  puts
+  exit 1
+end

data/lib/enginery.rb

@@ -0,0 +1,23 @@
+require 'fileutils'
+require 'logger'
+require 'yaml'
+require 'date'
+require 'pty'
+
+require 'e'
+require 'tenjin'
+
+require 'enginery/enginery'
+
+require 'enginery/helpers/app'
+require 'enginery/helpers/generic'
+require 'enginery/helpers/input'
+require 'enginery/helpers/orm'
+require 'enginery/helpers/validations'
+
+require 'enginery/configurator'
+require 'enginery/generator'
+require 'enginery/migrator'
+require 'enginery/delete'
+require 'enginery/registry'
+require 'enginery/cli'

data/lib/enginery/cli.rb

@@ -0,0 +1,44 @@
+module Enginery
+  class CLI
+    include Enginery::Helpers
+    
+    %w[controller route helper view spec model admin].each do |unit|
+      define_method 'new_' + unit do |*args|
+        run '"%s" g:%s %s' % [executable, unit, args.flatten*' ']
+      end
+    end
+
+    def new_migration *args
+      run '"%s" m %s' % [executable, args.flatten*' ']
+    end
+
+    def run_migration vector, force_run, file, setups
+      run '"%s" m:%s:%s f:%s %s' % [executable, vector, force_run, file, setups]
+    end
+
+    def bundle task
+      run 'bundle %s' % task, output_cmd: true
+    end
+
+    def executable
+      $0
+    end
+
+    def run cmd, opts = {}
+      opts[:output_cmd] && (o; o(cmd))
+      PTY.spawn cmd do |r, w, pid|
+        begin
+          r.sync
+          r.each_line do |line|
+            o line.rstrip!
+          end
+        rescue Errno::EIO # simply ignoring this
+        ensure
+          ::Process.wait pid
+        end
+      end
+      $? && $?.exitstatus == 0
+    end
+
+  end
+end

data/lib/enginery/configurator.rb

@@ -0,0 +1,139 @@
+module Enginery
+  class Configurator
+    include Helpers
+
+    def initialize dst_root, setups = {}, &proc
+      @dst_root, @setups = dst_root, setups||{}
+      @setups.is_a?(Hash) || fail('setups should be a Hash. A %s given instead' % @setups.class)
+      self.instance_exec(&proc) if block_given?
+    end
+
+    def update_config_yml
+      setups = normalize_setups(@setups)
+
+      setups.delete 'db'
+
+      engine = setups['engine'] || EConstants::VIEW__DEFAULT_ENGINE_NAME
+      path = src_path(:layouts, engine)
+      if File.directory?(path)
+        Dir[path + '/*'].each {|f| FileUtils.cp(f, dst_path.views)}
+        setups['layout'] = 'layout'
+      end
+
+      return if setups.empty?
+
+      yml = YAML.load File.read(dst_path.config_yml)
+      ENVIRONMENTS.each do |env|
+        (cfg = yml[env] || yml[env.to_s]) && cfg.update(setups)
+      end
+      o
+      write_file dst_path.config_yml, YAML.dump(yml)
+      output_source_code YAML.dump(setups).split("\n")
+    end
+
+    def update_gemfile
+      return if @setups.empty?
+
+      gems, gemfiles = [], []
+      target_gems = File.file?(dst_path.Gemfile) ?
+        extract_gems(File.read dst_path.Gemfile) : []
+      
+      @setups.values_at(:orm, :engine, :server).compact.each do |klass|
+        gemfiles << [src_path(:gemfiles, '%s.rb' % klass), klass]
+      end
+      if orm = @setups[:orm]
+        db_type = (@setups[:db]||{})[:type] || DEFAULT_DB_TYPE
+        gemfiles << [src_path(:gemfiles, db_type, '%s.rb' % orm)]
+      end
+      gemfiles.each do |(gemfile,gem)|
+        if File.file?(gemfile)
+          File.readlines(gemfile).each do |l|
+            extract_gems(l).each do |g|
+              gems << l.chomp unless target_gems.include?(g)
+            end
+          end
+        else
+          next unless gem
+          gem = class_to_gem(gem)
+          gems << ("gem '%s'" % gem) unless target_gems.include?(gem)
+        end
+      end
+      return if gems.empty?
+      o
+      source_code = ['', *gems, '']
+      update_file dst_path.Gemfile, source_code.join("\n")
+      output_source_code source_code
+    end
+
+    def update_rakefile
+      test_framework = @setups[:test_framework] || DEFAULT_TEST_FRAMEWORK
+      source_file = src_path(:rakefiles, "#{test_framework}.rb")
+      unless File.file?(source_file)
+        o("%s not in the list of supported test frameworks: %s" % [
+          test_framework,
+          Dir[src_path(:rakefiles, '*.rb')].map {|f| f.sub(/\.rb\Z/, '')}*', '
+        ])
+      end
+      source_code = File.readlines(source_file)
+      
+      if orm = @setups[:orm]
+        source_file = src_path(:rakefiles, '%s.rb' % orm)
+        source_code.concat  File.readlines(source_file)
+      end
+      o
+      update_file dst_path.Rakefile, source_code
+      output_source_code(source_code)
+    end
+
+    def update_boot_rb
+    end
+
+    def update_database_rb
+      if orm = @setups[:orm]
+        source_file = src_path(:database, '%s.rb' % orm)
+        source_code = File.readlines(source_file)
+        o
+        update_file dst_path.database_rb, source_code
+        output_source_code(source_code)
+      end
+    end
+
+    def update_database_yml
+      setups = normalize_setups(@setups[:db])
+      type   = setups['type'] || DEFAULT_DB_TYPE
+      yml    = YAML.load File.read(src_path(:database, '%s.yml' % type))
+      ENVIRONMENTS.each do |env|
+        (cfg = yml[env] || yml[env.to_s]) && cfg.update(setups)
+      end
+      o
+      write_file dst_path.database_yml, YAML.dump(yml)
+      setups['pass'] = '___________' if setups['pass']
+      output_source_code(YAML.dump(setups).split("\n")) if setups.any?
+    end
+
+    private
+    def class_to_gem klass
+      underscore klass.to_s
+    end
+
+    def extract_gems string
+      string.split("\n").inject([]) do |gems,l|
+        l.strip!
+        (l =~ /\Agem/) &&
+          (gem = l.scan(/\Agem\s+([^,]*)/).flatten.first) &&
+          (gems << gem.gsub(/\A\W+|\W+\Z/, ''))
+        gems
+      end
+    end
+    
+    def normalize_setups setups = {}
+      (setups||{}).inject({}) do |s,(k,v)|
+        key, val = k.to_s, v
+        val = val.to_i if v.respond_to?(:match) && v.match(/\A\d+\Z/)
+        val = val.to_s if val.is_a?(Symbol)
+        s.merge key => val
+      end
+    end
+
+  end
+end