git_compound 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 612c6d116fee9bcaaee021484a7679932bb3e675
+  data.tar.gz: cdd8dc429c4481348cbbea8a98f9faeb103c463c
+SHA512:
+  metadata.gz: e7dbe4c61f12ccd94571ef2e44c55fce8b35f7c32ac0e9a05bc586d68708728a43157f7441c1d47bfb713e1c19cac367f1229a0177454495ad1a8619749d5fa5
+  data.tar.gz: 8ba2126a8ea301f628bab615f0af411b4b13a1cecc1951cf321eb906d95e8a1ce556ba7175a19a674470641be8635e6fc35acb90b24b28ab92f43907963117d6

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/todo

data/.rspec

@@ -0,0 +1,3 @@
+--require 'spec_helper'
+--color
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Metrics/LineLength:
+  Max: 90
+Metrics/MethodLength:
+  Max: 18
+Style/SignalException:
+  Enabled: false
+Style/ModuleFunction:
+  Enabled: false

data/Compoundfile

@@ -0,0 +1,4 @@
+# GitCompound manifest
+#
+
+name :git_compound

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Grzegorz Bizon <grzegorz.bizon@ntsn.pl>
+
+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,291 @@
+# Git Compound
+
+Compose your project using git repositories and ruby tasks
+
+## Status
+
+This project is in alpha phase
+
+## Overview
+
+Create `Compoundfile` or `.gitcompound` manifest:
+
+```ruby
+  name :base_component
+
+  component :component_1 do
+    version '~>1.1'
+    source  'git@github.com:/user/repository'
+    destination 'src/component_1'
+  end
+
+  component :component_2 do
+    version '>=2.0'
+    source  'git@github.com:/user/repository_2'
+    destination 'src/component_2'
+  end
+
+  component :component_3 do
+    branch 'feature/new-feature'
+    source  '/my/component_3/repository'
+    destination 'src/component_3'
+  end
+
+  task 'add components to gitignore', :each do |component_dir|
+    File.open('.gitignore', 'a') { |f| f.write "#{component_dir}\n" }
+  end
+```
+
+GitCompound will also process similar manifests found in required components in hierarchical way.
+
+Then run `gitcompound build`.
+
+
+## Core features 
+
+`GitCompound` is more a distributed packaging system than alternative to Git submodules. 
+
+`GitCompound` makes sure your project composition is the same on all machines,
+but you can have different composition depending on manifest you are using.
+
+It has been created with Docker compatiblity in mind.
+
+Core features:
+
+*   `GitCompound` introduces Domain Specific Language desgined for writing manifests.
+
+*   It is possible to create multiple manifest files (`Compoundfile`, `.gitcompound` or something else)
+    and build them when necessary.
+
+*   Building manifest create lockfile (locking components on specific commit SHA). When lockfile is present if will
+    be used each time `build` command is invoked.
+
+*   Manifests can declare dependencies on different versions of components using different version strategies
+    (Rubygems-like version, tag, branch or explicit SHA).
+
+*   Manifests will be processed in hierarchical way. Manifest that `gitcompound` command is run against
+    is root manifest. `GitCompound` processes all subsequent manifests found in dependencies using depth-first
+    search of dependency graph.
+
+*   Root manifest and manifest of each subsequent component can declare Ruby tasks that will be executed
+    when component is built or updated.
+
+*   It is possible to install dependencies in root directory (`Dir.pwd` where `gitcompound` command is invoked).
+    Each subsequent component can install their dependencies into root directory (see overview for **destination** DSL method).
+
+*   Build process creates lockfile in `.gitcompound.lock`. It locks components on specific commit SHAs.
+    It is then possible to build components directly, depending on versions (SHAs) from lockfile.
+
+## Commands
+
+### build
+
+`gitcompound build [manifest]` -- builds project from manifest or lockfile
+
+If manifest is not supplied, it uses `Compoundfile` or `.gitcompound`
+
+### update
+
+`gitcompound update [manifest]` -- updates project and lockfile
+
+### check
+
+`gitcompound check [manifest]` -- checks for circular dependencies, conflicting dependencies
+and name constraints
+
+### show
+
+`gitcompound show [manifest]` -- prints project structure
+
+### help
+
+`gitcompound help` -- prints help message
+
+## Global options
+
+1.  `--verbose` -- turns debug mode on
+2.  `--disable-colors` -- disables ANSI colors in output
+
+## Details
+
+1.  Use `name` method to specify **name** of manifest or component that this manifest is included in.
+
+2.  Add dependency to required **component** using `component` method.
+
+    This method takes two parameters -- name of component (as symbol) and implicit or explicit block.
+
+    Beware that `GitCompound` checks name constraints, so if you rely on component
+    with name `:component_1`, and this component has `Compoundfile` inside that declares 
+    it's name as something else than `:component_1` -- `GitCompound` will raise exception.
+
+3.  Components can use following **version strategies**:
+
+    *   `version` -- Rubygems-like **version** strategy
+        
+        This strategy uses Git tags to determine available component versions.
+        If tag matches `/^v?#{Gem::Version::VERSION_PATTERN}$/` then it is considered to 
+        be version tag and therefore it can be used with Rubygems syntax 
+        (like pessimistic version constraint operator)
+
+    *   `tag` -- use component sources specified by **tag**
+
+    *   `branch` -- use HEAD of given **branch**
+
+    *   `sha` -- use explicitly set commit **SHA**
+
+4.  Provide path to **source** repository using `source` method of manifest domain specific language.
+
+    It will be used as source to clone repository into destination directory.
+
+    This can take `:shallow` parameter. When `:shallow` is set, shallow clone will be 
+    performed (`--branch #{ref} --depth 1`):
+
+    ```ruby
+    component :bootstrap do
+      version '~>3.3.5'
+      source 'git@github.com:twbs/bootstrap', :shallow
+      destination '/vendor/bootstrap
+    end
+    ```
+
+    However using it is not recommended at all.
+
+    It can be helpful when required component is big and you need to build your project
+    only once, but it will cause issues with update. You will not be able to update it properly.
+    Use it with caution !
+
+
+5.  Use `destination` method to specify **destination** path where component will be cloned into.
+
+    This should be relative path in most cases.
+
+    Relative path is always relative to parent component directory. So if you define 
+    `component_1` with destination path `component_1/`, and this component will
+    depend on `component_2` with destination path set to `src/component_2`, you will
+    end with `./component_1/src/component_2` directory after building components.
+
+    When path is absolute -- it will be always relative to `Dir.pwd` where
+    you invoke `gitcompound *` commands. So if you have `component_1` with destination path
+    set to `/component_1` and `component_1` which has manifest that depends on `component_2` with
+    destination path set to `/component_2`, then `GitCompound` will create two separate
+    directories in `Dir.pwd`: `./component_1` and `./component_2`.
+
+    Use absolute paths with caution as it affects how parent projects will be built.
+    Ceraintly components that are libraries should not use it at all. If component is project --
+    it can take benefit from using absolute paths in component destination.
+
+6.  Running tasks
+
+    It is possible to use `task` method to define new **task**. `task` method takes 2 or 3 arguments.
+    First one is task name (symbol). Second one is optional task type that define how, and 
+    in which context, task will be executed. Third one is block that will be excuted.
+
+    Currently there are three task types:
+
+    *   `:manifest` type (this is default) -- run task in context of current manifest
+
+        Task will be executed only once, in context of current manifest this task is
+        defined in. Example:
+
+        ```ruby
+        task :print_manifest_name do |dir, manifest|
+          puts "Current manifest name is #{manifest.name} and dir is: #{dir}"
+        end
+        ```
+
+    *   `:each` type -- run task for each component defined in current manifest
+
+        This executes task for all components that are explicitly defined in current manifest.
+        Example:
+
+        ```ruby
+        task :print_component_name, :each do |dir, component|
+          puts "Current component name: #{component.name}"
+          puts "Current component source: #{component.origin}
+          puts "Current component destination: #{component.destination_path}
+
+          puts "Component directory: #{dir}"
+        end
+        ```
+
+        Note that `dir` here is the same as `component.destination_path`.
+
+    *   `:all` type -- run task for all child components of this manifest
+
+        Task for `:all` components will be executed in context of every component
+        this manifest is parent of.
+
+        It will be executed for all components defined in manifest itself and for all
+        components that are included in child manifests (obviously child manifests are
+        manifests included in components defined in parent manifest).
+
+        Example:
+
+        ```ruby
+        task :print_all_component_names, :all do |dir, component|
+          puts "Component #{component.name} destination dir: #{dir}"
+        end
+        ```
+
+    By default `GitCompound` executes only tasks defined in root manifest.
+
+    This is default behaviour dictated by security reasons. Since all tasks (also those defined 
+    in child component) are visited in reverse order it is possible to execute them too.
+
+    If you know what you are doing and it is your conscious decision to run all tasks in project
+    pass `--allow-nested-subtasks` options to `build` or `update` command.
+
+    It can be beneficial approach, but it has to be done with caution.
+
+## Other concepts
+
+1.  Accessing manifests
+
+    `GitCompound` tries to be as fast as possible. To achieve this it tries to access
+    manifest of required component without cloning it first. Is uses different strategies to
+    achieve this. Currently only two strategies are available:
+    
+    *   `GitArchiveStrategy` -- it uses `git archive` command to access single file in remote
+        repository,
+    *   `GithubStrategy` -- it uses http request to `raw.githubusercontent.com` to access 
+        manifest file at GitHub.
+
+    It is possible to create new strategies by implementing new strategy base on
+    `GitCompound::Repository::RemoteFile::RemoteFileStrategy` abstraction.
+
+2.  Using lockfile (`.gitcompound.lock`)
+
+    If lockfile is present, `gitcompound build` command will ignore manifest, and build
+    components, with versions locked in commit SHA. You can always be sure that your
+    environment will be unchange when building from lockfile.
+
+3.  Building manifest
+
+    Behavior of `build` command depends on whether lockfile exists or not.
+
+    *   When lockfile does not exist -- components will be built using versions stored in manifest.
+
+        Then lockfile `.gitcompound.lock` will be created, locking each component on specific commit SHA
+        that component has been checkout on during build process.
+
+    *   If lockfile is present it will be used as source for update process (see "Updating manifest" below)
+
+4.  Updating manifest
+
+    When using `gitcompound update` command each subsequent component will be either
+    built, updated or replaced:
+
+    *   built (cloned) -- if destination directory does not exist
+    *   updated (fetch & checkout) -- if component exists, matches origin and existing SHA != new SHA
+    *   replaced (remove & clone) -- if component exists but doesn't match origin remote
+
+    When invoking update process via `gitcompound update` command, versions specified in manifest file
+    will be use.
+
+## Roadmap
+
+Take a look at issues at GitHub.
+
+## License
+
+This is free software licensed under MIT license

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+RuboCop::RakeTask.new
+
+task :test do
+  Rake::Task['rubocop'].invoke
+  Rake::Task['spec'].invoke
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'git_compound'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/exe/gitcompound

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'git_compound'
+GitCompound.run(*GitCompound::Command::Options.new(ARGV).parse)

data/git_compound.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'git_compound/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'git_compound'
+  spec.version       = GitCompound::VERSION
+  spec.authors       = ['Grzegorz Bizon']
+  spec.email         = ['grzegorz.bizon@ntsn.pl']
+  spec.summary       = 'Compose you project using git repositories and ruby tasks'
+  spec.homepage      = 'https://github.com/grzesiek/git_compound'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(/^spec/) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # rubocop:disable Style/SingleSpaceBeforeFirstArg
+  spec.add_development_dependency 'bundler',   '~> 1.8'
+  spec.add_development_dependency 'rake',      '~> 10.0'
+  spec.add_development_dependency 'rubocop',   '~> 0.31.0'
+  spec.add_development_dependency 'rspec',     '~> 3.2.0'
+  spec.add_development_dependency 'pry',       '~> 0.10.1'
+  spec.add_development_dependency 'simplecov', '~> 0.10.0'
+  # rubocop:enable Style/SingleSpaceBeforeFirstArg
+
+  spec.requirements << 'git scm version > 2'
+  spec.requirements << 'gnu tar'
+
+  spec.required_ruby_version = '>= 2.2'
+end

data/lib/git_compound/builder.rb

@@ -0,0 +1,93 @@
+module GitCompound
+  # Builder class, responsible for building project
+  # from manifest or lockfile
+  #
+  class Builder
+    def initialize(manifest, lock, opts)
+      @manifest = manifest
+      @lock     = lock
+      @opts     = opts
+    end
+
+    def manifest_build
+      Logger.info 'Building components ...'
+      @manifest.process(Worker::ComponentBuilder.new(@lock))
+      self
+    end
+
+    def manifest_update
+      Logger.info 'Updating components ...'
+      @lock_new = Lock.new.clean
+      @manifest.process(Worker::ComponentUpdateDispatcher.new(@lock_new))
+      self
+    end
+
+    def manifest_lock
+      lock = @lock_new ? @lock_new : @lock
+      lock.lock_manifest(@manifest)
+      lock.write
+      self
+    end
+
+    def dependencies_check
+      Logger.info 'Checking dependencies ...'
+
+      @manifest.process(
+        Worker::CircularDependencyChecker.new,
+        Worker::NameConstraintChecker.new,
+        Worker::ConflictingDependencyChecker.new)
+      self
+    end
+
+    def components_show
+      Logger.info 'Processing components list ...'
+      @manifest.process(
+        Worker::CircularDependencyChecker.new,
+        Worker::PrettyPrint.new)
+      self
+    end
+
+    def tasks_execute
+      Logger.info 'Running tasks ...'
+
+      if @opts.include?(:allow_nested_subtasks)
+        @manifest.process(Worker::TaskRunner.new)
+      else
+        @manifest.tasks.each_value(&:execute)
+      end
+      self
+    end
+
+    def locked_manifest_verify
+      return self if @manifest.md5sum == @lock.manifest
+      raise GitCompoundError,
+            'Manifest md5sum has changed ! Use `update` command.'
+    end
+
+    def locked_components_build
+      Logger.info 'Building components from lockfile ...'
+      @lock.process(Worker::ComponentUpdateDispatcher.new(@lock))
+      self
+    end
+
+    def locked_components_guard
+      @lock.process(Worker::LocalChangesGuard.new(@lock))
+      self
+    end
+
+    def locked_dormant_components_remove
+      raise GitCompoundError, 'No new lockfile !' unless @lock_new
+
+      dormant_components = @lock.components.reject do |component|
+        @lock_new.find(component) ? true : false
+      end
+
+      dormant_components.each do |component|
+        Logger.warn "Removing dormant component `#{component.name}` " \
+                    "from `#{component.destination_path}` !"
+
+        component.remove!
+      end
+    end
+  end
+end

data/lib/git_compound/command/options.rb

@@ -0,0 +1,55 @@
+module GitCompound
+  module Command
+    # Class that parses command arguments
+    #
+    class Options
+      GLOBAL_OPTIONS = [:verbose, :disable_colors]
+
+      def initialize(args)
+        @command, @args = parse_options(args)
+
+        set_global_options
+      end
+
+      def global_options
+        @args & GLOBAL_OPTIONS
+      end
+
+      def command_options
+        @args - GLOBAL_OPTIONS
+      end
+
+      def command
+        @command || 'help'
+      end
+
+      def parse
+        [command, command_options]
+      end
+
+      def self.verbose=(mode)
+        GitCompound::Logger.verbose = mode
+      end
+
+      def self.disable_colors=(mode)
+        String.disable_colors = mode
+      end
+
+      private
+
+      def parse_options(args)
+        opts_dash = args.select { |opt| opt.start_with?('--') }
+        opts_string = args - opts_dash
+        command = opts_string.shift
+        opts_sym = opts_dash.collect { |opt| opt.sub(/^--/, '').gsub('-', '_').to_sym }
+        [command, opts_string + opts_sym]
+      end
+
+      def set_global_options
+        global_options.each do |option|
+          self.class.public_send("#{option}=", true)
+        end
+      end
+    end
+  end
+end

data/lib/git_compound/command.rb

@@ -0,0 +1,113 @@
+module GitCompound
+  # GitCompount command facade
+  #
+  module Command
+    def build(*args)
+      if Lock.exist?
+        builder(args)
+          .locked_manifest_verify
+          .locked_components_build
+          .tasks_execute
+      else
+        builder(args)
+          .dependencies_check
+          .manifest_build
+          .tasks_execute
+          .manifest_lock
+      end
+    end
+
+    def update(*args)
+      raise GitCompoundError,
+            "Lockfile `#{Lock::FILENAME}` does not exist ! " \
+            'You should use `build` command.' unless Lock.exist?
+
+      builder(args)
+        .locked_components_guard
+        .dependencies_check
+        .manifest_update
+        .tasks_execute
+        .manifest_lock
+        .locked_dormant_components_remove
+    end
+
+    def check(*args)
+      builder(args).dependencies_check
+      Logger.info 'OK'
+    end
+
+    def show(*args)
+      builder(args).components_show
+    end
+
+    def help(*_args)
+      Logger.info(usage)
+    end
+
+    def run(command, args)
+      abort(usage) unless methods.include?(command.to_sym)
+
+      Logger.debug("GitCompound v#{GitCompound::VERSION}")
+      Logger.debug("Running command '#{command}'")
+
+      public_send(command, *args)
+    rescue GitCompoundError => e
+      abort Logger.error("Error: #{e.message}", :quiet)
+    end
+
+    private
+
+    def builder(args)
+      Builder.new(manifest(args.first), Lock.new, args)
+    end
+
+    def manifest(filename)
+      files = filename ? [filename] : Manifest::FILENAMES
+      found = files.select { |file| File.exist?(file) }
+
+      raise GitCompoundError,
+            "Manifest `#{filename || files.inspect}` not found !" if found.empty?
+
+      contents = File.read(found.first)
+      Manifest.new(contents)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def usage
+      <<-EOS
+      #{'GitCompound version'.bold.yellow} #{GitCompound::VERSION.bold}
+
+      Usage: #{'gitcompound'.bold.green} #{
+        '[options]'.green} #{'command'.bold} #{'[manifest_file]'.green}
+
+      Commands:
+        #{'build'.bold}
+            builds project from manifest (or lockfile if present)
+
+            If manifest is not specified it uses one of
+            #{Manifest::FILENAMES.inspect}
+
+        #{'update'.bold}
+            updates project
+
+        #{'check'.bold}
+            detects circular depenencies, conflicting dependencies
+            and checks for name contraints
+
+        #{'show'.bold}
+            prints structure of project
+
+        #{'help'.bold}
+            prints this help
+
+      Options:'
+        #{'--verbose'.bold}
+            prints verbose log info
+
+        #{'--disable-colors'.bold}
+            disable ANSI colors in output
+      EOS
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end