dronr 0.0.2

data/lib/dronr/manager.rb

@@ -0,0 +1,167 @@
+require 'rails/generators/rails/app/app_generator'
+
+module Dronr
+  class Manager
+  
+    attr_accessor :app_generator, :register
+
+    def initialize(app_generator, register=Register.new)
+      @app_generator = app_generator
+      @register = register
+    end
+
+    def self.from_scratch(app_name, template_register, user_params={})
+
+      opts = { skip_bundle: true }
+
+      template_register.drones.each do |drone|
+        opts.merge! drone.args_for_app_create
+      end
+
+      generator = Rails::Generators::AppGenerator.new([app_name], opts)
+      generator.invoke_all
+
+      # BOOTSTRAP
+      manager = new(generator, template_register)
+
+      manager.say_hello
+
+      dronr = Drones::Dronr.new(:incoming)
+      manager.bundle_drone(dronr)
+      manager.run_bundle
+      manager.install_drone(dronr)
+
+      manager.register.drones << dronr
+
+      manager.commit_register
+
+      manager.app_generator.run 'bin/dronr up'
+    end
+
+
+    def self.existing(options={})
+
+      generator = Rails::Generators::AppGenerator.new [Rails.root], {}, destination_root: Rails.root
+
+      manager = new(generator)
+
+      manager.load_register
+
+      canonical_register = Register.load_canonical
+      manager.register.sort_by_example_register(canonical_register)
+
+      manager.up
+
+      manager.commit_register
+
+      manager.say_goodbye
+    end
+
+    # def bootstrap
+    # --- add dronr to register & up
+    # end
+
+    # def stage
+    #   # for each drone in 'new' register
+    #   # sort by canonical register
+    #   # say 'staging for x drones'
+
+    #   # output all commands..
+    # end
+
+    def commit_register
+      @register.commit(register_path)
+    end
+
+    def load_register
+      @register = Register.load(register_path)
+    end
+
+    def up
+      incoming_drones = @register.incoming_drones.dup
+      bundled_drones = @register.bundled_drones.dup
+
+      # ----------------
+      # 1. BUNDLING new drones
+
+      incoming_drones.each do |drone|
+        bundle_drone(drone)
+      end
+
+      if incoming_drones.map(&:class).detect(&:bundle_block) 
+        run_bundle
+      end
+
+      # ------------
+      # 2. INSTALLING bundled drones
+
+      bundled_drones.each do |drone|
+        install_drone(drone)
+      end
+
+      say_status :dronr, "Finishing..", :blue
+
+      bundled_drones.each do |drone|
+        finish_drone(drone)
+      end
+
+    end
+
+    def bundle_drone(drone)
+      say_status :dronr, "Bundling #{drone.human_name}", :blue
+
+      if block = drone.class.bundle_block
+        @app_generator.instance_eval(&block)
+      end
+
+      drone.state = :bundled
+    end
+
+    def install_drone(drone)
+      say_status :dronr, "Installing #{drone.human_name}", :yellow
+
+      if block = drone.class.install_block
+        @app_generator.instance_eval(&block)
+      end
+    end
+
+    def finish_drone(drone)
+
+      if block = drone.class.finish_block
+        @app_generator.instance_eval(&block)
+      end
+
+      drone.state = :finished
+    end
+
+
+    def say_status(*opts)
+      @app_generator.say_status(*opts)
+    end
+
+    def say_hello
+      say_status :dronr, 'Hello :)', :blue
+    end
+
+    def say_goodbye
+      if register.finished_drones.count == register.drones.count
+        say_status :dronr, 'All yours, sparky!', :blue
+      else
+        say_status :dronr, 'Completed iteration but some drones are unfinished. To continue working, run `bin/dronr up` in the project root.', :red
+      end
+    end
+
+    def run_bundle
+      @app_generator.send :bundle_command, 'install --quiet'
+    end
+
+    def app_root
+      @app_generator.instance_variable_get(:@destination_stack).first
+    end
+
+    def register_path
+      File.join(app_root, '.dronr.yml')
+    end
+
+  end
+end

data/lib/dronr/register/canonical.yml

@@ -0,0 +1,37 @@
+incoming:
+# core:
+
+# app:
+
+# database:
+- postgresql
+- migrant
+
+# templating:
+- slim
+
+# decorating:
+- draper
+
+# assets:
+- compass
+- foundation
+- foundation_icons
+- underscore
+
+# test:
+- rspec
+- factory_girl
+
+# deploy:
+- heroku
+
+# misc
+- dotenv
+- cleanup
+- git
+
+bundled:
+
+finished:
+

data/lib/dronr/register/standard.yml

@@ -0,0 +1,27 @@
+incoming:
+
+- postgresql
+- migrant
+
+- slim
+- draper
+
+- compass
+- foundation
+- foundation_icons
+
+- underscore
+
+- dotenv
+- rspec
+- factory_girl
+
+- heroku
+
+- cleanup
+- git
+
+bundled:
+
+finished:
+

data/lib/dronr/register.rb

@@ -0,0 +1,91 @@
+require 'yaml'
+
+module Dronr
+
+  class Register
+
+    CANONICAL_PATH = '..'
+
+    class MalformedRegisterError < StandardError
+    end
+
+    class InvalidRegisterError < StandardError
+    end
+
+    %W{incoming bundled finished}.each do |state|
+      define_method "#{state}_drones" do
+        drones.select do |drone|
+          drone.state == state.to_sym
+        end
+      end
+    end
+
+    attr_reader :drones
+
+    def initialize(drones=[])
+      @drones = drones
+    end
+
+    def self.load_canonical
+      canonical_path = File.expand_path '../register/canonical.yml', __FILE__
+      load(canonical_path)
+    end
+
+    def self.load(path)
+      begin
+        yaml = YAML.load_file(path)
+      rescue Psych::SyntaxError
+        raise MalformedRegisterError.new(yaml), 'is not valid YAML'
+      end
+
+      unless yaml.has_key?('incoming') && yaml.has_key?('bundled') && yaml.has_key?('finished')
+        raise MalformedRegisterError.new(yaml), 'is missing required keys (incoming, bundled, finished)'
+      end
+
+      drones = %w{incoming bundled finished}.map do |state|
+        (yaml[state] || []).map do |drone_name|
+          klass = Drone.find_class_by_human_name(drone_name)
+          klass.new(state.to_sym)
+        end
+      end.flatten
+
+      new(drones).tap do |register|
+        unless register.valid?
+          raise InvalidRegisterError.new(register), "Couldnt load register at #{path}"
+        end
+      end
+    end
+
+    def valid?
+      has_valid_drones = drones.all? do |drone|
+        drone && (drone.class < Drone)
+      end
+
+      has_no_duplicate_drones = (drones.count == drones.map(&:class).uniq.count)
+
+      has_valid_drones && has_no_duplicate_drones
+    end
+
+    def sort_by_example_register(example_register)
+      @drones = example_register.drones.map do |drone|
+        @drones.detect{ |d| d.class == drone.class }
+      end.compact
+    end
+
+    def to_yaml
+      {
+        'incoming' => incoming_drones.map(&:human_name).presence,
+        'bundled' => bundled_drones.map(&:human_name).presence,
+        'finished' => finished_drones.map(&:human_name).presence
+      }.to_yaml
+    end
+
+    def commit(path)
+      File.open(path, 'w+') do |f|
+        f.write(to_yaml)
+      end
+    end
+
+  end
+
+end

data/lib/dronr/version.rb

@@ -0,0 +1,3 @@
+module Dronr
+  VERSION = "0.0.2"
+end

data/lib/dronr.rb

@@ -0,0 +1,17 @@
+require 'dronr/version'
+require 'pry'
+
+require 'rails'
+require 'rails/generators'
+
+module Dronr
+
+  extend ActiveSupport::Autoload
+
+  autoload :CLI
+  autoload :Drone
+  autoload :Drones
+  autoload :Manager
+  autoload :Register
+
+end

data/spec/dronr/drone_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Dronr
+
+  describe Drone do
+
+    describe '.find_class_by_human_name' do
+
+      it 'returns the correct class when a match exists' do
+        drone = Drone.find_class_by_human_name('drone1')
+        expect(drone).to eq Drones::Drone1
+      end
+
+      it 'raises an error if a matching drone cant be found' do
+        expect do
+          Drone.find_class_by_human_name('drone90210')
+        end.to raise_error(Drone::DroneNotFoundError)
+      end
+    end
+
+    describe '#human_name' do
+
+      it 'humanizes the class name' do
+        expect(Drones::Drone1.new.human_name).to eq 'drone1'
+        # TODO test more complex options
+      end
+
+    end
+
+    describe 'directive DSL' do
+
+      class TestableDrone1 < Drone
+        bundle do
+          'TestableDrone1 #bundle'
+        end
+
+        install do
+          'TestableDrone1 #install'
+        end
+
+        finish do
+          'TestableDrone1 #finish'
+        end
+      end
+
+      class TestableDrone2 < Drone
+        bundle do
+          'TestableDrone2 #bundle'
+        end
+
+        install do
+          'TestableDrone2 #install'
+        end
+
+        finish do
+          'TestableDrone2 #finish'
+        end
+      end
+
+
+      it 'captures unique #bundle and #install directives' do
+        expect(TestableDrone1.bundle_block.call).to eq 'TestableDrone1 #bundle'
+        expect(TestableDrone1.install_block.call).to eq 'TestableDrone1 #install'
+        expect(TestableDrone1.finish_block.call).to eq 'TestableDrone1 #finish'
+
+        expect(TestableDrone2.bundle_block.call).to eq 'TestableDrone2 #bundle'
+        expect(TestableDrone2.install_block.call).to eq 'TestableDrone2 #install'
+        expect(TestableDrone2.finish_block.call).to eq 'TestableDrone2 #finish'
+      end
+
+    end
+
+  end
+
+end

data/spec/dronr/register_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+module Dronr
+
+  describe Register do
+
+    describe '#load_canonical' do
+      it 'loads the canonical register' do
+        expect(Register.load_canonical).to be_a(Register)
+      end
+    end
+
+    describe '#load' do
+
+      it 'parses a YML file at the given path into a valid Register' do
+        register = Register.load fixture_path('register_template.yml')
+
+        expect(register.incoming_drones.map(&:class)).to eq([Drones::Drone2, Drones::Drone1])
+        expect(register.bundled_drones.map(&:class)).to eq([Drones::Drone4])
+        expect(register.finished_drones.map(&:class)).to eq([Drones::Drone3])
+      end
+
+      it 'raises an error if YML file is malformed' do
+        expect do
+          register = Register.load fixture_path('register_malformed.yml')
+        end.to raise_error(Register::MalformedRegisterError)
+      end
+
+      it 'raises an error if YML file is missing keys' do
+        expect do
+          register = Register.load fixture_path('register_keys_missing.yml')
+        end.to raise_error(Register::MalformedRegisterError)
+      end
+
+      it 'raises an error if a named drone couldnt be found' do
+        expect do
+          register = Register.load fixture_path('register_drone_not_found.yml')
+        end.to raise_error(Drone::DroneNotFoundError)
+      end
+
+      it 'raises an error if the register is invalid' do
+        expect do
+          register = Register.load fixture_path('register_invalid.yml')
+        end.to raise_error(Register::InvalidRegisterError)
+      end
+
+    end
+
+    describe '#sort_by_example_register' do
+
+      it 'returns drones ordered correctly' do
+
+        canonical_register = Register.new([
+          Drones::Drone1.new(:incoming),
+          Drones::Drone2.new(:incoming),
+          Drones::Drone3.new(:incoming),
+          Drones::Drone4.new(:incoming)
+        ])
+
+        drone4 = Drones::Drone4.new(:bundled)
+        drone1 = Drones::Drone1.new(:incoming)
+        drone3 = Drones::Drone3.new(:finished)
+
+        register = Register.new([drone4, drone1, drone3])
+
+        register.sort_by_example_register(canonical_register)
+        expect(register.drones).to eq [drone1, drone3, drone4]
+      end
+
+    end
+
+
+    describe '#valid?' do
+
+      it 'returns true when all entries are unique subclasses of Drone' do
+        register = Register.new([
+          Drones::Drone1.new(:incoming),
+          Drones::Drone2.new(:bundled),
+          Drones::Drone3.new(:finished)
+        ])
+        expect(register).to be_valid
+      end
+
+      it 'returns false if there are duplicate drones of the same kind' do
+        register = Register.new([
+          Drones::Drone1.new(:incoming),
+          Drones::Drone1.new(:incoming)
+        ])
+        expect(register).to_not be_valid
+      end
+
+      it 'returns false if a particular drone appears in both arrays' do
+        register = Register.new([
+          Drones::Drone1.new(:incoming), 
+          Drones::Drone1.new(:bundled),
+          Drones::Drone2.new(:bundled)
+        ])
+        expect(register).to_not be_valid
+      end
+
+      it 'returns false unless all entries are subclasses of Drone' do
+        register = Register.new([
+          Drones::Drone1.new(:incoming),
+          nil
+        ])
+        expect(register).to_not be_valid
+      end
+    end
+
+    describe '#to_yml' do
+
+      it 'correctly generates a YML file' do
+        register = Register.new([
+          Drones::Drone1.new(:incoming),
+          Drones::Drone2.new(:finished),
+          Drones::Drone3.new(:finished)
+        ])
+
+        yaml = YAML.load(register.to_yaml)
+
+        expect(yaml['incoming']).to eq %w{drone1}
+        expect(yaml['bundled']).to eq nil
+        expect(yaml['finished']).to eq %w{drone2 drone3}
+      end
+
+    end
+
+    describe '#commit' do
+
+      it 'serializes to yaml and saves at the given path' do
+
+        register = Register.new([
+          Drones::Drone1.new(:incoming),
+          Drones::Drone2.new(:bundled),
+          Drones::Drone3.new(:finished)
+        ])
+
+        path = File.expand_path '../../tmp/dronr.yml', __FILE__
+
+        File.delete(path) if File.exists?(path)
+        expect(File.exists?(path)).to eq false
+
+        register.commit(path)
+
+        expect(File.exists?(path)).to eq true
+        expect(Register.load(path)).to be_valid
+      end
+    end
+
+  end
+
+end

data/spec/fixtures/register_drone_not_found.yml

@@ -0,0 +1,8 @@
+incoming:
+  - drone2
+  - drone1
+
+bundled:
+
+finished:
+  - drone90210

data/spec/fixtures/register_invalid.yml

@@ -0,0 +1,8 @@
+incoming:
+  - drone3
+  - drone1
+
+bundled:
+
+finished:
+  - drone3

data/spec/fixtures/register_keys_missing.yml

@@ -0,0 +1,2 @@
+finished:
+  - drone3

data/spec/fixtures/register_malformed.yml

@@ -0,0 +1,7 @@
+- drone2
+- drone1
+
+finished:
+
+  - drone3
+

data/spec/fixtures/register_template.yml

@@ -0,0 +1,9 @@
+incoming:
+  - drone2
+  - drone1
+
+bundled:
+  - drone4
+
+finished:
+  - drone3

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'dronr'
+
+require 'support/sample_drones'
+require 'support/fixture_path'
+
+RSpec.configure do |config|
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.include Helpers::FixturePath
+
+end

data/spec/support/fixture_path.rb

@@ -0,0 +1,9 @@
+module Helpers
+  module FixturePath
+
+    def fixture_path(file_path)
+      File.expand_path("../../fixtures/#{file_path}", __FILE__)
+    end
+
+  end
+end

data/spec/support/sample_drones.rb

@@ -0,0 +1,15 @@
+module Dronr
+  module Drones
+    class Drone1 < Drone
+    end
+
+    class Drone2 < Drone
+    end
+
+    class Drone3 < Drone
+    end
+
+    class Drone4 < Drone
+    end
+  end
+end

data/spec/tmp/dronr.yml

@@ -0,0 +1,7 @@
+---
+incoming:
+- drone1
+bundled:
+- drone2
+finished:
+- drone3