melai 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock
+.rvmrc
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in melai.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Mike Fiedler
+
+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,67 @@
+# Melai
+
+Melai is a command-line tool to create software package repositories for
+APT and YUM package management tools.
+
+## Installation
+This tool is a standalone tool, and should be installed wither via RubyGems:
+
+    $ gem install melai
+
+If you'd rather install dependencies and install from source:
+
+    $ bundle install && rake install
+
+## Usage
+
+### Requirements
+Some prerequisites are needed, and exist currently on Debian/Ubuntu based distros.
+
+* `apt-ftparchive` (Debian-style packages) - `sudo apt-get install apt-utils`
+* `createrepo` (RedHat-style packages) - `sudo apt-get install createrepo`
+
+Both of these external tools are needed to build the required repo metadata.
+
+NOTE: This process cannot be run on RedHat/CentOS yet - as they do not have the
+tools to work with Debian-style packages.
+
+## Execution
+
+An example:
+
+    melai -r newrepo create -p sourcepackages -u "http://mypackageserver.com/myrepo"
+
+Another way is to initialize a config, and use that:
+
+    melai -r newrepo initconfig
+
+This will create a file named `~/.melai.rc`. Edit it to contain your values:
+
+    ---
+    :help: false
+    :r: newrepo
+    :repos-path: newrepo
+    commands:
+      :create:
+        :pkgs-path: sourcepackages
+        :url-root: "http://mypackageserver.com/myrepo"
+      :list: {}
+      :destroy: {}
+      :p: tmpfoo
+      :pkgs-path: tmpfoo
+      :u: "http://mypackageserver.com/myrepo"
+      :url-root: "http://mypackageserver.com/myrepo"
+    :list: {}
+    :destroy: {}
+
+Then you can run `melai create` with no arguments.
+See [here](https://github.com/davetron5000/gli/wiki/Config) for more details.
+
+## Contributing
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Test your changes (`rake test`)
+1. Commit your changes (`git commit -am 'Added some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create new Pull Request

data/Rakefile

@@ -0,0 +1,44 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+task :default => [:install, :test]
+
+desc "Run tests"
+task :test => [:features, :tailor]
+
+Cucumber::Rake::Task.new(:features) do |t|
+  # t.cucumber_opts = ['--format pretty -x']
+
+  t.cucumber_opts = ['--format', 'progress', '-x']
+  t.cucumber_opts += ['features']
+    
+  # This turns on the GLI debugging backtraces
+  t.cucumber_opts += ['GLI_DEBUG=true']
+end
+
+# https://github.com/turboladen/tailor
+require 'tailor/rake_task'
+Tailor::RakeTask.new do |task|
+  task.file_set('lib/**/*.rb', 'code') do |style|
+    style.max_line_length 100, level: :warn
+    style.max_code_lines_in_method 50, level: :warn
+  end
+  task.file_set('bin/*', 'binaries') do |style|
+    style.max_line_length 100, level: :warn
+  end
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md","lib/**/*.rb","bin/**/*")
+  rd.title = 'melai'
+end
+
+# File lib/tasks/notes.rake
+desc "Find notes in code"
+task :notes do
+  puts `grep --exclude=Rakefile -r 'OPTIMIZE:\\|FIXME:\\|TODO:' .`
+end

data/bin/melai

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# $: << File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../lib')
+# require 'rubygems'
+
+require 'gli'
+require_relative '../lib/melai'
+
+include GLI
+
+program_desc "Describe your application here"
+
+version Melai::VERSION
+
+# desc "Describe some switch here"
+# switch [:s, :switch]
+
+desc "Root directory for repositories, relative to current directory"
+default_value "repo"
+arg_name "REPOS_PATH"
+flag [:r, "repos-path"]
+
+# https://github.com/davetron5000/gli/wiki/Config
+config_file '.melai.rc'
+
+desc "Create a repository structure"
+command :create do |c|
+  # TODO: add a force option to rebuild from scratch
+
+  c.desc "Source directory containing all packages, relative to current directory"
+  c.default_value "srcpkgs"
+  c.arg_name "PKGS_PATH"
+  c.flag [:p, "pkgs-path"]
+
+  c.desc "FQDN of the web server, must include http:// and desired docroot"
+  c.default_value "http://somewhere.com/repo"
+  c.arg_name "URL_ROOT"
+  c.flag [:u, "url-root"]
+
+  c.action do |global_options, options, args|
+    repositories_path = File.absolute_path(global_options[:r])
+    packages_path = File.absolute_path(options[:p])
+    url_root = options[:u]
+    $melai.create(repositories_path, packages_path, url_root)
+  end
+end
+
+desc "List all packages in a directory"
+command :list  do |c|
+
+  c.desc "Source directory containing all packages"
+  c.default_value "srcpkgs"
+  c.arg_name "PKGS_PATH"
+  c.flag [:p, "pkgs-path"]
+
+  c.action do |global_options, options, args|
+    puts $melai.list(options[:p])
+  end
+end
+
+desc "Destroy the repository directory completely"
+command :destroy do |c|
+  c.action do |global_options, options, args|
+    # TODO: Add a --force option
+    # TODO: Add a "Are you sure? (y/n)" prompt
+    $melai.destroy(global_options[:r])
+  end
+end
+
+
+pre do |global, command, options, args|
+  # Pre logic here
+  # Return true to proceed; false to abort and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  # true
+  $melai = Melai::CommandHandler.new
+  # TODO: Why do I have to extend the CommandHandler class? Inclusion?
+  $melai.extend(Melai::DirHelpers)
+  $melai.extend(Melai::PackageHelpers)
+  $melai.extend(Melai::StringHelpers)
+end
+
+post do |global, command, options, args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit GLI.run(ARGV)
+
+
+# module Melai
+#   cmd_line = CommandLine.new(ARGV)
+#   # review, status = Linter.check(cmd_line)
+#   # printer = cmd_line.show_context? ? ContextOutput.new : SummaryOutput.new
+#   # printer.output(review)
+#   exit status.to_i
+# end
+# 
+# 
+# 

data/features/directories.feature

@@ -0,0 +1,26 @@
+Feature: Set up the repository directory
+    In order to increase the amount of confidence in repeatable package repositories,
+    As an operator
+    I want to set up all the directories I need
+
+Scenario: Listing an empty source directory returns no files
+    Given a directory named "emptysrcpkgs"
+    When I successfully run `melai list -p emptysrcpkgs`
+    Then the output should contain exactly ""
+
+Scenario: List all package files in a source directory
+    Given a directory named "srcpkgs"
+    And an empty file named "srcpkgs/example-1.0.deb"
+    And an empty file named "srcpkgs/example-1.0.rpm"
+    When I successfully run `melai list -p srcpkgs`
+    Then the output should contain:
+        """
+        srcpkgs/example-1.0.deb
+        srcpkgs/example-1.0.rpm
+        """
+
+# Final step, cleans up
+Scenario: A repository directory exists and I want to destroy it
+    Given a directory named "repo"
+    When I successfully run `melai -r repo destroy`
+    Then a directory named "repo" should not exist

data/features/repository.feature

@@ -0,0 +1,45 @@
+Feature: Create repositories from files
+    In order provide packages to end users,
+    As an operator
+    I want to create multiple repositories from a set of files
+
+Background:
+    Given I double `apt-ftparchive` with exit status 0
+    And I double `createrepo` with exit status 0
+
+Scenario: Create a repository for source packages in a semi-flat directory
+    Given an empty file named "srcpkgs/foo-1.0.0.i686.rpm"
+    And an empty file named "srcpkgs/foo-1.0.0.i386.deb"
+    And an empty file named "srcpkgs/ubuntu/foo-1.0.0-bar.i386.deb"
+    When I successfully run `melai -r repo create -p srcpkgs`
+    Then a directory named "repo/redhat/1.0/i686/RPMS" should exist
+    And a directory named "repo/redhat/os/i686/RPMS" should exist
+    And a directory named "repo/debian-sysvinit/dists/dist/10gen/binary-i386" should exist
+    And a directory named "repo/ubuntu-upstart/dists/dist/10gen/binary-i386" should exist
+
+Scenario Outline: Create a repository directory structure for a given file
+    Given a directory named "repo" does not exist
+    And an empty file named <SrcFile>
+    When I successfully run `melai -r repo create -p srcpkgs`
+    Then a directory named <RepoDir> should exist
+    Examples:
+        | SrcFile                                                             | RepoDir                                              |
+        | "srcpkgs/redhat/foo-2.0.0.i686.rpm"                                 | "repo/redhat/os/i686/RPMS"                           |
+        | "srcpkgs/redhat/foo-2.0.1.i686.rpm"                                 | "repo/redhat/2.0/i686/RPMS"                          |
+        | "srcpkgs/redhat/foo-2.0.2.x86_64.rpm"                               | "repo/redhat/2.0/x86_64/RPMS"                        |
+        | "srcpkgs/debian/foo-2.0.0.i386.deb"                                 | "repo/debian-sysvinit/dists/dist/10gen/binary-i386/" |
+        | "srcpkgs/redhat/os/i686/RPMS/bar-server-2.0.6-version_1.i686.rpm"   | "repo/redhat/os/i686/RPMS/"                          |
+        | "srcpkgs/redhat/os/i686/RPMS/bar-unstable-2.1.0-version_1.i686.rpm" | "repo/redhat/2.1/i686/RPMS/"                         |
+        | "srcpkgs/redhat/os/i686/RPMS/bar18-server-1.8.5-version_1.i686.rpm" | "repo/redhat/1.8/i686/RPMS/"                         |
+        | "srcpkgs/redhat/os/i686/RPMS/bar-2.0.6-version_1.i686.rpm"          | "repo/redhat/2.0/i686/RPMS/"                         |
+
+Scenario Outline: Create a repository file
+    Given a directory named "repo" does not exist
+    And an empty file named <SrcFile>
+    When I successfully run `melai -r repo create -p srcpkgs`
+    Then a file named <RepoTemplate> should exist
+    Examples:
+        | SrcFile                                                             | RepoTemplate                                                   |
+        | "srcpkgs/redhat/foo-2.0.0.i686.rpm"                                 | "repo/redhat/os/i686/RPMS/10gen.repo"                          |
+        | "srcpkgs/debian/foo-2.0.0.i386.deb"                                 | "repo/debian-sysvinit/dists/dist/10gen/binary-i386/10gen.list" |
+        | "srcpkgs/ubuntu/foo-2.0.0.i386.deb"                                 | "repo/ubuntu-upstart/dists/dist/10gen/binary-i386/10gen.list"  |

data/features/step_definitions/directories_steps.rb

@@ -0,0 +1,5 @@
+# It doesn't look lik there is currently a defined method in aruba for 
+# directories that should not exist. 
+Given /^a directory named "([^"]*)" does not exist$/ do |directory|
+  check_directory_presence([directory], false)
+end

data/features/support/env.rb

@@ -0,0 +1,15 @@
+# Set up the environment for testing
+require 'aruba/cucumber'
+require 'aruba-doubles/cucumber'
+
+Before do
+  @aruba_timeout_seconds = 5
+  # @dirs = ["tmp/aruba"]
+end
+
+After do |s| 
+  # Tell Cucumber to quit after this scenario is done - if it failed.
+  # This is useful to inspect the 'tmp/aruba' directory before any other
+  # steps are executed and clear it out.
+  Cucumber.wants_to_quit = true if s.failed?
+end

data/lib/melai.rb

@@ -0,0 +1,80 @@
+# require 'rubygems'
+require_relative 'melai/version'
+require_relative 'melai/dir_helpers'
+require_relative 'melai/package_helpers'
+require_relative 'melai/string_helpers'
+
+module Melai
+  # 
+  # This module is the main module. Creates a class of CommandHandler.
+  # Not entirely sure if the code is structured correctly. Might have to
+  # rethink module vs class locations, based on inheritance.
+  # 
+  class CommandHandler
+
+    # Creates/updates a symlink-based repository structure
+    #
+    # @param [String] a directory to build into
+    # @param [String] a directory containing the source packages
+    def create(repositories_path, packages_path, url_root)
+      puts "Creating a repository at #{repositories_path}."
+      ensure_directory(repositories_path)
+
+      # Accumulate a Hash keyed by repository filesystem path
+      # whose values are hashes of {:needs_update => bool, 
+      # :arch => String, :variant => String }
+      repositories = Hash.new
+
+      find_packages(packages_path).each do |package_path|
+        package_metadata(package_path, repositories_path).each do |metadata|
+          repository_path = metadata[:repository_path]
+          needs_update = ensure_symlink(metadata[:symlink_path], metadata[:package_path])
+
+          if repositories.include?(repository_path)
+            repositories[repository_path][:needs_update] ||= needs_update
+          else
+            repositories[repository_path] = {
+              :needs_update => needs_update,
+              :variant => metadata[:variant],
+              :arch => metadata[:arch],
+              :repository_path => metadata[:repository_path],
+              :repository_prefix => metadata[:repository_prefix]
+            }
+          end
+        end
+      end
+
+      # Now we have a Hash of all the repo directories that need updating by a value of 'true'
+      repositories.each do |repository_path, metadata|
+        next unless metadata[:needs_update]
+
+        repo_template(metadata, repositories_path, url_root)
+        update_repo_metadata(metadata, repositories_path, packages_path)
+      end
+    end
+
+    # List all package files found
+    #
+    # @param [String] a directory containing the source packages
+    # @return [Array] an array of filenames
+    def list(packages_path)
+      find_packages(packages_path)
+    end
+
+    # Destroy the repository directory completely.
+    # This is a glorified `rm -fr repo/` command, with a simple guard.
+    #
+    # @param [String] the root of repository directory
+    def destroy(repositories_path)
+      if repositories_path == "/"
+        exit_now!("WTF are you trying to do?", 1)
+      elsif Dir.exists?(repositories_path)
+        puts "Removing the entire #{repositories_path}"
+        FileUtils.remove_dir repositories_path
+        puts "It's gone!"
+      else
+        puts "Nothing there... idiot."
+      end
+    end
+  end
+end

data/lib/melai/dir_helpers.rb

@@ -0,0 +1,43 @@
+module Melai
+
+  # This module provides some helper methods, specificlally pertaining
+  # to directory creation, removal, searching, et al.
+  module DirHelpers
+
+    # Get any files with a known package extension
+    #
+    # @param [String] a directory to evaluate
+    # @return [Array] an array of filenmes
+    def find_packages(packages_path)
+      packages = File.join(packages_path, "**", "*.{rpm,deb}")
+      return Dir.glob(packages).sort()
+    end
+
+    # Ensure a directory exists
+    #
+    # @param [String] a directory to evaluate
+    # @return [Bool] true if the directory was created, false if already exists
+    def ensure_directory(directory)
+      unless File.directory?(directory)
+        FileUtils.mkdir_p(directory)
+        return true
+      end
+      return false
+    end
+
+    # Ensure a symlink exists
+    #
+    # @param [String] symlink_name: /foo/bar/i-am-a-symlink.rpm
+    # @param [String] original_file: /baz/i-am-a-real-file.rpm
+    # @return [Bool] true if the link was created, false if already exists
+    def ensure_symlink(symlink_name, original_file)
+      unless File.symlink?(symlink_name)
+        ensure_directory(File.dirname(symlink_name))
+        target = File.absolute_path(original_file)
+        File.symlink(target, symlink_name)
+        return true
+      end
+      return false
+    end
+  end
+end

data/lib/melai/package_helpers.rb

@@ -0,0 +1,168 @@
+require 'erb'
+require 'tempfile'
+require 'mixlib/shellout'
+require_relative 'dir_helpers'
+require_relative 'string_helpers'
+
+module Melai
+
+  # This module provides some package helper methods
+  module PackageHelpers
+
+    # Return an array of package metadata hashes. Each
+    # array element describes a particular repository
+    # that this package should be a member of.
+    def package_metadata(package_path, repositories_path)
+      case File.extname(package_path)
+      when '.rpm'
+        return rpm_package_metadata(package_path, repositories_path)
+      when '.deb'
+        if File.fnmatch('*ubuntu*', package_path)
+          return ubuntu_package_metadata(package_path, repositories_path)
+        else File.fnmatch('*debian*', package_path)
+          return debian_package_metadata(package_path, repositories_path)
+        end
+      end
+    end
+
+    def repo_template(metadata, repositories_path, url_root)
+      repository_path = metadata[:repository_path]
+      case repository_path
+      when /redhat/
+        source = "redhat.repo.erb"
+        target = "10gen.repo"
+        url_path = File.join(metadata[:repository_prefix], metadata[:variant], metadata[:arch])
+      else
+        source = "debian.list.erb"
+        target = "10gen.list"
+        url_path = File.join(metadata[:repository_prefix])
+      end
+
+      here = File.dirname(__FILE__)
+      template = ERB.new(File.read(File.join(here, "..", "..", "templates", source)))
+      output = File.new(File.join(repository_path, target), "w")
+      output.write(template.result(binding))
+    end
+
+    def update_repo_metadata(metadata, repositories_path, packages_path)
+      repository_path = metadata[:repository_path]
+
+      # e.g /data/packages/cache/debian-sysvinit/dists/
+      cache_path = File.join(packages_path, "cache", metadata[:repository_prefix])
+      ensure_directory(cache_path)
+
+      case repository_path
+      when /redhat/
+        begin
+          # e.g. repo/redhat/2.0/x86_64/
+          variant_dir = File.join(repositories_path,
+            metadata[:repository_prefix],
+            metadata[:variant],
+            metadata[:arch])
+
+          shell_out("createrepo --pretty -c #{cache_path} #{variant_dir}")
+        rescue Exception=>e
+          exit_now!("Could not complete createrepo:\n#{e}", 1)
+        end
+
+      else
+        # Do Debian-style repo builds
+        here = File.dirname(__FILE__)
+        fileloc = File.join(here, "../..", "templates", "apt-ftparchive.conf.erb")
+        template = ERB.new(File.read(fileloc))
+        output = Tempfile.new("apt-ftparchive.conf")
+        output.write(template.result(binding))
+        output.close()
+
+        begin
+          # Generates the Packages, Contents files
+          shell_out("apt-ftparchive generate #{output.path}")
+
+          # Generate the Release files on stdout
+          variant_dir = File.join(repositories_path,
+            metadata[:repository_prefix],
+            "dists",
+            metadata[:variant])
+
+          result = shell_out("apt-ftparchive -c #{output.path} release #{variant_dir}")
+
+          # Dump the Release stdout to a Release file
+          release_file = File.join(variant_dir, "Release.new")
+          File.open(release_file, "w").write(result.stdout)
+          # This ensures that the Release file is not included within itself
+          File.rename(release_file, File.join(variant_dir, "Release"))
+
+          # TODO: GPG Sign the Release file
+
+        rescue Exception=>e
+          exit_now!("Could not complete apt-ftparchive:\n#{e}", 1)
+        end
+      end
+    end
+
+    private
+
+    def shell_out(command)
+      proc = Mixlib::ShellOut.new(command)
+      proc.run_command
+      proc.error!
+      return proc
+    end
+
+    def rpm_package_metadata(package_path, repositories_path)
+      generate_metadata(package_path, repositories_path, ["os"]) do |variant, arch|
+        # Return path segments, relative to repositories_path,
+        # necessary to construct a path to the correct directory
+        # for RPM packages in the given variant and arch.
+        ["redhat", variant, arch, "RPMS"]
+      end
+    end
+
+    def debian_package_metadata(package_path, repositories_path)
+      generate_metadata(package_path, repositories_path, ["dist"]) do |variant, arch|
+        # Return path segments, relative to repositories_path,
+        # necessary to construct a path to the correct directory
+        # for Debian packages in the given variant and arch.
+        ["debian-sysvinit", "dists", variant, "10gen", "binary-#{arch}"]
+      end
+    end
+
+    def ubuntu_package_metadata(package_path, repositories_path)
+      generate_metadata(package_path, repositories_path, ["dist"]) do |variant, arch|
+        # Return path segments, relative to repositories_path,
+        # necessary to construct a path to the correct directory
+        # for Ubuntu packages in the given variant and arch.
+        ["ubuntu-upstart", "dists", variant, "10gen", "binary-#{arch}"]
+      end
+    end
+
+    def generate_metadata(package_path, repositories_path, variants)
+      # Since we want to provide both a 'base' variant and a version-specific
+      # one, we build an array of variants based on the the version maj.min
+      version, dist = get_version_from_filename(package_path)
+      arch = get_arch_from_filename(package_path)
+
+      variants << dist
+
+      package_metadata = []
+      variants.each do |variant|
+        # This is where the link will end up
+        path_segments = yield variant, arch
+        repository_path = File.join(repositories_path, *path_segments)
+        repository_prefix = path_segments[0]
+
+        # Create a symlink from the source file to the destination directories
+        package_metadata << {
+          :symlink_path => File.join(repository_path, File.basename(package_path)),
+          :package_path => package_path,
+          :variant => variant,
+          :arch => arch,
+          :repository_path => repository_path,
+          :repository_prefix => repository_prefix
+        }
+      end
+
+      return package_metadata
+    end
+  end
+end

data/lib/melai/string_helpers.rb

@@ -0,0 +1,40 @@
+require 'versionomy'
+
+module Melai
+
+  # This module provides some string helper methods
+  module StringHelpers
+
+    # Find the arch name within a filename
+    #
+    # @params [String] A filename
+    # @return [String] the arch name
+    def get_arch_from_filename(filename)
+      case
+      when matched = filename.match(/(i686|x86_64|i386|amd64)/)
+        arch = matched[0]
+      else
+        return 'unknown'
+      end
+    end
+
+    # Find the version within a filename
+    #    
+    # @params [String] A filename
+    # @return [Object] the version object, Versionomy-style
+    # @return [String] The Major + Minor versions
+    def get_version_from_filename(filename)
+      version = Versionomy.parse(/(\d+)\.(\d+)\.(\d+)/.match(filename).to_s)
+      # TODO: If we start packaging prerelease/rc packages, try:
+      # (\d+)\.(\d+)\.(\d+)(?:-[^\.]+)?
+      dist = [version.major, version.minor].join(".")
+      return version, dist
+    end
+
+    # TODO: needs work, currently unused
+    def get_unstable_from_filename(filename)
+      unstable = /unstable/.match(filename)
+      return unstable
+    end
+  end
+end

data/lib/melai/version.rb

@@ -0,0 +1,3 @@
+module Melai
+  VERSION = "0.0.1"
+end

data/melai.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/melai/version', __FILE__)
+
+Gem::Specification.new do |gem|
+
+  gem.name          = 'melai'
+  gem.summary       = %q{melai builds multi-platform repositories for a given list of package files}
+  gem.description   = %q{Build your repositories with melai}
+  gem.version       = Melai::VERSION
+  
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+  
+  
+   # GLI (Github-Like Interface) http://davetron5000.github.com/gli/
+  gem.add_dependency 'gli'
+
+  # versiononmy http://dazuma.github.com/versionomy/
+  gem.add_dependency 'versionomy'
+
+  # MixLib::ShellOut to perform system-level commands
+  gem.add_dependency 'mixlib-shellout'
+  
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'aruba'
+  gem.add_development_dependency 'aruba-doubles'
+  gem.add_development_dependency 'pry'
+
+  # tailor, for style. https://github.com/turboladen/tailor
+  gem.add_development_dependency 'tailor'
+
+  gem.authors       = ["Mike Fiedler"]
+  gem.email         = ["miketheman@gmail.com"]
+  gem.homepage      = "http://www.miketheman.net"  
+  
+end

data/melai.rdoc

@@ -0,0 +1,4 @@
+= melai
+
+consider changing to ronn
+http://rtomayko.github.com/ronn/ronn.1.html

data/templates/apt-ftparchive.conf.erb

@@ -0,0 +1,26 @@
+Dir {
+  ArchiveDir "<%= repositories_path %>/<%= metadata[:repository_prefix] %>";
+  CacheDir "<%= cache_path %>";
+};
+
+Tree "dists/<%= metadata[:variant] %>" {
+  Sections      "10gen";
+  Architectures "i386 amd64";
+};
+
+APT::FTPArchive {
+  MD5 true;
+  SHA1 true;
+  SHA256 true;
+  SHA512 true;
+  Release {
+    Origin "10gen";
+    Label  "10gen";
+    Suite  "10gen";
+    Version "<%= metadata[:variant] %>";
+    Codename "<%= metadata[:variant] %>";
+    Architectures "i386 amd64";
+    Components "10gen";
+    Description "10gen packages";
+  };
+};

data/templates/debian.list.erb

@@ -0,0 +1,2 @@
+# This file provides the 10gen software repository
+deb <%= url_root %>/<%= url_path %> <%= metadata[:variant] %> 10gen

data/templates/redhat.repo.erb

@@ -0,0 +1,6 @@
+# This file provides the 10gen software repository
+[10gen]
+name=10gen Repository
+baseurl=<%= url_root %>/<%= url_path %>
+gpgcheck=0
+enabled=1

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: melai
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mike Fiedler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: versionomy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mixlib-shellout
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba-doubles
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tailor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Build your repositories with melai
+email:
+- miketheman@gmail.com
+executables:
+- melai
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/melai
+- features/directories.feature
+- features/repository.feature
+- features/step_definitions/directories_steps.rb
+- features/support/env.rb
+- lib/melai.rb
+- lib/melai/dir_helpers.rb
+- lib/melai/package_helpers.rb
+- lib/melai/string_helpers.rb
+- lib/melai/version.rb
+- melai.gemspec
+- melai.rdoc
+- templates/apt-ftparchive.conf.erb
+- templates/debian.list.erb
+- templates/redhat.repo.erb
+homepage: http://www.miketheman.net
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: melai builds multi-platform repositories for a given list of package files
+test_files:
+- features/directories.feature
+- features/repository.feature
+- features/step_definitions/directories_steps.rb
+- features/support/env.rb