cany 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 575282993ba4ffbbf4a1f932a57658c6d570965e
+  data.tar.gz: 8bcf88c7b8cf69da3108189061c06229f15b739e
+SHA512:
+  metadata.gz: 10d981813625901b4618e2d15679c0b898f064964f2780c8bbc6f2e2c1cadc9cbabdccfd5c138dd6d5c90183a5bfc8cca2d265465fc22c45c5f08a7c86aeffa9
+  data.tar.gz: da1ad37fd1fff55b7d7f0f9fa51840038bd44c5c0f4a57f0fb34bc0fc6b897b5a1414010857e0eddf01ac7d12230e88308a04dadea4e94764d25944e993cb309

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.iml
+.idea
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+tmp
+

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cany.gemspec
+gemspec
+
+group :test do
+  gem 'deb_control', '~> 0.0.1'
+  gem 'timecop'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Malte Swart
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# Cany
+
+Cany is a toolkit to create easily distribution packages from your (ruby) application. The goal is to reduce the packaging work to managing the application meta data (specification).
+
+The goal is to support all (common) package manager - all from the some specification, although at the moment is only dpkg implemented.
+
+The difference to other packaging tools is that cany uses as much tools as possible to build packages in the recommended way.
+
+**Warning:** The gem has successfully built packages. But there are known limitations or problems. We collecting knowledge with the current usage and appreciate your feedback. With the 1.0 we will start with semantic visioning. Until then every updates tries to be as much compatible as possible but the more important goal is to create a better architecture and design -- so be careful when updating this gem.
+
+
+## Installation
+
+Cany is a rubygem, it needs **ruby >=1.9.3** to work. It is design to be lightweight, therefore a:
+
+    $ gem install cany
+
+is enough to install and use it. But you can add is also to your application's Gemfile:
+
+```ruby
+gem 'cany'
+```
+
+And then execute:
+
+    $ bundle
+
+To let bundle install it for you.
+
+
+## Write a Specification for your Application
+
+Create a file ``<your application name>.canspec`` inside your application folder:
+
+```ruby
+Cany::Specification.new do
+  name 'example-application' # This is used as package name - please you only ASCII letters, - and literals.
+  version '0.1' # Your application's version
+  description 'This example application is used to have a application for that this README can describe how it is packaged with cany' # A short description for you application. Should not longer than a few paragraphs
+  maintainer_name 'Hans Otto' # The person/organisation maintaining the package
+  maintainer_email 'hans.otto@example.org' # A eMail address to contact the maintainer
+  website 'http://example.org/cany' # A website to get more information about the application
+  licence 'MIT' # Your Licence
+
+  # Use common build tasks to build your application - describing how your application needs to be build
+  # The ordering is important, see the recipes documentation for more information about the recipes itself and there recommended ordering
+  use :bundler
+  use :rails
+end
+```
+
+
+## Recipes
+
+Cany uses different recipes to share different packaging tasks above multiple applications.
+
+### Bundler
+
+All common applications need a bunch of gems. Bundle is the common tool to manage these gems. Because for most of the gems there exists no packages, we decide that the best approach is to ship the installed gems with the application.
+
+This recipe is designed to use as first one. The installs bundler and uses the ``Gemfile.lock`` to install the referenced gems to ``vendor/bundle``.
+
+### Rails
+
+This recipe is used to install a ruby on rails application. The recipes installs the different files/directories.
+
+### Thin
+
+This recipe configures thin and install an init script to launch the application. It assumes that ``thin`` is listed in your Gemfile.
+
+
+### Own Adjustments
+
+There are applications were the known recipes are not sufficient to build it. You can define blocks inside the canspec that are runs like normal recipes and allow you to do specific tasks.
+
+The following example installs an additional folder (of an Ruby on Rails applications):
+
+```ruby
+Cany::Sepcification.new do
+  # meta data and recipe loading
+  binary do
+    install 'additional_subdir', "/usr/share/#{spec.name}"
+  end
+end
+```
+
+Take a look at the ``Recipe`` class for helper you can use.
+
+
+## Use Your Specification to Create Packages
+
+### dpkg
+
+To create dpkg packages (used by debian and its derivatives) run from your application directory with your canspec:
+
+    $ cany dpkg-create
+
+It creates a debian subdirectory containing all needed files/information to build a dpkg package in the debian way. To create the package itself cany relies on the debian packaging tools. The build your package without signing the created files with GPG run
+
+    $ dpkg-buildpackage -us -uc
+
+Afterwards you should have ``*.deb`` package in the directory containing your application directory.
+
+
+## Contributing
+
+If you have problems create an issue. Feedback is also welcome - you can write me on email or contact me on freenode (@mswart).
+
+If you have a change which should be included into cany:
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/cany

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+#require 'bundler/setup'
+
+require 'cany'
+require 'cany/dpkg/creator'
+require 'cany/dpkg/builder'
+
+tasks = {
+  'dpkg-create' => Cany::Dpkg::Creator,
+  'dpkg-builder' => Cany::Dpkg::Builder
+}
+
+unless tasks.include? ARGV.first
+  puts 'Unknown subaction - choose from ' + tasks.keys.join(', ')
+  exit 1
+end
+
+tasks[ARGV.shift].new(Cany::setup '.').run *ARGV

data/cany.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cany/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cany'
+  spec.version       = Cany::VERSION
+  spec.authors       = ['Malte Swart']
+  spec.email         = %w(mswart@devtation.de)
+  spec.description   = %q{Canning your ruby applications}
+  spec.summary       = %q{Canning your ruby applications}
+  spec.homepage      = 'https://github.com/mswart/cany'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/cany.rb

@@ -0,0 +1,29 @@
+require 'cany/version'
+require 'cany/specification'
+require 'cany/recipe'
+require 'cany/recipes/bundler'
+require 'cany/recipes/rails'
+require 'cany/recipes/web_server'
+require 'cany/recipes/thin'
+require 'cany/dpkg'
+require 'cany/dpkg/creator'
+require 'cany/dpkg/builder'
+require 'cany/dpkg/deb_helper_recipe'
+
+module Cany
+  class MissingSpecification < Exception
+  end
+
+  class MultipleSpecifications < Exception
+  end
+
+  def self.setup(directory='.')
+    specs = Dir[directory + '/*.' + Specification::EXT]
+    raise MissingSpecification, "No #{Specification::EXT} found in #{directory}" if specs.size == 0
+    raise MultipleSpecifications, "Multiple #{Specification::EXT} found in #{directory}" if specs.size > 1
+    file = specs.first
+    spec = eval File::read(file), binding, file
+    spec.base_dir = directory
+    spec
+  end
+end

data/lib/cany/dpkg.rb

@@ -0,0 +1,4 @@
+module Cany
+  module Dpkg
+  end
+end

data/lib/cany/dpkg/builder.rb

@@ -0,0 +1,37 @@
+module Cany
+  module Dpkg
+    # This class does the real job. It is called for every dpkg build step to build the package.
+    # An instance is created on every execution. The package specification is passed as option to
+    # the initializer. Afterwards the run method is called to execute the wanted build step. The
+    # first parameter specifies the build step name (clean, build, binary).
+    # This method uses recipes instances to do the job itself.
+    class Builder
+      attr_reader :spec
+      def initialize(spec)
+        @spec = spec
+      end
+
+      def debian(*args)
+        File.join spec.base_dir, 'debian', *args
+      end
+
+      # This method is called to do the actual work
+      # @api public
+      # @param [String] build_step_name The name of the dpkg build step (clean, build, binary)
+      def run(build_step_name)
+        setup_recipes
+        @recipes.first.send build_step_name.to_s
+      end
+
+      # @api private
+      # This method creates recipe instances for all required recipes from the given spec.
+      def setup_recipes
+        @recipes = []
+        @recipes << DebHelperRecipe.new(spec, nil)
+        spec.recipes.reverse.each do |name|
+          @recipes.unshift Recipe.from_name(name).new(spec, @recipes.first)
+        end
+      end
+    end
+  end
+end

data/lib/cany/dpkg/creator.rb

@@ -0,0 +1,145 @@
+require 'optparse'
+
+module Cany
+  module Dpkg
+    class Creator
+      attr_reader :spec
+      def initialize(spec)
+        @spec = spec
+        @options = {}
+      end
+
+      def debian(*args)
+        File.join spec.base_dir, 'debian', *args
+      end
+
+      def ruby_exe
+        @options[:ruby_exe] || 'ruby'
+      end
+
+      def ruby_deb
+        @options[:ruby_deb] || 'ruby'
+      end
+
+      def parse_opts(*args)
+        @options = {}
+
+        OptionParser.new do|opts|
+          opts.on('--ruby-exe RUBY_EXE', 'Choose the ruby interpreter name (default is ruby)') do |exe|
+            @options[:ruby_exe] = exe
+          end
+
+          opts.on('--ruby-deb RUBY_DEB', 'Choose the ruby package name (default is ruby)') do |deb|
+            @options[:ruby_deb] = deb
+          end
+
+          opts.on('-r', '--ruby RUBY_EXE_DEB', 'Set ruby interpreter and package name') do |name|
+            @options[:ruby_exe] = name
+            @options[:ruby_deb] = name
+          end
+
+          opts.on('-h', '--help', 'Display this screen') do
+            puts opts
+            exit
+          end
+        end.parse *args
+      end
+
+      def run(*args)
+        parse_opts *args
+
+        Dir.mkdir debian
+        create_compact
+        create_source_format
+        create_source_control
+        create_copyright
+        create_rules
+        create_changelog
+      end
+
+      def create_source_format
+        Dir.mkdir debian 'source'
+        File.open(debian('source', 'format'), 'w') { |f| f.write '3.0 (native)' }
+      end
+
+      def create_compact
+        File.open debian('compat'), 'w' do |f|
+          f.write '8'
+        end
+      end
+
+      def create_source_control
+        require 'bundler'
+        lock_path = File.join(spec.base_dir, 'Gemfile.lock')
+        extra_libs = {
+            pg: ['libpq-dev', 'libpq5']
+        }
+        src_deps = ['debhelper (>= 7.0.50~)', ruby_deb, ruby_deb + '-dev']
+        bin_deps = ['${shlibs:Depends}', '${misc:Depends}', ruby_deb]
+        if File.exists? lock_path
+          lock = Bundler::LockfileParser.new File.read lock_path
+          lock.specs.each do |spec|
+            if extra_libs.has_key? spec.name.to_sym
+              src, bin = extra_libs[spec.name.to_sym]
+              src_deps << src
+              bin_deps << bin
+            end
+          end
+        end
+        File.open debian('control'), 'w' do |f|
+          # write source package fields:
+          f.write("Source: #{spec.name}\n")
+          f.write("Section: ruby\n")
+          f.write("Priority: optional\n")
+          f.write("Maintainer: #{spec.maintainer_name} <#{spec.maintainer_email}>\n")
+          f.write("Standards-Version: 3.9.2\n")
+          f.write("Homepage: #{spec.website}\n")
+          f.write("Build-Depends: #{src_deps.join(', ')}\n")
+
+          # write binary package fields:
+          f.write("\n")
+          f.write("Package: #{spec.name}\n")
+          f.write("Architecture: any\n")
+          f.write("Depends: #{bin_deps.join(', ')}\n")
+          f.write("Description: #{spec.description}\n")
+        end
+      end
+
+      def create_copyright
+        File.open debian('copyright'), 'w' do |f|
+          f.write("Format: http://dep.debian.net/deps/dep5\n")
+          f.write("Upstream-Name: #{spec.name}\n\n")
+
+          f.write("Files: *\n")
+          f.write("Copyright: #{Time.now.year} #{spec.maintainer_name}\n")
+          f.write("Licence: #{spec.licence}\n  [LICENCE TEXT]\n")
+        end
+      end
+
+      def create_rules
+        File.open debian('rules'), 'w' do |f|
+          f.write("#!/usr/bin/make -f\n")
+          f.write("export PATH := debian/bin:${PATH}\n")
+          f.write("export GEM_PATH := debian/gems:${GEM_PATH}\n")
+          # call cany for every target:
+          f.write("%:\n")
+          f.write("\t#{ruby_exe} -cS cany >/dev/null || #{ruby_exe} -S gem install --no-ri --no-rdoc --install-dir debian/gems --bindir debian/bin $${CANY_GEM:-cany}\n")
+          f.write("\t#{ruby_exe} -S cany dpkg-builder $@\n")
+          f.write("\noverride_dh_prep:\n")
+
+          f.chmod(0755)
+        end
+      end
+
+      def create_changelog
+        File.open debian('changelog'), 'w' do |f|
+          f.write "#{spec.name} (#{spec.version}-1) unstable; urgency=low\n"
+          f.write "\n"
+          f.write "  * Build with cany\n"
+          f.write "\n"
+          f.write " -- #{spec.maintainer_name} <#{spec.maintainer_email}>  #{Time.now.strftime "%a, %d %b %Y %H:%M:%S %z" }"
+        end
+      end
+    end
+  end
+end