dotum 0.0.0

data/lib/dotum/rules.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Dotum::Rules
+  extend Dotum::AutoloadConvention
+end

data/lib/dotum/rules/cd.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+class Dotum::Rules::Cd < Dotum::AbstractRules::Base
+
+  # Special case; we don't accept an options block.
+  def initialize(context, destination, &block)
+    super(context)
+
+    @destination = @context.target_dir.join(destination)
+    @block       = block
+  end
+
+  def pretty_subject
+    @destination.pretty
+  end
+
+private
+
+  def execute
+    Dir.chdir(@destination, &@block)
+  end
+
+end

data/lib/dotum/rules/download.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+class Dotum::Rules::Download < Dotum::AbstractRules::OptionsBase
+
+  shorthand :uri => :destination
+
+  required :uri
+  standard :destination
+  optional :mode
+  optional :owner
+  optional :group
+
+  def pretty_subject
+    "#{@destination.pretty} (#{@uri})"
+  end
+
+private
+
+  def execute
+    if @destination.exists? && !@destination.file?
+      failure! "#{@destination} already exists and is not a file!"
+    end
+
+    # TODO: ETag support!
+    run "curl", "--output", @destination, @uri
+
+    run "chmod", @mode, @destination  if @mode
+    run "chown", @owner, @destination if @owner
+    run "chgrp", @group, @destination if @group
+  end
+
+end

data/lib/dotum/rules/link.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+class Dotum::Rules::Link < Dotum::AbstractRules::GlobbableFiles
+
+private
+
+  def execute
+    link_path = @destination.symlink? ? @destination.link_path : nil
+
+    success! "Already linked" if link_path == @source
+    if @destination.exists?
+      if link_path
+        failure! "Target already exists as a symlink to #{link_path}"
+      else
+        failure! "Target already exists"
+      end
+    end
+
+    run "ln", "-s", @source, @destination
+  end
+
+end

data/lib/dotum/rules/repo.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+class Dotum::Rules::Repo < Dotum::AbstractRules::OptionsBase
+
+  shorthand :repo_uri => :destination
+
+  required :repo_uri
+  standard :destination
+  optional :branch
+
+  attr_reader :destination
+
+  def pretty_subject
+    @repo_uri
+  end
+
+private
+
+  def execute
+    @destination ||= default_destination
+    @repo_exists = @destination.join(".git").directory?
+
+    if !is_local? && context.no_remote?
+      if @repo_exists
+        skip! "Remote interactions are disabled."
+      else
+        failure! "Remote interactions are disabled; cannot clone!"
+      end
+    end
+
+    if @repo_exists
+      update_repo
+    else
+      clone_repo
+    end
+  end
+
+  def clone_repo
+    command = ["git", "clone"]
+    command += ["--branch", @branch] if @branch
+    command += [@repo_uri, @destination]
+
+    run *command
+  end
+
+  def update_repo
+    cd @destination do
+      run "git", "add", "--all"
+      run "git", "commit", "--quiet", "--allow-empty", "--message", "Temporary Dotum Commit"
+      run "git", "pull", "--rebase"
+      run "git", "reset", "HEAD^"
+    end
+  end
+
+  def default_destination
+    basename = [@repo_uri, @branch].compact.join("-").gsub(/[\/:]+/, "-")
+
+    context.state_dir.join("repo", basename)
+  end
+
+  def is_local?
+    @repo_uri.start_with? "file://"
+  end
+
+end

data/lib/dotum/rules/require_extension.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require "uri"
+
+class Dotum::Rules::RequireExtension < Dotum::AbstractRules::OptionsBase
+
+  shorthand :extension_uri
+
+  required :extension_uri
+  optional :legacy
+  optional :branch
+
+  def pretty_subject
+    @extension_uri
+  end
+
+private
+
+  def execute
+    # Does it look like a URI?
+    if URI.parse(@extension_uri).scheme
+      rule = repo @extension_uri, {:branch => @branch}
+      @destination = rule.destination
+    # Nope, we're just treating a local directory like a repo.
+    else
+      @destination = Dotum::Util::Path.new(@extension_uri)
+    end
+
+    failure! "Failed to clone repo to #{@destination}" unless @destination.directory?
+
+    # Dotum extensions are practically gems, but we don't want the overhead of
+    # building a gemspec.  Also, `require_extension` is the only supported
+    # means of loading them.  We don't want magic extensions to be already
+    # loaded via gems.  Explicit is good here!
+
+    # So, just load all files in the extension and be done with it.
+    @destination.glob("lib/**/*.rb").each do |path|
+      Kernel.load(path)
+    end
+  end
+
+end

data/lib/dotum/rules/run.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+class Dotum::Rules::Run < Dotum::AbstractRules::Base
+
+  def initialize(context, *command)
+    super(context)
+
+    @command = command
+  end
+
+  def pretty_subject
+    @command.join(" ")
+  end
+
+private
+
+  def execute
+    Kernel.system(*@command)
+
+    failure! unless $?.success?
+  end
+
+end

data/lib/dotum/rules/use.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class Dotum::Rules::Use < Dotum::AbstractRules::OptionsBase
+
+  shorthand :path
+
+  required(:path) { |v| package_dir.join(v) }
+
+  def self.expand_options(context, options)
+    paths = context.package_dir.glob(options[:path], &:directory?)
+    paths.reject! &:hidden?
+
+    paths.map { |p| options.merge(:path => p) }
+  end
+
+  def pretty_subject
+    @path.pretty
+  end
+
+private
+
+  def execute
+    failure! "Expected #{@path} to be a directory!" unless @path.directory?
+
+    rule_file = @path.join("rules.dotum")
+    rule_file = Dotum::DATA_PATH.join("default_rules.dotum") unless rule_file.file?
+
+    new_context = context.fork(:package_dir => @path)
+
+    Dotum::RuleRunner.eval(new_context, rule_file.read, rule_file)
+  end
+
+end

data/lib/dotum/rules/use_repo.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require "uri"
+
+class Dotum::Rules::UseRepo < Dotum::AbstractRules::OptionsBase
+
+  shorthand :repo_uri
+
+  required :repo_uri
+  optional :legacy
+  optional :branch
+
+  def pretty_subject
+    @repo_uri
+  end
+
+private
+
+  def execute
+    # Does it look like a URI?
+    if URI.parse(@repo_uri).scheme
+      rule = repo @repo_uri, {:branch => @branch}
+      @destination = rule.destination
+    # Nope, we're just treating a local directory like a repo.
+    else
+      @destination = Dotum::Util::Path.new(@repo_uri)
+    end
+
+    failure! "Failed to clone repo to #{@destination}" unless @destination.directory?
+    # We are now located within the repo.
+    @context = context.fork(:package_dir => @destination)
+
+    if @legacy
+      execute_legacy
+    else
+      execute_dotum
+    end
+  end
+
+  def execute_dotum
+    # Straight up `use` the repo if it is rooted with a `rules.dotum`.
+    if @destination.join('rules.dotum').file?
+      use "."
+
+    # Otherwise, this is a 'meta-package' that contains child packages.
+    else
+      @destination.relative_glob("*", &:directory?).each do |package_path|
+        use package_path
+      end
+    end
+  end
+
+  def execute_legacy
+    # In legacy mode, we just symlink everything
+    link "**/*"
+  end
+
+end

data/lib/dotum/standard_options.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Dotum::StandardOptions
+  extend Dotum::AutoloadConvention
+end

data/lib/dotum/standard_options/destination.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Dotum::StandardOptions::Destination
+  extend Dotum::RuleOptionsDSL
+
+  optional(:destination) { |v| context.target_dir.join(v) }
+
+  def preprocess_for_destination
+    # It's required by the time you reach the preprocessing step; but not
+    # necessarily required for the shorthand.
+    failure! "Option 'destination' is required." if @destination.nil?
+
+    parent_dir = @destination.dirname
+    if parent_dir.exists? && !parent_dir.directory?
+      failure! "Parent path #{parent_dir} is not a directory; cannot write into it!"
+    end
+
+    run "mkdir", "-p", parent_dir unless parent_dir.directory?
+  end
+  register_preprocessor :preprocess_for_destination
+
+end

data/lib/dotum/util.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Dotum::Util
+  extend Dotum::AutoloadConvention
+end

data/lib/dotum/util/ansi_colors.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Dotum::Util::ANSIColors
+
+  def ansi_color(text, code)
+    "\e[#{code}m#{text}\e[0m"
+  end
+
+  colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
+  colors.each_with_index do |color, i|
+    color_code = 30 + i
+
+    module_eval <<-end_eval, __FILE__, __LINE__
+
+      def c_#{color}(text)
+        ansi_color(text, "#{color_code}")
+      end
+
+      def c_bright_#{color}(text)
+        ansi_color(text, "#{color_code};1")
+      end
+
+    end_eval
+  end
+
+end

data/lib/dotum/util/path.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require "fileutils"
+
+# **Very** similar to `Pathname`.
+class Dotum::Util::Path
+
+  ABSOLUTE_PATH_MATCHER = /^(~?\/|\w+\:\\)/
+
+  def initialize(path, relative=nil)
+    path = path.to_str.gsub(/[\/\\]/, File::Separator)
+
+    @path = File.expand_path(path, relative)
+  end
+
+  def join(*components)
+    (components.size - 1).downto(0) do |i|
+      # Do we have absolute paths?  Stop at the last one.
+      if components[i].to_str =~ ABSOLUTE_PATH_MATCHER
+        return self.class.new(File.join(*components[i..-1]))
+      end
+    end
+
+    self.class.new(File.join(@path, *components))
+  end
+
+  def exists?
+    File.exist? @path
+  end
+
+  def file?
+    File.file? @path
+  end
+
+  def directory?
+    File.directory? @path
+  end
+
+  def symlink?
+    File.symlink? @path
+  end
+
+  def hidden?
+    File.split(@path).any? { |p| p.start_with? "." }
+  end
+
+  def link_path
+    self.class.new(File.readlink(@path))
+  end
+
+  def to_s
+    @path
+  end
+
+  def to_str
+    @path
+  end
+
+  def self.home_dir
+    @home_dir ||= File.expand_path("~")
+  end
+
+  def pretty
+    home_dir = File.expand_path("~")
+    if @path.start_with? home_dir
+      return "~" + @path[home_dir.size..-1]
+    end
+
+    @path
+  end
+
+  def read
+    File.read(@path)
+  end
+
+  def write(content)
+    File.open(@path, "w") do |file|
+      file.write(content)
+    end
+  end
+
+  def dirname
+    self.class.new(File.dirname(@path))
+  end
+
+  def basename
+    File.basename(@path)
+  end
+
+  def glob(expression, &filter)
+    matches = Dir.glob(join(expression), File::FNM_DOTMATCH)
+
+    if filter
+      matches.reject! { |p| !filter.call(self.class.new(p)) }
+    end
+
+    matches.reject! { |path|
+      basename = File.basename(path)
+
+      basename == "." || basename == ".."
+    }
+
+    matches.map { |p| self.class.new(p) }
+  end
+
+  def relative_glob(expression, &filter)
+    glob(expression, &filter).map { |path|
+      path.to_str[(@path.size + 1)..-1] || "."
+    }
+  end
+
+  def ==(other)
+    to_str == other.to_str
+  end
+
+  def mkpath!
+    FileUtils.mkpath(@path)
+  end
+
+end