cany 0.0.1

data/lib/cany/dpkg/deb_helper_recipe.rb

@@ -0,0 +1,28 @@
+module Cany
+  module Dpkg
+    class DebHelperRecipe < Cany::Recipe
+      register_as :deb_helper
+
+      def initialize(*args)
+        super *args
+        @log = File.read('debian/xikolo-account.debhelper.log') if File.exists?  'debian/xikolo-account.debhelper.log'
+        exec 'dh_prep'
+      end
+
+      def clean
+        exec %w(dh clean)
+      end
+
+      def build
+        instance_eval &spec.build if spec.build
+        exec %w(dh build)
+      end
+
+      def binary
+        instance_eval &spec.binary if spec.binary
+        File.write('debian/xikolo-account.debhelper.log', @log)
+        exec %w(dh binary)
+      end
+    end
+  end
+end

data/lib/cany/recipe.rb

@@ -0,0 +1,128 @@
+require 'fileutils'
+
+module Cany
+  class Recipe
+
+    # @api public
+    # This method should be call in subclasses to register new recipe instances. Cany ignores any
+    # recipe subclasses which does not call register_as. If multiple recipes register on the same
+    # name the later one will overwrite the earlier one and therefore used by Cany.
+    # @param [Symbol] name A ruby symbol as name for the recipe. It should be short and recognizable
+    def self.register_as(name)
+      @@recipes ||= {}
+      @@recipes[name] = self
+    end
+
+    # @api public
+    # Looks for the class registered for the given name
+    # @param [Symbol] name the name the class is search for
+    # @return [Cany::Recipe, nil] Returns the found class or nil if no class is registered on this
+    #  name
+    def self.from_name(name)
+      @@recipes[name]
+    end
+
+    # Creates a new instance of this recipe
+    # @param [Cany::Specification] spec Specification object
+    # @param [Cany::Recipe, nil] inner Inner recipes should should be call between the pre and post
+    #  actions of this class. Nil means most inner recipes.
+    def initialize(spec, inner)
+      @spec = spec
+      @inner = inner
+    end
+
+    attr_reader :spec, :inner
+
+    # API to use inside the recipe
+    ##############################
+
+    # @api public
+    # Run a command inside the build directory. In most cases it is not needed to call this method
+    # directly. Look at the other helper methods.
+    #
+    # The method expects as arguments the program name and additional parameters for the program.
+    # The arguments can be group with arguments, but must not:
+    # @example
+    #   exec 'echo', %w(a b)
+    #   exec ['echo', 'a', 'b']
+    #   exec 'echo', 'a', 'b'
+    def exec(*args)
+      puts "   #{args.flatten.join(' ')}"
+      system *args.flatten
+    end
+
+    # @api public
+    # Run a ruby task (like gem, bundler, rake ...)
+    #
+    # The method expects as arguments the program name and additional parameters for the program.
+    # See exec for more examples
+    def ruby_bin(*args)
+      exec 'ruby', '-S', *args
+    end
+
+    # @api public
+    # Install files or directory from the build directory
+    # @param [String] source The relative file name to a filename or directory inside the build
+    #   directory that should be installed/copied into the destination package
+    # @param [String] destination The diretory name into that the file or directory should be
+    #   installed
+    def install(src, dest_dir)
+      exec 'dh_install', src, dest_dir
+    end
+
+    # @api public
+    # Install a file. The content is passed as argument. This method is designed to be used by
+    # recipes to create files dynamically.
+    # @param [String] filename The absolute file name for the file inside the package.
+    # @param [String] content The file content
+    def install_content(filename, content)
+      FileUtils.mkdir_p File.dirname File.join('debian', spec.name, filename)
+      File.open File.join('debian', spec.name, filename), 'w' do |f|
+        f.write content
+      end
+    end
+
+    # @api public
+    # Installs/creates an empty directory
+    # @param [String] path The path name
+    def install_dir(path)
+      exec 'dh_installdirs', path
+    end
+
+    # @api public
+    # Create a file named destination as a link to a file named source
+    def install_link(source, destination)
+      exec 'dh_link', source, destination
+    end
+
+    # @api public
+    # Ensure that the given files or directories are no present. Directories are removed
+    # recursively.
+    def rmtree(*args)
+      args.flatten.each do |path|
+        ::FileUtils.remove_entry path if File.exists? path
+      end
+    end
+
+    # default implementation:
+    #########################
+
+    # @api public
+    # clean the build directory from all temporary and created files
+    def clean
+      inner.clean
+    end
+
+    # @api public
+    # build the program (means ./configure and make)
+    def build
+      inner.build
+    end
+
+    # @api public
+    # create binary (package) version of this file (means make install)
+    def binary
+      inner.binary
+    end
+  end
+end

data/lib/cany/recipes/bundler.rb

@@ -0,0 +1,33 @@
+module Cany
+  module Recipes
+    class Bundler < Cany::Recipe
+      register_as :bundler
+
+      def clean
+        rmtree 'bundler'
+        # rmtree 'vendor/bundle' -- do not remove gems, increase testing time
+        inner.clean
+      end
+
+      def build
+        ENV['GEM_PATH'] = 'bundler'
+        ENV['PATH'] = 'bundler/bin:' + ENV['PATH']
+        ruby_bin 'gem', %w(install bundler --no-ri --no-rdoc --install-dir bundler --bindir bundler/bin)
+        ruby_bin 'bundle', %w(install --deployment --without development test)
+        inner.build
+      end
+
+      def binary
+        install 'bundler', "/usr/share/#{spec.name}"
+        install '.bundle', "/usr/share/#{spec.name}"
+        install 'vendor/bundle', "/usr/share/#{spec.name}/vendor"
+        install_content "/usr/bin/#{spec.name}", "#!/bin/sh
+cd /usr/share/#{spec.name}
+export GEM_PATH=/usr/share/#{spec.name}/bundler
+exec /usr/share/#{spec.name}/bundler/bin/bundle exec \"$@\"
+"
+        inner.binary
+      end
+    end
+  end
+end

data/lib/cany/recipes/rails.rb

@@ -0,0 +1,37 @@
+module Cany
+  module Recipes
+    class Rails < Recipe
+      register_as :rails
+
+      def clean
+        rmtree 'tmp', 'public/assets'
+        inner.clean
+      end
+
+      def build
+        ruby_bin 'rake', 'assets:precompile'
+        inner.build
+      end
+
+      def binary
+        %w(app config.ru db Gemfile Gemfile.lock lib public Rakefile vendor).each do |item|
+          install item, "/usr/share/#{spec.name}" if File.exists? item
+        end
+
+        Dir.foreach('config') do |entry|
+          next if %w(. ..).include? entry
+          install File.join('config', entry), "/etc/#{spec.name}"
+        end
+        install_link "/etc/#{spec.name}", "/usr/share/#{spec.name}/config"
+
+        install_dir "/etc/#{spec.name}"
+        install_dir "/var/tmp/#{spec.name}"
+        install_dir "/var/log/#{spec.name}"
+
+        install_link "/var/log/#{spec.name}", "/usr/share/#{spec.name}/log"
+        install_link "/var/tmp/#{spec.name}", "/usr/share/#{spec.name}/tmp"
+        inner.binary
+      end
+    end
+  end
+end

data/lib/cany/recipes/thin.rb

@@ -0,0 +1,25 @@
+require 'yaml'
+
+module Cany
+  module Recipes
+    # This recipes runs the application with the thin web server. At the moment it installs only a
+    # upstart start script. Other init scripts are planed (e.g. systemd for debian).
+    class Thin < WebServer
+      register_as :thin
+
+      def launch_command
+        "thin start -C /etc/#{spec.name}/thin.yml"
+      end
+
+      def binary
+        default_options = {
+            'environment' => 'production',
+            'socket' => "/var/run/#{spec.name}/sock",
+            'pid' => "/var/run/#{spec.name}/thin.pid"
+        }
+        install_content "/etc/#{spec.name}/thin.yml", default_options.to_yaml
+        super
+      end
+    end
+  end
+end

data/lib/cany/recipes/web_server.rb

@@ -0,0 +1,28 @@
+module Cany
+  module Recipes
+    class WebServer < Recipe
+      def binary
+        File.open File.join('debian', "#{spec.name}.upstart"), 'w' do |f|
+          f.write "description  \"#{spec.description}\"\n"
+
+          f.write "start on filesystem or runlevel [2345]\n"
+          f.write "stop on runlevel [!2345]\n"
+
+          f.write "respawn\n"
+          f.write "respawn limit 10 5\n"
+          f.write "umask 022\n"
+
+          f.write "chdir /usr/share/#{spec.name}\n"
+
+          f.write "pre-start script\n"
+          f.write "\tmkdir -p /var/run/#{spec.name}\n"
+          f.write "\tchown www-data /var/run/#{spec.name}\n"
+          f.write "end script\n"
+
+          f.write "exec su www-data --shell /usr/bin/#{spec.name} -- #{launch_command}\n"
+        end
+        inner.binary
+      end
+    end
+  end
+end

data/lib/cany/specification.rb

@@ -0,0 +1,21 @@
+module Cany
+
+  require 'cany/specification/dsl'
+
+  class Specification
+    EXT = 'canspec'
+
+    attr_accessor :name, :description, :maintainer_name, :maintainer_email, :website, :licence, :version
+    attr_accessor :base_dir, :recipes
+    attr_accessor :build, :binary
+
+    def initialize(dsl=Cany::Specification::DSL, &block)
+      @recipes = []
+      setup dsl, &block
+    end
+
+    def setup(dsl=Cany::Specification::DSL, &block)
+      dsl.new(self).exec(&block)
+    end
+  end
+end

data/lib/cany/specification/dsl.rb

@@ -0,0 +1,39 @@
+module Cany
+  class Specification
+    class DSL
+      def initialize(specification)
+        @specification = specification
+      end
+
+      def exec(&block)
+        instance_eval &block
+      end
+
+      def self.delegate(*methods)
+        methods.each do |method|
+          module_eval(<<-EOS, __FILE__, __LINE__)
+            def #{method}(*args, &block)
+              @specification.send :'#{method}=', *args, &block
+            end
+            EOS
+        end
+      end
+
+      delegate :name, :description, :maintainer_name, :maintainer_email, :website, :licence, :version
+
+      # This include the given recipe into the build process.
+      # @param [Symbol] name The name of the recipe as symbol.
+      def use(name)
+        @specification.recipes << name
+      end
+
+      def build(&block)
+        @specification.build = block
+      end
+
+      def binary(&block)
+        @specification.binary = block
+      end
+    end
+  end
+end

data/lib/cany/version.rb

@@ -0,0 +1,10 @@
+module Cany
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+    STAGE = nil
+    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
+    def self.to_s; STRING end
+  end
+end

data/spec/cany/specification_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Cany::Specification do
+  describe '#new' do
+    it 'should have a name' do
+      spec = Cany::Specification.new do
+        name 'example'
+      end
+      expect(spec.name).to eq 'example'
+    end
+
+    it 'should have a description' do
+      spec = Cany::Specification.new do
+        description 'Test hans otto project'
+      end
+      expect(spec.description).to eq 'Test hans otto project'
+    end
+
+    it 'should have a maintainer name' do
+      spec = Cany::Specification.new do
+        maintainer_name 'Otto Hans'
+      end
+      expect(spec.maintainer_name).to eq 'Otto Hans'
+    end
+
+    it 'should have a maintainer email' do
+      spec = Cany::Specification.new do
+        maintainer_email 'hans.otto@example.org'
+      end
+      expect(spec.maintainer_email).to eq 'hans.otto@example.org'
+    end
+
+    it 'should have a website' do
+      spec = Cany::Specification.new do
+        website 'http://example.org/~hans.otto/'
+      end
+      expect(spec.website).to eq 'http://example.org/~hans.otto/'
+    end
+
+    it 'should have a licence' do
+      spec = Cany::Specification.new do
+        licence 'MIT'
+      end
+      expect(spec.licence).to eq 'MIT'
+    end
+
+    it 'should have a version' do
+      spec = Cany::Specification.new do
+        version '0.1'
+      end
+      expect(spec.version).to eq '0.1'
+    end
+
+    it 'should be able to include recipes' do
+      spec = Cany::Specification.new do
+        use :bundler
+      end
+      expect(spec.recipes).to eq [:bundler]
+    end
+
+    it 'should accept a block for own build steps' do
+      spec = Cany::Specification.new do
+        build do
+          install 'hans', 'otto'
+        end
+      end
+      expect(spec.build).to be_a_kind_of Proc
+    end
+
+    it 'should accept a block for own build steps' do
+      spec = Cany::Specification.new do
+        binary do
+          install 'hans', 'otto'
+        end
+      end
+      expect(spec.binary).to be_a_kind_of Proc
+    end
+  end
+end

data/spec/cany_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Cany do
+  context '#setup' do
+    it 'should require a .canspec file' do
+      expect { Cany::setup File.expand_path('../fixtures/empty', __FILE__) }.to raise_error(Cany::MissingSpecification)
+    end
+  end
+
+  it 'should stop on multiple .canspec files' do
+    expect { Cany::setup File.expand_path('../fixtures/multiple', __FILE__) }.to raise_error Cany::MultipleSpecifications, /Multiple canspec found in .*/
+  end
+
+  it 'should load a .canspec file' do
+    spec = Cany::setup File.expand_path('../fixtures/single', __FILE__)
+    expect(spec).to be_an_instance_of Cany::Specification
+    expect(spec.name).to eq 'single-test'
+    expect(spec.base_dir).to eq File.expand_path('../fixtures/single', __FILE__)
+  end
+end