cartage 1.0

data/lib/cartage/command.rb

@@ -0,0 +1,59 @@
+require 'cartage'
+require 'cmdparse'
+
+class Cartage
+  # The base Cartage command object. This is used to provide commands with a
+  # reference to the Cartage instance (<tt>@cartage</tt>) that is running under
+  # the main command-line program.
+  #
+  #   class Cartage::InfoCommand < Cartage::Command
+  #     def initialize(cartage)
+  #       super(cartage, 'info')
+  #     end
+  #
+  #     def perform
+  #       puts 'info'
+  #     end
+  #   end
+  #
+  # Cartage::Command changes the class-based command protocol from CmdParse so
+  # that you must define #perform instead of #execute. This is so that certain
+  # common behaviours (such as common config resolution) can be performed for
+  # all commands.
+  class Command < ::CmdParse::Command
+    # Create a ::CmdParse::Command with the given name. Save a reference to the
+    # provided cartage object.
+    def initialize(cartage, name, takes_commands: false)
+      if self.instance_of?(Cartage::Command)
+        raise ArgumentError, 'Cartage::Command cannot be instantiated.'
+      end
+
+      super(name, takes_commands: takes_commands)
+
+      @cartage = cartage
+    end
+
+    # Run the command. Children must *not* implement this method.
+    def execute(*args)
+      @cartage.send(:resolve_config!, *Array(with_plugins))
+      perform(*args)
+    end
+
+    ##
+    # :method: perform
+    #
+    # Perform the action of the command. Children *must* implement this method.
+
+    # This optional method is implemented by a plug-in to instruct Cartage to
+    # resolve the plug-in configuration for the specified plug-ins. Specify the
+    # plug-ins to be resolved as an array of Symbols.
+    #
+    # Plug-ins resolve by overriding the private method
+    # Cartage::Plugin#resolve_config!.
+    def with_plugins
+      []
+    end
+  end
+end
+
+require_relative 'pack_command'

data/lib/cartage/config.rb

@@ -0,0 +1,193 @@
+require 'ostruct'
+require 'pathname'
+
+class Cartage
+  # The Cartage configuration structure. The supported Cartage-wide
+  # configuration fields are:
+  #
+  # +target+:: The target where the final Cartage package will be created. Sets
+  #            Cartage#target. Equivalent to <tt>--target</tt>.
+  # +name+:: The name of the package to create. Sets Cartage#name. Equivalent
+  #          to <tt>--name</tt>.
+  # +root_path+:: The root path of the application. Sets Cartage#root_path.
+  #               Equivalent to <tt>--root-path</tt>.
+  # +timestamp+:: The timestamp for the final package. Sets Cartage#timestamp.
+  #               Equivalent to <tt>--timestamp</tt>.
+  # +bundle_cache+:: The bundle cache. Sets Cartage#bundle_cache. Equivalent to
+  #                  <tt>--bundle-cache</tt>.
+  # +without+:: Groups to exclude from bundle installation. Sets
+  #             Cartage#without_groups. Equivalent to <tt>--without</tt>.
+  #             This value should be provided as an array.
+  # +plugins+:: A dictionary for plug-in configuration groups. See below for
+  #             more information.
+  #
+  # Cartage configuration is not typically partitioned by an environment label,
+  # but can be. See the examples below for details.
+  #
+  # == Plug-Ins
+  #
+  # Plug-ins also keep configuration in the Cartage configuration structure,
+  # but as dictionary (hash) structures under the +plugins+ field. Each plug-in
+  # has its own key based on its name, so that the Manifest plug-in (if it had
+  # storable configuration values) would keep its configuration in a +manifest+
+  # key. See the examples below for details.
+  #
+  # == Loading Configuration
+  #
+  # When <tt>--config-file</tt> is specified, the configuration file will be
+  # loaded and parsed. If a filename is given, that file will be loaded. If a
+  # filename is not given, Cartage will look for the configuration in the
+  # following locations:
+  #
+  # * config/cartage.yml
+  # * ./cartage.yml
+  # * $HOME/.config/cartage.yml
+  # * $HOME/.cartage.yml
+  # * /etc/cartage.yml
+  #
+  # The contents of the configuration file are evaluated through ERB and then
+  # parsed from YAML and converted to nested OpenStruct objects. The basic
+  # environment example below would look like:
+  #
+  #   #<OpenStruct development=
+  #     #<OpenStruct without=["test", "development", "assets"]>
+  #   >
+  #
+  # == Examples
+  #
+  # Basic Cartage configuration:
+  #
+  #   ---
+  #   without:
+  #     - test
+  #     - development
+  #     - assets
+  #
+  # With an environment set:
+  #
+  #   ---
+  #   development:
+  #     without:
+  #       - test
+  #       - development
+  #       - assets
+  #
+  # With the Manifest plug-in (note: the Manifest plug-in does *not* have
+  # configurable options; this is for example purposes only).
+  #
+  #   ---
+  #   without:
+  #     - test
+  #     - development
+  #     - assets
+  #   manifest:
+  #     format: json
+  #
+  # With the Manifest plug-in and an environment:
+  #
+  #   ---
+  #   development:
+  #     without:
+  #       - test
+  #       - development
+  #       - assets
+  #     manifest:
+  #       format: json
+  class Config < OpenStruct
+    #:stopdoc:
+    DEFAULT_CONFIG_FILES = %w(
+    config/cartage.yml
+    ./cartage.yml
+    ~/.config/cartage.yml
+    ~/.cartage.yml
+    /etc/cartage.yml
+    )
+    #:startdoc:
+
+    class << self
+      # Load a Cartage configuration file.
+      def load(filename)
+        config_file = resolve_config_file(filename)
+        config = YAML.load(ERB.new(config_file.read, nil, '%<>-').result)
+        new(ostructify(config))
+      end
+
+      private
+
+      def resolve_config_file(filename)
+        return unless filename
+
+        files = if filename == :default
+                  DEFAULT_CONFIG_FILES
+                else
+                  [ filename ]
+                end
+
+        file  = files.find { |f| Pathname(f).expand_path.exist? }
+
+        if file
+          Pathname(file).expand_path
+        else
+          message = if filename
+                      "Configuration file #{filename} does not exist."
+                    else
+                      "No default configuration file found."
+                    end
+
+          raise ArgumentError, message
+        end
+      end
+
+      def ostructify(hash)
+        hash = hash.dup
+        hash.keys.each do |k|
+          hash[k.to_sym] = ostructify_recursively(hash.delete(k))
+        end
+        OpenStruct.new(hash)
+      end
+
+      def ostructify_recursively(object)
+        case object
+        when ::Array
+          object.map! { |i| ostructify_recursively(i) }
+        when ::OpenStruct
+          object = ostructify(object.to_h)
+        when ::Hash
+          object = ostructify(object)
+        end
+
+        object
+      end
+    end
+
+    # Convert the entire Config structure to a hash recursively.
+    def to_h
+      hashify(self)
+    end
+
+    # Override the default #to_yaml implementation.
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    private
+    def hashify(ostruct)
+      {}.tap { |hash|
+        ostruct.each_pair do |k, v|
+          hash[k.to_s] = hashify_recursively(v)
+        end
+      }
+    end
+
+    def hashify_recursively(object)
+      case object
+      when ::Array
+        object.map! { |i| hashify_recursively(i) }
+      when ::OpenStruct, ::Hash
+        object = hashify(object)
+      end
+
+      object
+    end
+  end
+end

data/lib/cartage/manifest.rb

@@ -0,0 +1,218 @@
+require 'tempfile'
+# Manage and use the package manifest ('Manifest.txt') and the ignore file
+# ('.cartignore').
+class Cartage::Manifest < Cartage::Plugin
+  # This exception is raised if the package manifest is missing.
+  MissingError = Class.new(StandardError) do
+    def message
+      <<-exception
+Cartage cannot create a package without a Manifest.txt file. You may generate
+or update the Manifest.txt file with the following command:
+
+      exception
+    end
+  end
+
+  DIFF     = if system('gdiff', __FILE__, __FILE__) #:nodoc:
+               'gdiff'
+             else
+               'diff'
+             end
+
+  def initialize(cartage) #:nodoc:
+    @cartage = cartage
+  end
+
+  # Resolve the Manifest to something that can be used by <tt>tar -T</tt>. The
+  # manifest should be relative to the files in the repository, as reported
+  # from <tt>git ls-files</tt>. +tar+ requires either full paths, or files
+  # relative to the directory you are packaging from (and we want relative
+  # files).
+  #
+  # This reads the manifest, prunes it with package ignores, and then writes it
+  # in a GNU tar compatible format as a tempfile. It does this by taking the
+  # expanded version of +path+, grabbing the basename, and inserting that in
+  # front of every line in the Manifest.
+  #
+  # If +path+ is not provided, Dir.pwd is used.
+  def resolve(path = nil, command: nil) # :yields: resolved manifest filename
+    raise MissingError unless manifest_file.exist?
+
+    data = strip_comments_and_empty_lines(manifest_file.readlines)
+    raise "Manifest.txt is empty." if data.empty?
+
+    path = Pathname(path || Dir.pwd).expand_path.basename
+    tmpfile = Tempfile.new('Manifest')
+
+    tmpfile.puts prune(data, with_slugignore: true).map { |line|
+      path.join(line).to_s
+    }.join("\n")
+
+    tmpfile.close
+
+    yield tmpfile.path
+  ensure
+    if tmpfile
+      tmpfile.close
+      tmpfile.unlink
+    end
+  end
+
+  # Generates Manifest.txt.
+  def generate
+    create_file_list(manifest_file)
+  end
+
+  # Checks Manifest.txt
+  def check
+    raise MissingError unless manifest_file.exist?
+    tmp = create_file_list('Manifest.tmp')
+    system(DIFF, '-du', manifest_file.basename.to_s, tmp.to_s)
+    $?.success?
+  ensure
+    tmp.unlink if tmp
+  end
+
+  # Installs the default .cartignore file.
+  def install_default_ignore(mode: nil)
+    mode = mode.to_s.downcase.strip
+    save = mode || !ignore_file.exist?
+
+    if mode == :merge
+      data = strip_comments_and_empty_lines(ignore_file.readlines)
+
+      if data.empty?
+        data = DEFAULT_IGNORE
+      else
+        data += strip_comments_and_empty_lines(DEFAULT_IGNORE.split($/))
+        data = data.uniq.join("\n")
+      end
+    else
+      data = DEFAULT_IGNORE
+    end
+
+    ignore_file.open('w') { |f| f.puts data } if save
+  end
+
+  private
+
+  def ignore_file
+    @ignore_file ||= @cartage.root_path.join('.cartignore')
+  end
+
+  def slugignore_file
+    @slugignore_file ||= @cartage.root_path.join('.slugignore')
+  end
+
+  def manifest_file
+    @manifest_file ||= @cartage.root_path.join('Manifest.txt')
+  end
+
+  def create_file_list(filename)
+    Pathname(filename).tap { |file|
+      file.open('w') { |f|
+        f.puts prune(%x(git ls-files).split.map(&:chomp)).sort.join("\n")
+      }
+    }
+  end
+
+  def ignore_patterns(with_slugignore: false)
+    pats = if ignore_file.exist?
+             ignore_file.readlines
+           elsif with_slugignore && slugignore_file.exist?
+             slugignore_file.readlines
+           else
+             DEFAULT_IGNORE.split($/)
+           end
+
+    pats = strip_comments_and_empty_lines(pats)
+
+    pats.map { |pat|
+      if pat =~ %r{/\z}
+        Regexp.new(%r{\A#{pat}})
+      elsif pat =~ %r{\A/[^*?]+\z}
+        Regexp.new(%r{\A#{pat.sub(%r{\A/}, '')}/})
+      else
+        pat
+      end
+    }.compact
+  end
+
+  def strip_comments_and_empty_lines(list)
+    list.map { |item|
+      item = item.chomp.gsub(/(?:^|[^\\])#.*\z/, '').strip
+      if item.empty?
+        nil
+      else
+        item
+      end
+    }.compact
+  end
+
+  def prune(files, with_slugignore: false)
+    exclusions = ignore_patterns(with_slugignore: with_slugignore)
+    files.reject { |file| prune?(file, exclusions) }
+  end
+
+  def prune?(file, exclusions = ignore_patterns())
+    exclusions.any? do |pat|
+      case pat
+      when /[*?]/
+        File.fnmatch?(pat, file, File::FNM_PATHNAME | File::FNM_EXTGLOB |
+                      File::FNM_DOTMATCH)
+      when Regexp
+        file =~ pat
+      else
+        file == pat
+      end
+    end
+  end
+
+  DEFAULT_IGNORE = <<-'EOM' #:nodoc:
+# Some of these are in .gitignore, but let’s remove these just in case they got
+# checked in.
+
+# Exact files to remove. Matches with ==.
+.DS_Store
+.autotest
+.editorconfig
+.env
+.git-wtfrc
+.gitignore
+.local.vimrc
+.lvimrc
+.cartignore
+.powenv
+.rake_tasks~
+.rspec
+.rubocop.yml
+.rvmrc
+.semaphore-cache
+.workenv
+Guardfile
+README.md
+bin/build
+bin/notify-project-board
+bin/osx-bootstrap
+bin/setup
+
+# Patterns to remove. These have a *, **, or ? in them. Uses File.fnmatch with
+# File::FNM_DOTMATCH and File::FNM_EXTGLOB.
+*.rbc
+.*.swp
+**/.DS_Store
+
+# Directories to remove. These should end with a slash. Matches as the regular
+# expression %r{\A#{pattern}}.
+db/seeds/development/
+db/seeds/test/
+# db/seeds/dit/
+# db/seeds/staging/
+log/
+test/
+tmp/
+vendor/bundle/
+  EOM
+end
+
+require_relative 'manifest/commands'