shanty 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 472f2d824a07db1b5c47ec13ddca184cad7478db
+  data.tar.gz: 6a45c1b9a654584efbd06d87d2c7202667095b43
+SHA512:
+  metadata.gz: 92abe04b4e6d65338f17a637c03ff0079297b3777c3e23726d4d8f85438121ece70a02806feac64e149e24103816f734518247e6f07ee53c460b0778a802b31a
+  data.tar.gz: 7b7e75add8f40176c1510ffeb96453678194a8e4f7f6a6fafb9f266d1e3a211d00d5d144285ee50d72ebd0e63d8c3276d9931d6017121705ca2ab8b2feecf3f0

data/README.md

@@ -0,0 +1,52 @@
+# Shanty [![Build Status](https://travis-ci.org/shantytown/shanty.svg?branch=master)](https://travis-ci.org/shantytown/shanty)[![Coverage Status](https://coveralls.io/repos/shantytown/shanty/badge.png?branch=master)](https://coveralls.io/r/shantytown/shanty?branch=master)
+
+**Shanty** is a project orchestration tool. It is designed to make it easy for you to build dependencies between projects, and execute tasks across this tree of relationships, regardless of what language or technology these projects use. The aim is consistency in the way you manage, build, test and deploy your projects.
+
+* Shanty is **language agnostic**. Shanty config files must be written in Ruby, but can be written for any type of project written in any language.
+* Shanty **is not a build tool**. It is designed to work with your existing build tool, instead living a layer up where it manages tasks to call to your build tool.
+* Shanty **is great for people with single repository, many subproject setups**. It makes it trivial to use your repository with many well known Continuous Integration tools and get benefits like building only changed projects, and depedency management.
+* Shanty **supports plugins**. You can hook into the lifecycle of Shanty at any point to achieve the task you want. Plugins can discover projects, add support for a new VCS, add actions that will be executed when a command is run, and work out whether a project has changed or not based on more complex dependencies.
+
+## Why Would I Want To Use Shanty Instead Of `<Insert Build Tool Here>`?
+
+Shanty is designed to make it easy to run tasks consistently across projects of many different types or written in many different languages.
+
+A great example use case of Shanty is integrating with Docker:
+
+```
+Foo (Java) -> Bar (Java) -> Bar Container (Docker)
+```
+
+Lets say you have a Java project `Bar` that builds an artifact. This Java project has a dependency on the artifact of another Java project called `Foo`. In order to dockerise the `Bar` project, you need to build the `Foo` dependency, then build the `Bar` project, and then build the Docker container.
+
+Managing this in existing setups often requires cobbling together shell scripts and the build tool of your choice. Shanty is designed to manage these relationships for you, abstracting the tasks of building and linking these projects into plugins that get auto-triggered based on these relationships (think `make`). Projects like `Gradle` go a long way towards supporting this model with their multi-project support, but the expressiveness of Ruby is missed as soon as you need to do something menial like read in a JSON options file for a project.
+
+So, with Shanty, building the Docker container would be as simple as `shanty build` in the Docker container project folder, and the rest is taken care of for you. This is because Shanty is designed to give you the freedom to choose any tool for any project, written in any language, by allowing you to plug in functionality where you need it.
+
+## Contibuting
+
+We welcome any contribution, whether big or small! We're busy importing our planned work as GitHub issues so people can join in the fun, we also have a [Huboard](https://huboard.com/shantytown/shanty) to make following the progress easier. If you have any questions, please hit us up on our freenode IRC channel `#shantytown`.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Chris Jansen, Nathan Kleyn
+
+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/bin/shanty

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'shanty'
+Shanty::Shanty.new.start!

data/lib/shanty/cli.rb

@@ -0,0 +1,83 @@
+require 'commander'
+require 'i18n'
+require 'shanty/task'
+
+module Shanty
+  # Public: Handle the CLI interface between the user and the registered tasks
+  # and plugins.
+  class Cli
+    include Commander::Methods
+
+    def initialize(graph)
+      @graph = graph
+    end
+
+    def tasks
+      Task.tasks.reduce({}) do |acc, task|
+        acc.merge(task.task_definitions)
+      end
+    end
+
+    def run
+      program :name, 'Shanty'
+      program :version, '0.1.0'
+      program :description, 'Something'
+
+      setup_tasks
+      run!
+    end
+
+    private
+
+    def setup_tasks
+      tasks.each do |name, task|
+        setup_task(name, task)
+      end
+    end
+
+    def setup_task(name, task)
+      command name do |c|
+        c.description = I18n.t(task[:desc], default: task[:desc])
+
+        task[:options].each do |option_name, option|
+          c.option(syntax_for_option(option_name, option), I18n.t(option[:desc], default: option[:desc]))
+        end
+
+        c.action do |args, options|
+          execute_task(name, args, options)
+        end
+      end
+    end
+
+    def execute_task(name, args, options)
+      task = tasks[name]
+
+      default_option_pairs = task[:options].map do |option_name, option|
+        [option_name, default_for_type(option)]
+      end
+      options.default(Hash[default_option_pairs])
+
+      task[:klass].new.send(name, options, @graph, *args)
+    end
+
+    def syntax_for_option(name, option)
+      syntax = case option[:type]
+               when :boolean
+                 "--#{name}"
+               else
+                 "--#{name} #{option[:type].upcase}"
+               end
+
+      option[:required] ? "[#{syntax}]" : syntax
+    end
+
+    def default_for_type(option)
+      case option[:type]
+      when :boolean
+        option[:default] || false
+      else
+        option[:default]
+      end
+    end
+  end
+end

data/lib/shanty/discoverer.rb

@@ -0,0 +1,31 @@
+require 'shanty/util'
+require 'shanty/project_template'
+
+module Shanty
+  # Public: Enables discovery of different types of project
+  # utilises inherited class method to find all implementing
+  # classes
+  class Discoverer
+    class << self
+      attr_reader :discoverers
+    end
+
+    def self.inherited(discoverer)
+      Util.logger.debug("Detected project discoverer #{discoverer}")
+      @discoverers ||= []
+      @discoverers << discoverer
+    end
+
+    def discover_all
+      self.class.discoverers.flat_map do |discoverer|
+        discoverer.new.discover
+      end
+    end
+
+    private
+
+    def create_project(*args)
+      ProjectTemplate.new(*args)
+    end
+  end
+end

data/lib/shanty/discoverers/gradle.rb

@@ -0,0 +1,18 @@
+require 'shanty/discoverer'
+require 'shanty/projects/static'
+
+module Shanty
+  # Gradle discoverer
+  class ShantyfileDiscoverer < Discoverer
+    def discover
+      Dir['**/build.gradle'].map do |path|
+        create_project(
+          File.dirname(path),
+          type: GradleProject,
+          options: { foo: 'bar' },
+          plugins: [GradlePlugin], parents: ['']
+        )
+      end
+    end
+  end
+end

data/lib/shanty/discoverers/shantyfile.rb

@@ -0,0 +1,15 @@
+require 'shanty/discoverer'
+require 'shanty/projects/static'
+
+module Shanty
+  # Public: Discoverer for Shantyfiles
+  # will create a a project for every Shantyfile it finds in
+  # a directory
+  class ShantyfileDiscoverer < Discoverer
+    def discover
+      Dir['**/Shantyfile'].map do |path|
+        create_project(File.absolute_path(File.dirname(path)))
+      end
+    end
+  end
+end

data/lib/shanty/global.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+require 'deep_merge'
+
+module Shanty
+  # Global configuration variables for shanty
+  module Global
+    module_function
+
+    def config_file
+      '.shanty.yml'
+    end
+
+    def environment
+      @environment = ENV['SHANTY_ENV'] || 'local'
+    end
+
+    def default_config
+      @default_config ||= {}
+    end
+
+    def add_default_config(new_config)
+      @default_config.merge!(new_config)
+    end
+
+    def root
+      @root ||= find_root
+    end
+
+    def config
+      file_config = YAML.load_file("#{root}/#{config_file}") || {}
+      @config ||= default_config.deep_merge!(file_config[environment]) || default_config
+    end
+
+    def find_root
+      if root_dir.nil?
+        fail "Could not find a #{Global.config_file} file in this or any parent directories. \
+             Please run `shanty init` in the directory you want to be the root of your project structure."
+      end
+
+      root_dir
+    end
+
+    def root_dir
+      Pathname.new(Dir.pwd).ascend do |d|
+        return d if d.join(Global.config_file).exist?
+      end
+    end
+  end
+end

data/lib/shanty/graph.rb

@@ -0,0 +1,122 @@
+require 'algorithms'
+
+module Shanty
+  # Public: Represents the link graph of projects in the repository. This class is
+  # responsible for collecting up all the information the projects we have,
+  # making parent/child dependency links between them, and then calculating which
+  # projects need to be build by combining a Git diff with the dependency graph
+  # to resolve to a list of projects required to be built.
+  class Graph
+    attr_reader :projects
+
+    # Public: Initialise a ProjectLinkGraph.
+    #
+    # projects - An array of project instances to take and link together into
+    #            a graph structure of dependencies.
+    def initialize(projects)
+      @projects = sort_projects(link_projects(projects))
+
+      @project_path_trie = Containers::Trie.new
+
+      @projects.each do |project|
+        @project_path_trie[project.path] = project
+      end
+    end
+
+    # Public: All the changed projects in the current repository.
+    #
+    # Returns an Array of Project subclasses, one for each project in the
+    # repository.
+    def changed
+      @projects.select { |project| project.changed? }
+    end
+
+    # Public: Returns a project, if any, with the given name.
+    #
+    # name - The name to filter by.
+    #
+    # Returns an instance of a Project subclass if found, otherwise nil.
+    def by_name(name)
+      @projects.find { |project| project.name == name }
+    end
+
+    # Public: Returns all projects of the given types.
+    #
+    # *types - One or more types to filter by.
+    #
+    # Returns an Array of Project subclasses, one for each project in the
+    # repository.
+    def all_of_type(*types)
+      @projects.select { |project| types.include?(project.class) }
+    end
+
+    # Public: Returns all the changed projects of the given types.
+    #
+    # *types - One or more types to filter by.
+    #
+    # Returns an Array of Project subclasses, one for each project in the
+    # repository.
+    def changed_of_type(*types)
+      changed.select { |project| types.include?(project.class) }
+    end
+
+    # Public: Returns the project, if any, that the current working directory
+    # belongs to.
+    #
+    # Returns an instance of a Project subclass if found, otherwise nil.
+    def current
+      owner_of_file(Dir.pwd)
+    end
+
+    # Public: Given a path to a file or directory (normally a path obtained
+    # while looking at a Git diff), find the project that owns this file. This
+    # works by finding the project with the longest path in common with the
+    # file, and is very efficient because this search is backed using a Trie
+    # data structure. This data structure allows worst case matching of O(m)
+    # complexity.
+    #
+    # path - The path to the file to find the owner project.
+    #
+    # Returns a Project subclass if any found, otherwise nil.
+    def owner_of_file(path)
+      key = @project_path_trie.longest_prefix(path)
+      @project_path_trie[key]
+    end
+
+    private
+
+    # Private: Given a list of projects, construct the parent/child
+    # relationships between them given a list of their parents/children by name
+    # as defined on the project instances.
+    #
+    # projects - An array of Project subclasses to link together.
+    #
+    # Returns an Array of linked projects.
+    def link_projects(projects)
+      projects_by_name = projects.each_with_object({}) { |project, acc| acc[project.name] = project }
+
+      projects.each do |project|
+        parent_dependencies = project.parents_by_name.map { |parent_name| projects_by_name[parent_name] }.compact
+
+        parent_dependencies.each do |parent_dependency|
+          project.add_parent(parent_dependency)
+          parent_dependency.add_child(project)
+        end
+      end
+
+      projects
+    end
+
+    # Private: Given a list of Project subclasses, sort them by their distance
+    # from the root node (that is, the topmost node). This order is important
+    # because it matches the order in which things should be build to avoid
+    # missing dependencies.
+    #
+    # projects - An array of Project subclasses to sort.
+    #
+    # Returns a sorted Array of Project subclasses.
+    def sort_projects(projects)
+      projects.sort { |a, b| a.distance_from_root <=> b.distance_from_root }
+    end
+  end
+end

data/lib/shanty/mixins/acts_as_link_graph_node.rb

@@ -0,0 +1,81 @@
+module Shanty
+  module Mixins
+    # A mixin module enabling classes to have parents and children. It provides
+    # convenience methods for determining dependencies, depdenants, and a distance
+    # from the root node. Note that in contrast to a tree, this link graph module
+    # allows multiple parents.
+    module ActsAsLinkGraphNode
+      # The self.included idiom. This is described in great detail in a
+      # fantastic blog post here:
+      #
+      # http://www.railstips.org/blog/archives/2009/05/15/include-vs-extend-in-ruby/
+      #
+      # Basically, this idiom allows us to add both instance *and* class methods
+      # to the class that is mixing this module into itself without forcing them
+      # to call extend and include for this mixin. You'll see this idiom everywhere
+      # in the Ruby/Rails world, so we use it too.
+      def self.included(cls)
+        cls.extend(ClassMethods)
+      end
+
+      # Common methods inherited by all classes
+      module ClassMethods
+        attr_writer :parents, :children
+      end
+
+      # Public: The parents linked to this instance.
+      #
+      # Returns an Array of Objects.
+      def parents
+        @parents ||= []
+      end
+
+      # Public: The children linked to this instance.
+      #
+      # Returns an Array of Objects.
+      def children
+        @children ||= []
+      end
+
+      # Public: Add a node to the parents linked to this instance.
+      #
+      # node - The Object to add.
+      def add_parent(node)
+        parents << node
+      end
+
+      # Public: Add a node to the children linked to this instance.
+      #
+      # node - The Object to add.
+      def add_child(node)
+        children << node
+      end
+
+      # Public: Convenience method to return all of the children from this node in
+      # the tree downwards to the leaves of the tree.
+      #
+      # Returns an Array of child Objects.
+      def all_children
+        children + children.map(&:all_children).flatten
+      end
+
+      # Public: Convenience method to return all of the parents from this node in
+      # the tree upwards to the root of the tree.
+      #
+      # Returns an Array of parent Objects.
+      def all_parents
+        parents + parents.map(&:all_parents).flatten
+      end
+
+      # Public: Calculate the maximum number of traverses that need to be made to
+      # reach the root from this node.
+      #
+      # Returns a Fixnum representing the traverses to the root. Note that a return
+      # value of 0 means this is the root (ie. it has no parents).
+      def distance_from_root
+        return 0 if parents.empty?
+        parents.map(&:distance_from_root).max + 1
+      end
+    end
+  end
+end

data/lib/shanty/mixins/attr_combined_accessor.rb

@@ -0,0 +1,24 @@
+module Shanty
+  module Mixins
+    # Additional accessor utility
+    module AttrCombinedAccessor
+      # Creates an invariant accessor that allows getting and setting from the
+      # same endpoint. It will operate in getter mode if you don't pass any
+      # arguments when calling it, otherwise it will work in setter mode. Useful
+      # when needing to chain methods (you can't chain standard attr_writer
+      # methods because of the `= something` part) or when trying to create a
+      # nice looking DSL.
+      def attr_combined_accessor(*syms)
+        syms.each do |sym|
+          define_method(sym) do |*args|
+            if args.empty?
+              instance_variable_get(:"@#{sym}")
+            else
+              instance_variable_set(:"@#{sym}", *args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shanty/mixins/callbacks.rb

@@ -0,0 +1,39 @@
+require 'hooks'
+
+module Shanty
+  module Mixins
+    # A mixin to implement publish/subscribe style callbacks in the class that
+    # includes this.
+    module Callbacks
+      # The self.included idiom. This is described in great detail in a
+      # fantastic blog post here:
+      #
+      # http://www.railstips.org/blog/archives/2009/05/15/include-vs-extend-in-ruby/
+      #
+      # Basically, this idiom allows us to add both instance *and* class methods
+      # to the class that is mixing this module into itself without forcing them
+      # to call extend and include for this mixin. You'll see this idiom everywhere
+      # in the Ruby/Rails world, so we use it too.
+      def self.included(cls)
+        cls.include(Hooks)
+        cls.extend(ClassMethods)
+      end
+
+      # Common methods inherited by all classes
+      module ClassMethods
+        def subscribe(*names, sym)
+          names.each do |name|
+            define_hook(name, halts_on_falsey: true) unless respond_to?(name)
+            send(name, sym)
+          end
+        end
+      end
+
+      def publish(name, *args)
+        return true if self.class.callbacks_for_hook(name).nil?
+        results = run_hook(name, *args)
+        !results.halted?
+      end
+    end
+  end
+end

data/lib/shanty/mutator.rb

@@ -0,0 +1,23 @@
+require 'shanty/util'
+
+module Shanty
+  # Public: enables mutation of the project graph
+  # Common usage would be to set changed flags on projects
+  class Mutator
+    class << self
+      attr_reader :mutators
+    end
+
+    def self.inherited(mutator)
+      Util.logger.debug("Detected mutator #{mutator}")
+      @mutators ||= []
+      @mutators << mutator
+    end
+
+    def apply_mutations(graph)
+      self.class.mutators.reduce(graph) do |acc, mutator|
+        mutator.new.mutate(acc)
+      end
+    end
+  end
+end

data/lib/shanty/mutators/git.rb

@@ -0,0 +1,24 @@
+require 'shanty/mutator'
+require 'shanty/vcs_ranges/local_git'
+
+module Shanty
+  # Git VCS mutator
+  class Git < Mutator
+    def initialize
+      @vcs_range = VCSRange.new
+    end
+
+    def mutate(graph)
+      git_root = `git rev-parse --show-toplevel`.strip
+      diff_files = `git diff --name-only #{@vcs_range.from_commit} #{@vcs_range.to_commit}`.split("\n")
+      diff_files.each do |path|
+        next if path.nil?
+        path = File.join(git_root, path)
+        project = graph.owner_of_file(path)
+        project.changed = true unless project.nil?
+      end
+
+      graph
+    end
+  end
+end

data/lib/shanty/plugin.rb

@@ -0,0 +1,26 @@
+require 'shanty/util'
+require 'shanty/project_template'
+
+module Shanty
+  # Some basic functionality for every plugin.
+  module Plugin
+    def self.extended(mod)
+      mod.module_eval do
+        def self.included(cls)
+          copy_subscribes_to_class(cls)
+        end
+      end
+    end
+
+    def copy_subscribes_to_class(cls)
+      @subscriptions.each do |args|
+        cls.subscribe(*args)
+      end
+    end
+
+    def subscribe(*args)
+      @subscriptions ||= []
+      @subscriptions.push(args)
+    end
+  end
+end

data/lib/shanty/plugins/bundler.rb

@@ -0,0 +1,15 @@
+require 'shanty/plugin'
+
+module Shanty
+  # Public: Bundler plugin for building ruby projects.
+  module BundlerPlugin
+    extend Plugin
+
+    subscribe :build, :bundle_install
+
+    def bundle_install
+      # FIXME: Add support for the --jobs argument to parallelise the bundler run.
+      system 'bundle install --quiet'
+    end
+  end
+end

data/lib/shanty/plugins/rspec.rb

@@ -0,0 +1,14 @@
+require 'shanty/plugin'
+
+module Shanty
+  # Public: Rspec plugin for testing ruby projects.
+  module RspecPlugin
+    extend Plugin
+
+    subscribe :test, :rspec
+
+    def rspec
+      system 'rspec'
+    end
+  end
+end

data/lib/shanty/plugins/rubocop.rb

@@ -0,0 +1,14 @@
+require 'shanty/plugin'
+
+module Shanty
+  # Public: Rubocop plugin for style checking ruby projects.
+  module RubocopPlugin
+    extend Plugin
+
+    subscribe :test, :rubocop
+
+    def rubocop
+      system 'rubocop'
+    end
+  end
+end

data/lib/shanty/project.rb

@@ -0,0 +1,71 @@
+require 'shanty/mixins/acts_as_link_graph_node'
+require 'shanty/mixins/callbacks'
+
+module Shanty
+  # Public: Represents a project in the current repository.
+  class Project
+    include Mixins::ActsAsLinkGraphNode
+    include Mixins::Callbacks
+
+    attr_accessor :name, :path, :options, :parents_by_name, :changed
+    attr_reader :changed
+    alias_method :changed?, :changed
+
+    # Public: Initialise the Project instance.
+    #
+    # project_template - An instance of ProjectTemplate from which to
+    #                    instantiate this project.
+    def initialize(project_template)
+      @name = project_template.name
+      @path = project_template.path
+      @options = project_template.options
+      @parents_by_name = project_template.parents
+      @changed = false
+
+      project_template.plugins.each do |plugin|
+        self.class.include plugin
+      end
+
+      instance_eval(&project_template.after_create) unless project_template.after_create.nil?
+    end
+
+    # Public: A list of the external dependencies this project has by name
+    # and version. This is used in dependency tree generation.
+    #
+    # Returns an Array of Strings representing external dependencies by name
+    # and version.
+    def externals_by_name
+      []
+    end
+
+    # Public: The absolute path to the artifact that would be created by this
+    # project when built, if any. This is expected to be overriden in subclasses.
+    #
+    # Returns a String representing the absolute path to the artifact.
+    def artifact_path
+      nil
+    end
+
+    # Public: Overriden String conversion method to return a simplified
+    # representation of this instance that doesn't include the cyclic
+    # parent/children attributes as defined by the ActsAsLinkGraphNode mixin.
+    #
+    # Returns a simple String representation of this instance.
+    def to_s
+      "Name: #{name}"
+    end
+
+    # Public: Overriden String conversion method to return a more detailed
+    # representation of this instance that doesn't include the cyclic
+    # parent/children attributes as defined by the ActsAsLinkGraphNode mixin.
+    #
+    # Returns more detailed String representation of this instance.
+    def inspect
+      {
+        name: name,
+        path: path,
+        options: options
+      }.inspect
+    end
+  end
+end

data/lib/shanty/project_template.rb

@@ -0,0 +1,53 @@
+require 'shanty/mixins/attr_combined_accessor'
+require 'shanty/projects/static'
+
+module Shanty
+  # Public: Allows creation of a project using a discoverer
+  class ProjectTemplate
+    extend Mixins::AttrCombinedAccessor
+
+    attr_combined_accessor :name, :type, :plugins, :parents, :options
+    attr_reader :path
+
+    def initialize(path, args = {})
+      fail 'Path to project must be a directory.' unless File.directory?(path)
+
+      @path = path
+      @name = File.basename(path)
+      @type = args[:type] || StaticProject
+      @plugins = args[:plugins] || []
+      @parents = args[:parents] || []
+      @options = args[:options] || {}
+
+      execute_shantyfile
+    end
+
+    def execute_shantyfile
+      shantyfile_path = File.join(@path, 'Shantyfile')
+
+      return unless File.exist?(shantyfile_path)
+
+      eval(File.read(shantyfile_path))
+    end
+
+    def plugin(plugin)
+      @plugins << plugin
+    end
+
+    def parent(parent)
+      @parents << parent
+    end
+
+    def option(key, value)
+      @options[key] = value
+    end
+
+    def after_create(&block)
+      if block.nil?
+        @after_create
+      else
+        @after_create = block
+      end
+    end
+  end
+end

data/lib/shanty/projects/ruby.rb

@@ -0,0 +1,12 @@
+require 'shanty/project'
+
+module Shanty
+  # Public: Represents a projects created with the Ruby language.
+  class RubyProject < Project
+    subscribe :build, :on_build
+
+    def on_build
+      system 'gem build *.gemspec'
+    end
+  end
+end

data/lib/shanty/projects/static.rb

@@ -0,0 +1,21 @@
+require 'shanty/project'
+
+module Shanty
+  # Public: Base type of project, simply creates a tarball of the directory
+  class StaticProject < Project
+    subscribe :build, :on_build
+
+    def on_build
+      # FIXME: Create a tarball of the current project.
+      true
+    end
+
+    # Public: The absolute path to the artifact that would be created by this
+    # project when built.
+    #
+    # Returns a String representing the absolute path to the artifact.
+    def artifact_path
+      "#{@root_dir}/build/#{@options['artifact_name'] || name}-#{@build_number}.tgz"
+    end
+  end
+end

data/lib/shanty/task.rb

@@ -0,0 +1,45 @@
+module Shanty
+  # Public: Discover shanty tasks
+  class Task
+    class << self
+      attr_reader :tasks
+      attr_reader :task_definitions, :task_definiton
+    end
+
+    # This method is auto-triggred by Ruby whenever a class inherits from
+    # Shanty::Task. This means we can build up a list of all the tasks
+    # without requiring them to register with us - neat!
+    def self.inherited(task)
+      @tasks ||= []
+      @tasks << task
+    end
+
+    def self.desc(desc)
+      task_definition[:desc] = desc
+    end
+
+    def self.param(name, options = {})
+      task_definition[:params][name] = options
+    end
+
+    def self.option(name, options = {})
+      task_definition[:options][name] = options
+    end
+
+    def self.method_added(name)
+      @task_definitions ||= {}
+      @task_definitions[name] = task_definition.merge(klass: self)
+
+      # Now reset the task definition.
+      @task_definition = {}
+    end
+
+    def self.task_definition
+      @task_definition ||= {}
+      @task_definition[:params] ||= {}
+      @task_definition[:options] ||= {}
+
+      @task_definition
+    end
+  end
+end

data/lib/shanty/tasks/basic.rb

@@ -0,0 +1,41 @@
+require 'i18n'
+require 'shanty/task'
+require 'shanty/util'
+
+module Shanty
+  # Public: A set of basic tasks that can be applied to all projects and that
+  # ship with the core of Shanty.
+  class BasicTasks < Shanty::Task
+    desc 'tasks.projects.desc'
+    option :changed, type: :boolean, desc: 'tasks.common.options.changed'
+    option :types, type: :array, desc: 'tasks.common.options.types'
+    def projects(options, graph)
+      graph.projects.each do |project|
+        next if options.changed? && !project.changed?
+        puts project
+      end
+    end
+
+    desc 'tasks.build.desc'
+    option :changed, type: :boolean, desc: 'tasks.common.options.changed'
+    option :watch, type: :boolean, desc: 'tasks.common.options.watch'
+    option :types, type: :array, desc: 'tasks.common.options.types'
+    def build(options, graph)
+      graph.projects.each do |project|
+        next if options.changed? && !project.changed?
+        fail I18n.t('tasks.build.failed', project: project) unless project.publish(:build)
+      end
+    end
+
+    desc 'tasks.test.desc'
+    option :changed, type: :boolean, desc: 'tasks.common.options.changed'
+    option :watch, type: :boolean, desc: 'tasks.common.options.watch'
+    option :types, type: :array, desc: 'tasks.common.options.types'
+    def test(options, graph)
+      graph.projects.each do |project|
+        next if options.changed? && !project.changed?
+        fail I18n.t('tasks.test.failed', project: project) unless project.publish(:test)
+      end
+    end
+  end
+end

data/lib/shanty/util.rb

@@ -0,0 +1,12 @@
+require 'logger'
+
+module Shanty
+  # Utility module for common tasks
+  module Util
+    module_function
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+end

data/lib/shanty/vcs_range.rb

@@ -0,0 +1,31 @@
+require 'shanty/util'
+
+module Shanty
+  # Public: Enables discovery of rangeerent types of CI provider
+  # utilises inherited class method to find all implementing
+  # classes
+  class VCSRange
+    class << self
+      attr_reader :vcs_range
+    end
+
+    def self.inherited(vcs_range)
+      Util.logger.debug("Detected VCS range #{vcs_range}")
+      @vcs_range = vcs_range
+    end
+
+    def from_commit
+      vcs_range.from_commit
+    end
+
+    def to_commit
+      vcs_range.to_commit
+    end
+
+    private
+
+    def vcs_range
+      @vcs_range ||= self.class.vcs_range.new
+    end
+  end
+end

data/lib/shanty/vcs_ranges/local_git.rb

@@ -0,0 +1,20 @@
+require 'shanty/vcs_range'
+
+module Shanty
+  # Use range of local vs remote changes
+  class LocalGit < VCSRange
+    def from_commit
+      "origin/#{branch}"
+    end
+
+    def to_commit
+      'HEAD'
+    end
+
+    private
+
+    def branch
+      `git rev-parse --abbrev-ref HEAD`.strip
+    end
+  end
+end

data/lib/shanty.rb

@@ -0,0 +1,47 @@
+require 'i18n'
+require 'pathname'
+require 'pry'
+
+require 'shanty/cli'
+require 'shanty/discoverers/shantyfile'
+require 'shanty/graph'
+require 'shanty/global'
+require 'shanty/mutators/git'
+require 'shanty/tasks/basic'
+
+module Shanty
+  # Main shanty class
+  class Shanty
+    GEM_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+    def start!
+      setup_i18n
+      Cli.new(graph).run
+    end
+
+    def graph
+      @graph ||= construct_project_graph
+    end
+
+    private
+
+    def setup_i18n
+      I18n.enforce_available_locales = true
+      I18n.load_path = Dir[File.join(GEM_ROOT, 'translations', '*.yml')]
+    end
+
+    def construct_project_graph
+      project_templates = Dir.chdir(Global.root) do
+        Discoverer.new.discover_all
+      end
+
+      projects = project_templates.map do |project_template|
+        project_template.type.new(project_template)
+      end
+
+      graph = Graph.new(projects)
+
+      Mutator.new.apply_mutations(graph)
+    end
+  end
+end

metadata

@@ -0,0 +1,315 @@
+--- !ruby/object:Gem::Specification
+name: shanty
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Jansen
+- Nathan Kleyn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: algorithms
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: graph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.11
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: Pluggable, destributed continous delivery framework. Works with your
+  existing build, test, CI, deployment, or indeed any tools to provide a cohesive
+  way to do continuous delivery.
+email:
+- nathan@nathankleyn.com
+executables:
+- shanty
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/shanty
+- lib/shanty.rb
+- lib/shanty/cli.rb
+- lib/shanty/discoverer.rb
+- lib/shanty/discoverers/gradle.rb
+- lib/shanty/discoverers/shantyfile.rb
+- lib/shanty/global.rb
+- lib/shanty/graph.rb
+- lib/shanty/mixins/acts_as_link_graph_node.rb
+- lib/shanty/mixins/attr_combined_accessor.rb
+- lib/shanty/mixins/callbacks.rb
+- lib/shanty/mutator.rb
+- lib/shanty/mutators/git.rb
+- lib/shanty/plugin.rb
+- lib/shanty/plugins/bundler.rb
+- lib/shanty/plugins/rspec.rb
+- lib/shanty/plugins/rubocop.rb
+- lib/shanty/project.rb
+- lib/shanty/project_template.rb
+- lib/shanty/projects/ruby.rb
+- lib/shanty/projects/static.rb
+- lib/shanty/task.rb
+- lib/shanty/tasks/basic.rb
+- lib/shanty/util.rb
+- lib/shanty/vcs_range.rb
+- lib/shanty/vcs_ranges/local_git.rb
+homepage: https://github.com/shantytown/shanty
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Pluggable, destributed continous delivery framework.
+test_files: []