fixman 0.1.0

data/lib/fixman/configuration.rb

@@ -0,0 +1,161 @@
+require 'English'
+require 'yaml'
+require 'pathname'
+require 'fixman/utilities'
+require 'fixman/task_parse_error'
+require 'classy_hash'
+
+module Fixman
+  class Configuration
+    DEFAULT_LEDGER_FILE = '.fixman_ledger.yaml'
+    DEFAULT_CONF_FILE = '.fixman_conf.yaml'
+
+    CONDITION_OR_CLEANUP_SCHEMA = ->(h) {
+      return ':type is mising' unless h.has_key? :type
+      unless [:ruby, :shell].include? h[:type]
+        return ':type must be one of :ruby or :shell'
+      end
+      return ':action is mising' unless h.has_key? :action
+      return ':action should be a String' unless h[:action].is_a? String
+
+      if h[:type] == :ruby 
+        begin
+          # Here a misformed Ruby source would also throw an ArgumentError
+          raise ArgumentError unless eval(h[:action]).is_a? Proc
+        rescue ArgumentError
+          return ':action should evaluate to a Proc object'
+        end
+      elsif h[:type] == :shell && h[:exit_status]
+        es = h[:exit_status]
+        unless es.is_a?(Integer) && (0..255).include?(es)
+          return ':exit_status should be an integer in 0..255 range'
+        end
+      end
+
+      true
+    }
+
+    REPO_INFO_SCHEMA = {
+      symbol: Symbol,
+      prompt: String,
+      label: String,
+      type: Symbol,
+      choices: [ :optional, [[String]] ]
+    }
+
+    TASK_SCHEMA = {
+      name: String,
+      target_placeholder: [ :optional, String ],
+      command: {
+        action: String,
+        exit_status: [ :optional, 0..255 ]
+      },
+      condition: [ :optional, CONDITION_OR_CLEANUP_SCHEMA ],
+      cleanup: [ :optional, CONDITION_OR_CLEANUP_SCHEMA ],
+      groups: [ :optional, [[ String ]] ]
+    }
+
+    CONF_SCHEMA = {
+      fixtures_base: String,
+      fixtures_ledger: [ :optional, String ],
+      tasks: ->(tasks) {
+        if tasks.is_a?(Array) && tasks.size > 0
+          begin
+            tasks.all? do |task|
+              begin
+                CH.validate task, TASK_SCHEMA
+              rescue => e
+                index = tasks.find_index task
+                raise Fixman::TaskParseError.new(e, index)
+              end
+              true
+            end
+          rescue Fixman::TaskParseError => e
+            e.message
+          end
+        else
+          "a non-empty array"
+        end
+      },
+      groups: [ :optional, [[ String ]] ],
+      extra_repo_info: [ :optional, [[ REPO_INFO_SCHEMA ]] ]
+    }
+
+    include Fixman::Utilities
+
+    attr_reader :fixtures_base, :fixture_ledger, :raw_tasks, :extra_repo_info, :groups
+
+    def initialize(fixtures_base,
+                   fixture_ledger,
+                   raw_tasks,
+                   groups,
+                   extra_repo_info)
+      @fixtures_base = Pathname.new(fixtures_base)
+      @fixture_ledger = Pathname.new(fixture_ledger)
+      @raw_tasks = raw_tasks
+      @extra_repo_info = extra_repo_info
+      @groups = groups
+    end
+
+    class << self
+      def read(path_to_conf)
+        conf_yaml = YAML.load IO.read(path_to_conf)
+
+        ClassyHash.validate conf_yaml, CONF_SCHEMA
+        initialize_defaults conf_yaml
+
+        raw_tasks = conf_yaml[:tasks].map do |task|
+          RawTask.new task
+        end
+
+        Configuration.new(conf_yaml[:fixtures_base],
+                          conf_yaml[:fixture_ledger],
+                          raw_tasks,
+                          conf_yaml[:groups],
+                          conf_yaml[:extra_repo_info])
+      end
+
+      def initialize_defaults(conf_hash)
+        conf_hash[:tasks].each do |task|
+          command = task[:command]
+          command[:exit_status] = 0 unless command[:exit_status]
+          unless task[:target_placeholder]
+            task[:target_placeholder] = 'TARGET'
+          end
+
+          condition = task[:condition]
+          if !condition
+            task[:condition] = {
+              type: :ruby,
+              action: 'proc { true }'
+            }
+          elsif condition[:type] == :shell && !condition[:exit_status]
+            condition[:exit_status] = 0
+          end
+
+          cleanup = task[:cleanup]
+          if !cleanup
+            task[:cleanup] = {
+              type: :ruby,
+              action: 'proc { true }'
+            }
+          end
+
+          task[:variables] = [] unless task[:variables]
+        end
+
+        unless conf_hash[:fixture_ledger]
+          conf_hash[:fixture_ledger] = DEFAULT_LEDGER_FILE
+        end
+
+        [:groups, :extra_repo_info].each do |key|
+          conf_hash[key] = [] unless conf_hash[key]
+        end
+
+        conf_hash[:extra_repo_info].each do |repo_info|
+          repo_info[:prompt] << ' '
+        end
+      end
+    end
+  end
+end

data/lib/fixman/controller.rb

@@ -0,0 +1,121 @@
+require 'fixman/repository'
+require 'git'
+require 'yaml'
+
+module Fixman
+  class Controller
+    attr_reader :repos
+
+    def initialize(repos = [])
+      @repos = repos
+    end
+
+    # Add a new repository to the collection.
+    def add(input, fixtures_base, extra_repo_info)
+      repo = Repository.new input, fixtures_base, extra_repo_info
+
+      @repos << repo
+    end
+
+    # Remove repository from the fixtures list.
+    def delete(canonical_name)
+      repo = find canonical_name
+
+      if repo
+        @repos.delete repo
+        repo.destroy
+      else
+        fail ArgumentError
+      end
+    end
+
+    # Download repositories belonging to the at least one of the given groups.
+    def fetch(groups)
+      repos = find_by_groups(groups).reject { |repo| repo.fetched? }
+      repos.each do |repo|
+        begin
+          repo.fetch
+        rescue Git::GitExecuteError => error
+          STDERR.puts "Warning: Repository #{repo.canonical_name} could not be fetched."
+          STDERR.puts error.message
+        end
+      end
+    end
+
+    def update(canonical_name, sha = nil)
+      repo = find canonical_name
+      fail ArgumentError unless repo
+
+      repo.sha = sha || repo.retrieve_head_sha
+    end
+
+    def upgrade(groups)
+      repos = find_by_groups(groups) 
+      repos.each do |repo| 
+        begin
+          repo.upgrade
+        rescue Git::GitExecuteError => error
+          STDERR.puts "Warning: Repisotiry #{repo.canonical_name} could not be \"
+            upgraded."
+          STDERR.puts error.message
+        end
+      end
+    end
+
+    class << self
+      # Controller for the command line interface.
+      def open(conf)
+        original_ledger = ""
+
+        controller =
+        begin
+          original_ledger = YAML.load(IO.read conf.fixture_ledger)
+          original_ledger.map! { |entry| YAML.load entry } 
+
+          repos = []
+          original_ledger.each do |repo_params|
+            repos << Repository.new(repo_params,
+                                    conf.fixtures_base,
+                                    conf.extra_repo_info)
+          end
+
+          Controller.new repos
+        rescue Errno::ENOENT
+          Controller.new
+        end
+
+        result = yield controller
+
+        write_ledger controller.repos, original_ledger, conf.fixture_ledger
+
+        result
+      rescue Git::GitExecuteError => error
+        puts error.message
+        exit 1
+      end
+
+      private
+
+      def write_ledger(repos, original_ledger, fixture_ledger)
+        new_ledger = YAML.dump repos.map(&:to_yaml)
+        if new_ledger != original_ledger
+          IO.write fixture_ledger, new_ledger
+        end
+      end
+    end
+
+    private
+
+    def find_by_groups(groups)
+      if groups.empty?
+        @repos
+      else
+        @repos.select { |repo| !(repo.groups & groups).empty? }
+      end
+    end
+
+    def find(canonical_name)
+      @repos.find { |repo| canonical_name == repo.canonical_name }
+    end
+  end
+end

data/lib/fixman/raw_task.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'fixman/utilities'
+
+module Fixman
+  class RawTask
+    include Utilities
+
+    def initialize params
+      # Common to commands, cleanup, condition
+      @name = params[:name]
+      @target_placeholder = params[:target_placeholder]
+
+      # Command to execute and check exit status
+      @command = params[:command]
+      @variables = params[:variables] || []
+
+      # Condition to run the task
+      @condition = params[:condition]
+
+      # Clean up
+      @cleanup = params[:cleanup]
+    end
+
+    def refine
+      condition_proc = refine_condition
+      cleanup_proc = refine_cleanup
+      command_procs = refine_command
+
+      command_procs.map do |command_proc|
+        Task.new @name, condition_proc, command_proc, cleanup_proc
+      end
+    end
+
+    private
+
+    # Defines refine_cleanup and refine_condition methods.
+    # ivar is the associated instance variable i.e. @condition and @cleanup
+    %w(condition cleanup).each do |ivar_name|
+      define_method("refine_#{ivar_name}") do
+        ivar = instance_variable_get("@#{ivar_name}")
+
+        return proc { true } unless ivar
+
+        result =
+        case ivar[:type]
+        when :ruby
+          eval ivar[:action]
+        when :shell
+          shell_to_proc ivar[:action], ivar[:exit_status]
+        else
+          error "Unknown #{ivar_name} type"
+        end
+
+        error 'Invalid action' unless result.class == Proc
+
+        result
+      end
+    end
+
+    def refine_command
+      actions = substitute_variables
+
+      actions.map do |action|
+        shell_to_proc action, @command[:exit_status]
+      end
+    end
+
+    def substitute_variables
+      actions = [@command[:action]]
+
+      @variables.each do |variable|
+        key_regexp = Regexp.new variable[:key]
+        actions.map! do |action|
+          if key_regexp =~ action
+            variable[:values].map { |value| action.gsub(variable[:key], value) }
+          else
+            action
+          end
+        end.flatten!
+      end
+
+      actions
+    end
+
+    def shell_to_proc(shell_command, exit_status)
+      proc do |target|
+        final_command_str =
+        if target
+          shell_command.gsub(@target_placeholder, target.to_s)
+        else
+          shell_command
+        end
+
+        final_command_str << ' &> /dev/null'
+
+        system(final_command_str)
+        if exit_status
+          $CHILD_STATUS.exitstatus == exit_status
+        end
+      end
+    end
+  end
+end

data/lib/fixman/repository.rb

@@ -0,0 +1,99 @@
+require 'English'
+require 'git'
+require 'fileutils'
+require 'yaml'
+
+module Fixman
+  class Repository
+    FIELD_LABEL_WIDTH = 20
+
+    GIT_URL_REGEXP = %r{
+      (?:github\.com)\/
+      (?<owner>(?:\w|-)+)
+      \/
+      (?<name>(?:\w|-)+)
+      (?:\.git)?
+      $
+    }xi
+
+    attr_accessor :url, :name, :owner, :sha, :groups, :other_fields
+    attr_reader :path
+
+    def initialize(repo_params, fixtures_base, extra_repo_info)
+      @url = repo_params[:url]
+      @name = repo_params[:name]
+      @owner = repo_params[:owner]
+      @sha = repo_params[:sha]
+      @groups = repo_params[:groups]
+
+      [:url, :name, :owner, :sha, :groups].each { |key| repo_params.delete key }
+      @other_fields = repo_params
+
+      @extra_repo_info = extra_repo_info
+      @path = fixtures_base + canonical_name
+    end
+
+    def fetched?
+      File.exist? @path
+    end
+
+    def fetch
+      git = Git.clone @url, @path
+      git.reset_hard @sha
+    end
+
+    def upgrade
+      git = Git.open @path
+      git.pull
+      git.reset_hard @sha
+    end
+
+    def destroy
+      FileUtils.rm_rf @path if File.exist? @path
+    end
+
+    def canonical_name
+      "#{@owner}/#{@name}"
+    end
+
+    def summary
+      "#{canonical_name}\t#{@sha}"
+    end
+
+    def to_s
+      str = StringIO.new
+      str.puts 'Repository'.ljust(FIELD_LABEL_WIDTH) + canonical_name
+      str.puts 'URL'.ljust(FIELD_LABEL_WIDTH) + @url
+      str.puts 'Commit SHA'.ljust(FIELD_LABEL_WIDTH) + @sha
+      str.puts 'Groups'.ljust(FIELD_LABEL_WIDTH) + @groups.join(', ')
+      @extra_repo_info.each do |info|
+        str.puts info[:label].ljust(FIELD_LABEL_WIDTH) +
+          @other_fields[info[:symbol]]
+      end
+      str.string
+    end
+
+    def to_yaml
+      {
+        name: @name,
+        owner: @owner,
+        sha: @sha,
+        url: @url,
+        access_right: @access_right,
+        notes: @notes
+      }.merge(@other_fields).to_yaml
+    end
+
+    class << self
+      def extract_owner_and_name(url)
+        match_data = GIT_URL_REGEXP.match url
+        [match_data[:owner], match_data[:name]] if match_data
+      end
+
+      def retrieve_head_sha url
+        ref = Git.ls_remote url
+        ref['head'][:sha]
+      end
+    end
+  end
+end