branchable_cdn_assets 0.5.0

data/lib/branchable_cdn_assets/manifest.rb

@@ -0,0 +1,63 @@
+require 'set'
+
+module BranchableCDNAssets
+  class Manifest
+
+    attr_reader :source_file, :file_set
+
+    def initialize source_file
+      @source_file = source_file
+      @file_set = File.exists?(source_file) ? read_source_file : Set.new
+    end
+
+    # list files set as an Array
+    # @return [Array]
+    def files
+      file_set.to_a
+    end
+
+    # add new files to the manifest set
+    # @param new_files [Array]
+    # @return [Set]
+    def merge_files new_files
+      file_set.merge Array(new_files)
+    end
+
+    # remove a set of files from the manifest
+    # @param files_to_remove [Array]
+    # @return [Set]
+    def remove_files files_to_remove
+      file_set.subtract Array(files_to_remove)
+    end
+
+    # updates the manifest file with the
+    # most recent set of files
+    # @return [Void]
+    def update_source_file!
+      destroy! && return if file_set.empty?
+
+      File.open( source_file, 'w' ) do |file|
+        file.write manifest_content
+      end
+    end
+
+    private
+
+      # read the manifest source_file
+      def read_source_file
+        IO.read(source_file).split("\n").to_set
+      end
+
+      # render/serialize the manifest set
+      def manifest_content
+        file_set.to_a.join("\n")
+      end
+
+      # remove the manifest source_file
+      def destroy!
+        File.delete(source_file)
+        true
+      end
+
+  end
+end

data/lib/branchable_cdn_assets/rake_tasks.rb

@@ -0,0 +1,69 @@
+require 'rake'
+require 'branchable_cdn_assets'
+
+module BranchableCDNAssets
+
+  class RakeTasks
+    include ::Rake::DSL
+
+    class << self
+      def register namespace, data={}
+        RakeTasks.new( namespace, Config.new(data) ).register_tasks
+      end
+    end
+
+    attr_reader :file_manager, :rake_namespace
+
+    def initialize namespace, config
+      @file_manager = FileManager.new config
+      @rake_namespace = namespace
+    end
+
+    def tasks
+      {
+        list:  'list of local files',
+        pull!:  'move the current branch\'s remote files to local',
+        push!:  'move local files to the current branch\'s remote',
+        prune!: 'remove local files with the same name as remote files',
+        move_to_production: 'move named branch files to production cdn'
+      }
+    end
+
+    def register_tasks
+      tasks.each do |name, desc|
+        if self.respond_to?(:"register_#{name}")
+          self.send(:"register_#{name}", desc)
+        else
+          register_task name, desc
+        end
+      end
+    end
+
+    def register_move_to_production task_desc
+      in_namespace do
+        desc task_desc
+        task :move_to_production, :branch do |t,args|
+          puts file_manager.with_check(:move_to_production, args[:branch])
+        end
+      end
+    end
+
+    private
+
+      def in_namespace &block
+        namespace rake_namespace do
+          yield
+        end
+      end
+
+      def register_task task_name, task_desc
+        in_namespace do
+          desc task_desc
+          task task_name.to_s.sub('!','') do
+            puts file_manager.public_send( :with_check, task_name )
+          end
+        end
+      end
+
+  end
+end

data/lib/branchable_cdn_assets/shell.rb

@@ -0,0 +1,17 @@
+module BranchableCDNAssets
+  module Shell
+
+    class << self
+      include HereOrThere
+
+      # get input from the command line
+      # @return [String]
+      def get_input message
+        print message
+        $stdin.gets.chomp
+      end
+
+    end
+
+  end
+end

data/lib/branchable_cdn_assets/version.rb

@@ -0,0 +1,3 @@
+module BranchableCDNAssets
+  VERSION = "0.5.0"
+end

data/spec/lib/branchable_cdn_assets/check_before_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe BranchableCDNAssets::CheckBefore do
+
+  class Stub
+    extend BranchableCDNAssets::CheckBefore
+
+    def hello; 'world'; end
+    def filter;   true; end
+  end
+
+  after :each do
+    Stub.remove_instance_variable :@_before_checks
+  end
+
+  describe "::before_checks" do
+    it "returns an array if @_before_checks not set" do
+      expect( Stub.before_checks.is_a?(Array) ).to be_truthy
+    end
+
+    it "returs @_before_checks if set" do
+      Stub.instance_variable_set :@_before_checks, ['hello']
+      expect( Stub.before_checks ).to match_array ['hello']
+    end
+  end
+
+  describe "::check_before" do
+    it "adds hash with params to before_checks" do
+      Stub.check_before :check, {hello: 'world'}
+      expect( Stub.before_checks.first ).to eq check: :check, hello: 'world'
+    end
+  end
+
+  describe "#with_check" do
+
+    it "sends the the called method" do
+      stub = Stub.new
+      expect( stub ).to receive(:hello)
+      stub.with_check( :hello )
+    end
+
+    context "with check defined on method" do
+      before :each do
+        Stub.instance_eval do; check_before :filter, methods: [:hello]; end
+      end
+
+      it "runs included checks" do
+        stub = Stub.new
+        expect( stub ).to receive(:filter)
+        stub.with_check(:hello)
+      end
+
+      it "runs the called method" do
+        stub = Stub.new
+        expect( stub ).to receive(:hello)
+        stub.with_check(:hello)
+      end
+    end
+  end
+
+end

data/spec/lib/branchable_cdn_assets/config_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe BranchableCDNAssets::Config do
+
+  let(:data) do
+    {
+      production_branch: 'production',
+      default_env: 'default',
+      dir: 'cdn_dir',
+      environments: {
+        production: {
+          host: 'production',
+          url:  'http://production.com',
+          root: '/var/www/production'
+        },
+        test: {
+          host: 'test',
+          url:  'http://test.com',
+          root: '/var/www/test'
+        },
+        staging: {
+          host: 'staging',
+          url:  'http://staging.com',
+          root: '/var/www/staging'
+        },
+        default: {
+          host: 'default',
+          url:  'http://default.com',
+          root: '/var/www/default'
+        }
+      },
+      cloudfront: {
+        access_key:   'FooBar',
+        secret_key:   'SecretBaz',
+        distribution: 'Distro',
+        path_prefix:  '/'
+      }
+    }
+  end
+
+  let(:yaml) do
+    "foo: bar\n" +
+    "baz: wu\n"
+  end
+
+  describe "#raw_data" do
+    context "when given a hash" do
+      it "uses hash data as is" do
+        expect( described_class.new( data ).raw_data ).to eq data
+      end
+      it "symbolizes data's keys if they are strings" do
+        expect( described_class.new( {'foo'=>'foo', 'bar' => { 'baz' => 'baz' }} ).raw_data ).to eq foo: 'foo', bar: { baz: 'baz' }
+      end
+    end
+    context "when given a path" do
+      it "reads yaml data in config" do
+        allow(File).to receive(:exists?).with('yaml').and_return(true)
+        allow(IO).to receive(:read).with('yaml').and_return(yaml)
+
+        expect( described_class.new('yaml').raw_data ).to eq foo: 'bar', baz: 'wu'
+      end
+      it "raises exception if file not found" do
+        allow(File).to receive(:exists?).with('yaml').and_return(false)
+
+        expect{
+          described_class.new('yaml')
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "#branch" do
+    it "defaults to the Asgit.current_branch" do
+      allow( Asgit ).to receive(:current_branch).and_return('foo_bar')
+      expect( described_class.new( data ).branch ).to eq 'foo_bar'
+    end
+    it "can be overriden by passing in a branch" do
+      expect( described_class.new( data, 'baz' ).branch ).to eq 'baz'
+    end
+  end
+
+  describe "#production_branch" do
+    it "defaults to 'master' if none is passed" do
+      expect( described_class.new( data.without_key(:production_branch) ).production_branch ).to eq 'master'
+    end
+    it "can be set with data" do
+      expect( described_class.new( data ).production_branch ).to eq 'production'
+    end
+  end
+
+  describe "#cloudfront" do
+    it "is set to the passed value" do
+      expect( described_class.new( data ).cloudfront ).to eq data[:cloudfront]
+    end
+  end
+
+  describe "#cdn_dir" do
+    it "is set to the passed value" do
+      expect( described_class.new( data ).cdn_dir ).to eq 'cdn_dir'
+    end
+
+    it "falls back to 'cdn' if no value is passed" do
+      expect( described_class.new( data.without_key(:dir) ).cdn_dir ).to eq 'cdn'
+    end
+  end
+
+  describe "#env" do
+    context "when the current branch matches production_branch" do
+      before :each do
+        allow( Asgit ).to receive(:current_branch).and_return('production')
+      end
+      it "is :production" do
+        expect( described_class.new( data ).env ).to eq :production
+      end
+    end
+    context "when on a branch with a matching environment key" do
+      before :each do
+        allow( Asgit ).to receive(:current_branch).and_return('test')
+      end
+      it "matchs the current_branch" do
+        expect( described_class.new( data ).env ).to eq :test
+      end
+    end
+    context "when on a branch that doesn't match an env key" do
+      before :each do
+        allow( Asgit ).to receive(:current_branch).and_return('random')
+      end
+      it "sets env to the set default_env" do
+        expect( described_class.new( data ).env ).to eq :default
+      end
+      it "falls back to 'staging' if no default env given" do
+        expect( described_class.new( data.without_key(:default_env) ).env ).to eq :staging
+      end
+    end
+  end
+
+  describe "#environments" do
+    it "returns data namespaced with branch" do
+      production = described_class.new( data, 'production' )
+      default    = described_class.new( data, 'foo_bar' )
+
+      expect( production.root ).to eq '/var/www/production'
+      expect( production.host ).to eq 'production'
+      expect( production.url  ).to eq 'http://production.com'
+
+      expect( default.root ).to eq '/var/www/default/foo_bar/'
+      expect( default.host ).to eq 'default'
+      expect( default.url  ).to eq 'http://default.com/foo_bar'
+    end
+  end
+
+end

data/spec/lib/branchable_cdn_assets/file_manager/find_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe BranchableCDNAssets::FileManager do
+
+  describe "#find" do
+
+    before :each do
+      Given.fixture 'base'
+      Given.file 'cdn/master.manifest', "image_one\nimage_remote_one\n"
+      Given.file 'cdn/staging.manifest', "image_one\nimage_remote_two\n"
+      Given.file 'cdn/image_one', ''
+      Given.file 'cdn/image_two', ''
+    end
+
+    context "when on production branch" do
+      before :each do
+        allow( Asgit ).to receive(:current_branch)
+                      .and_return('master')
+        @manager = described_class.new BranchableCDNAssets::Config.new('config/cdn_assets.yaml')
+      end
+
+      it "returns :local if asset is local" do
+        expect( @manager.find('image_one') ).to eq :local
+      end
+
+      it "returns the production url of the asset" do
+        expect( @manager.find('image_remote_one') ).to eq 'http://production.com/image_remote_one'
+      end
+
+      it "returns nil if asset is missing" do
+        expect( @manager.find('missing') ).to be_nil
+      end
+    end
+
+    context "when on staging branch" do
+      before :each do
+        allow( Asgit ).to receive(:current_branch)
+                      .and_return('staging')
+        @manager = described_class.new BranchableCDNAssets::Config.new('config/cdn_assets.yaml')
+      end
+
+      it "returns :local if asset is local" do
+        expect( @manager.find('image_one') ).to eq :local
+      end
+
+      it "returns namespaced staging url if listed in staging manifest" do
+        expect( @manager.find('image_remote_two') ).to eq 'http://staging.com/staging/image_remote_two'
+      end
+
+      it "returns production url if listed only in production manifest" do
+        expect( @manager.find('image_remote_one') ).to eq 'http://production.com/image_remote_one'
+      end
+
+      it "returns nil if asset is missing" do
+        expect( @manager.find('missing') ).to be_nil
+      end
+    end
+
+  end
+
+end

data/spec/lib/branchable_cdn_assets/file_manager_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+describe BranchableCDNAssets::FileManager do
+
+  before :each do
+    @config_data = {
+      env: 'default',
+      branch: 'branch',
+      cdn_dir: 'cdn',
+      host: 'host',
+      root: 'root',
+      cloudfront: {
+        path_prefix: '/prefix'
+      }
+    }
+    @config = instance_double( "BranchableCDNAssets::Config", @config_data )
+    allow( BranchableCDNAssets::Config ).to receive(:new).and_return( @config )
+
+    @file_list = [
+      'filename_one',
+      'filename_two',
+      'directory/dir_file'
+    ]
+
+    allow( Dir).to receive(:[]).with(anything()).and_call_original
+    allow( Dir).to receive(:[]).with( "#{Dir.pwd}/cdn/**/*" ).and_return( @file_list.map { |f| File.join( Dir.pwd, 'cdn', f ) } )
+
+    @manifest = instance_double("BranchableCDNAssets::Manifest", files: @file_list )
+    allow( BranchableCDNAssets::Manifest ).to receive(:new).and_return( @manifest )
+
+    @cloudfront = instance_double("BranchableCDNAssets::Cloudfront")
+    allow( BranchableCDNAssets::Cloudfront ).to receive(:new).and_return( @cloudfront )
+
+    @tempfile = instance_double( "Tempfile",
+      unlink: nil,
+      path: 'tempfile_path',
+      write: nil,
+      close: nil
+    )
+    allow( Tempfile ).to receive(:new).and_return( @tempfile )
+
+    @success_response = instance_double("HereOrThere::Response",
+      success?: true,
+      stderr: "",
+      stdout: ">f+++++++++ filename_one\n" +
+              ">f+++++++++ filename_two\n" +
+              ">d+++++++++ directory/\n" +
+              ">f+++++++++ directory/dir_file\n"
+    )
+
+    @error_response = instance_double("HereOrThere::Response",
+      success?: false,
+      stderr: "stderr",
+      stdout: ""
+    )
+  end
+
+  describe '#config' do
+    it "returns the provided config" do
+      files = described_class.new( @config )
+      expect( files.config ).to eq @config
+    end
+  end
+
+  describe '#root' do
+    it "returns the provided root from config" do
+      files = described_class.new( @config )
+      expect( files.root ).to eq 'cdn'
+    end
+  end
+
+  describe '#manifest' do
+    it "returns a manifest with the environment manifest path" do
+      expect( BranchableCDNAssets::Manifest ).to receive(:new).with( "cdn/#{@config.branch}.manifest" )
+      files = described_class.new( @config )
+      expect( files.manifest ).to eq @manifest
+    end
+  end
+
+  describe "#branch" do
+    it "is defaults to the config.branch" do
+      expect( described_class.new(@config).branch ).to eq @config.branch
+    end
+    it "can be overriden by passed arg" do
+      expect( described_class.new(@config, 'foo').branch ).to eq 'foo'
+    end
+  end
+
+  describe '#list' do
+
+    let(:remote_files) { ['filename_one', 'remote_one', 'remote_two'] }
+    let(:local_files)  { @file_list }
+
+    before :each do
+      allow( @manifest ).to receive(:files).and_return(remote_files)
+    end
+
+    it "returns remote files when arg is :remote" do
+      expect( described_class.new(@config).list(:remote) ).to match_array remote_files
+    end
+
+    it "returns local files when arg is :local" do
+      expect( described_class.new(@config).list(:local) ).to match_array local_files
+    end
+
+    it "returns both local and remote files when :all" do
+      expect( described_class.new(@config).list() ).to match_array remote_files + local_files
+    end
+
+    it "returns intersecting files whe :both" do
+      expect( described_class.new(@config).list(:both) ).to match_array ['filename_one']
+    end
+
+  end
+
+  describe "#pull!" do
+
+    context "when pull is successful" do
+      before :each do
+        allow( BranchableCDNAssets::Shell ).to receive(:run_local).and_return( @success_response )
+        allow( @manifest ).to receive(:remove_files)
+        allow( @manifest ).to receive(:update_source_file!)
+      end
+
+      it "returns list of pulled files" do
+        expect( described_class.new(@config).pull! ).to match_array @file_list
+      end
+
+      it "removes files & updates manifest" do
+        expect( @manifest ).to receive(:remove_files).with(@file_list)
+        expect( @manifest ).to receive(:update_source_file!)
+        described_class.new(@config).pull!
+      end
+    end
+
+    context "when pull returns error" do
+      it "raises an error" do
+        allow( BranchableCDNAssets::Shell ).to receive(:run_local).and_return( @error_response )
+
+        expect{
+          described_class.new(@config).pull!
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "#push!" do
+
+    before :each do
+      allow( BranchableCDNAssets::Shell ).to receive(:run_remote)
+      allow( BranchableCDNAssets::Shell ).to receive(:run_local).and_return( @success_response )
+      allow( @manifest ).to receive(:merge_files)
+      allow( @manifest ).to receive(:update_source_file!)
+    end
+
+    context "when setup_remote is successful" do
+      before :each do
+        allow( BranchableCDNAssets::Shell ).to receive(:run_remote).with('mkdir -p root', hostname: 'host').and_return(@success_response)
+      end
+
+      it "sets up remote" do
+        expect( BranchableCDNAssets::Shell ).to receive(:run_remote).with('mkdir -p root', hostname: 'host').and_return(@success_response)
+        described_class.new(@config).push!
+      end
+
+      it "returns an array of pushed files" do
+        expect( described_class.new(@config).push! ).to match_array @file_list
+      end
+
+      it "adds files and updates the manifest" do
+        expect( @manifest ).to receive(:merge_files).with(@file_list)
+        expect( @manifest ).to receive(:update_source_file!)
+
+        described_class.new(@config).push!
+      end
+
+      context "when env is production" do
+
+        before :each do
+          allow( @config ).to receive(:env).and_return(:production)
+        end
+
+        it "invalidates intersecting files" do
+          expect( @cloudfront ).to receive(:invalidate_files).with( @file_list.map { |f| "/prefix/#{f}"} )
+          described_class.new(@config).push!
+        end
+      end
+    end
+
+    context "when setup_remote fails" do
+      it "aborts and prints error" do
+        allow( BranchableCDNAssets::Shell ).to receive(:run_remote).and_return( @error_response )
+        expect {
+          described_class.new(@config).push!
+        }.to raise_error
+      end
+    end
+  end
+
+  describe "#prune!" do
+
+    let(:remote_files) { ['filename_one', 'remote_one', 'remote_two'] }
+    let(:local_files)  { @file_list }
+
+    before :each do
+      allow( @manifest ).to receive(:files).and_return(remote_files)
+    end
+
+    context "when confirm removal" do
+      it "removes files that are local and on remote" do
+        expect( BranchableCDNAssets::Shell ).to receive(:run_local).with("rm cdn/filename_one")
+        release_stdin 'y' do
+          described_class.new(@config).prune!
+        end
+      end
+
+      it "removes empty directories" do
+        files = described_class.new(@config)
+        expect( files ).to receive(:remove_empty_directories)
+        release_stdin 'y' do
+          files.prune!
+        end
+      end
+    end
+
+    context "when removal aborted" do
+      it "does not remove files and exits" do
+        expect( BranchableCDNAssets::Shell ).not_to receive(:run_local).with(/rm\s[\w\/\.]+$/)
+
+        expect{
+          release_stdin 'n' do
+            described_class.new(@config).prune!
+          end
+        }.to raise_error SystemExit
+      end
+    end
+  end
+
+  describe "#move_to_production" do
+    before :each do
+      @orig_cdn   = described_class.new(@config)
+      @branch_cdn = instance_double("BranchableCDNAssets::FileManager", manifest: @manifest )
+      allow( BranchableCDNAssets::Shell ).to receive(:run_local).and_return(@success_response)
+      allow( described_class ).to receive(:new).and_call_original
+      allow( @config ).to receive(:raw_data)
+      allow( described_class ).to receive(:new).with( @config ).and_return( @branch_cdn )
+    end
+
+    it "pulls from remote branch & pushes on current branch" do
+      expect( @branch_cdn ).to receive(:pull!).and_return([])
+      expect( @orig_cdn ).to   receive(:push!).and_return([])
+      @orig_cdn.move_to_production('test')
+    end
+  end
+
+end