rulebow 0.4.0

data/lib/rulebow/cli.rb

@@ -0,0 +1,181 @@
+module Rulebow
+
+  ##
+  # Rulebow's command line interface.
+  #
+  class CLI
+
+    # Fire her up!
+    def self.fire!(argv=ARGV)
+      new(argv).fire!
+    end
+
+    # Initialize new instance of Rulebow::CLI.
+    # If `argv` is not provided than ARGV is used.
+    #
+    # argv - Command line argument. [Array<String>]
+    #
+    # Returns nothing.
+    def initialize(argv=ARGV)
+      #begin
+      #  require 'dotopts'
+      #rescue LoadError
+      #end
+
+      @argv = Array(argv || ARGV)
+
+      @script = nil
+      @watch  = nil
+      @fresh  = false
+    end
+
+    # Returns runner instance. [Runner]
+    def runner
+      @runner ||= (
+        Runner.new(
+          :script => @script,
+          :fresh  => @fresh,
+          :watch  => @watch
+        )  
+      )
+    end
+
+    # Execute command.
+    #
+    # command - Which command to execute.
+    #
+    # Returns nothing.
+    def fire!(argv=ARGV)
+      $DEBUG = argv.include?('--debug') || $DEBUG
+      return fire if $DEBUG
+      begin
+        fire
+      rescue => err
+        puts "#{$0}: error #{err}"
+      end
+    end
+
+    # Fire her up!
+    def fire
+      args = cli_parse
+
+      ensure_options(args)
+
+      #if args.first == 'init' && !runner.root?
+      #  init_project(*args)
+      #end
+
+      case @command
+      when :list
+        print_rules(*args)
+      when :help
+        print_help(*args)
+      else
+        runner.run(args.first)
+      end
+    end
+
+    # Parse command line arguments with just the prettiest
+    # little CLI parser there ever was.
+    def cli_parse
+      @command = nil
+
+      cli @argv,
+        "-R --rules"  => lambda{ @command = :list },
+        "-H --help"   => lambda{ @command = :help },
+        "-a --auto"   => method(:watch=),
+        "-f --fresh"  => method(:fresh!),
+        "-s --script" => method(:script=),
+        "-D --debug"  => method(:debug!)
+    end
+
+    #
+    def print_help(*names)
+      puts "-R --rules            list ruleset descriptions"
+      puts "-H --help             list these help options"
+      puts "-a --auto [TIME]      autorun every so many seconds"
+      puts "-f --fresh            clear digest for fresh run"
+      puts "-s --script [SCRIPT]  use alternate script"
+      puts "-D --debug            extra error information"
+    end
+
+    #
+    def ensure_options(args)
+      erropts = args.select{ |a| a.start_with?('-') }
+      unless erropts.empty?
+        raise "unsupported options #{erropts.join(' ')}" 
+      end
+    end
+
+    # Shall we make a fresh start of it, and remove all digests?
+    #
+    # Returns [Boolean]
+    def fresh?
+      @fresh
+    end
+
+    # Set fresh flag to true.
+    #
+    # Returns [Boolean]
+    def fresh! 
+      @fresh = true
+    end
+
+    # Is debug mode on?
+    #
+    # Returns [Boolean]
+    def debug?
+      $DEBUG
+    end
+
+    # Set debug flag to true.
+    #
+    # Returns [Boolean]
+    def debug! 
+      $DEBUG = true
+    end
+  
+    # Set the "watch" period --the rate at which
+    # autofiring of occurs.
+    #
+    # Returns [Fixnum[
+    def watch=(seconds)
+      @watch = seconds.to_i
+    end
+
+    # Use alternate rulebow script.
+    #
+    # Returns [Array]
+    def script=(script)
+      @script = script.to_s
+    end
+
+    # Initialize project for rulebow.
+    #
+    # Returns nothing.
+    def init_project(*args)
+      # anything to do?
+    end
+
+    # Print out a list of availabe manual triggers.
+    #
+    # Returns nothing.
+    def print_rules(*names)
+      names = nil if names.empty?
+      puts "(#{runner.root})"
+      runner.rulesets.each do |name, set|
+        next unless names.member?(name.to_s) if names
+        print "#{name}"
+        print " (#{set.chain.join(' ')})" unless set.chain.empty?
+        puts
+        set.docs.each_with_index do |d, i|
+          puts "  * #{d}"
+        end
+      end
+
+      #exit
+    end
+
+  end
+
+end

data/lib/rulebow/core_ext.rb

@@ -0,0 +1,3 @@
+require 'rulebow/core_ext/cli'
+require 'rulebow/core_ext/boolean'
+require 'rulebow/core_ext/true_class'

data/lib/rulebow/core_ext/boolean.rb

@@ -0,0 +1,10 @@
+module Boolean
+end
+
+class TrueClass
+  include Boolean
+end
+
+class FalseClass
+  include Boolean
+end

data/lib/rulebow/core_ext/cli.rb

@@ -0,0 +1,56 @@
+module Kernel
+  private
+  #
+  # CLI is based on Clap library
+  # Copyright (c) 2010 Michel Martens
+  #
+  def cli(*args)
+    opts = (Hash === args.last ? args.pop : nil)
+    argv = args.first || ARGV.dup
+    args = []
+
+    #raise ArgumentError unless opts
+
+    # Split option aliases.
+    opts = opts.inject({}) do |h,(k,v)|
+      k.to_s.split(/\s+/).each{|o| h[o]=v}; h
+    end
+
+    # Convert single dash flags into multiple flags.
+    argv = argv.inject([]) do |a, v|
+      if v[0,1] == '-' && v[1,1] != '-'
+        a.concat(v[1..-1].chars.map{|c| "-#{c}"})
+      else
+        a << v
+      end
+      a
+    end
+
+    while argv.any?
+      item = argv.shift
+      flag = opts[item]
+
+      if flag
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+
+    args
+  end
+end

data/lib/rulebow/core_ext/true_class.rb

@@ -0,0 +1,61 @@
+# We are going to try doing it this way. If it proves a problem
+# we'll make a special class.
+#
+class TrueClass
+  def empty?
+    false
+  end
+
+  def &(other)
+    other
+  end
+
+  def |(other)
+    other
+  end
+end
+
+#
+class Array
+  alias and_without_t :&
+  alias or_without_t :|
+
+  def |(other)
+    TrueClass === other ? dup : or_without_t(other)
+  end
+
+  def &(other)
+    TrueClass === other ? dup : and_without_t(other)
+  end
+end
+
+
+=begin
+class TrueArray < Array
+
+  def each; end
+
+  def size
+    1  # ?
+  end
+
+  def empty?
+    false
+  end
+
+  def &(other)
+    other.dup
+  end
+
+  def |(other)
+    other.dup
+  end
+
+  ## If this would have worked we would not have had
+  ## to override Array.
+  #def coerce(other)
+  #  return self, other
+  #end
+end
+=end
+

data/lib/rulebow/digest.rb

@@ -0,0 +1,240 @@
+module Rulebow
+
+  ##
+  # Digest class is used to read and write lists of files with their
+  # associated checksums. This class uses SHA1.
+  #
+  class Digest
+
+    # The name of the master digest.
+    DEFAULT_NAME = 'default'
+
+    # System instance. [System]
+    attr :system
+
+    # Digest of files as they are presently on disk. [Hash]
+    attr :current
+
+    # Digest of files as saved in the digest file. [Hash]
+    attr :saved
+
+    # Initialize new instance of Digest.
+    #
+    # Options
+    #   ignore - Instance of Ignore for filtering unwanted files. [Ignore]
+    #   mark   - Name of digest to load. [String]
+    #
+    def initialize(system)
+      @system = system
+      #@name   = (options[:name] || MASTER_NAME).to_s
+      #@ignore = options[:ignore]
+
+      @filename = system.state_file
+
+      @current = Hash.new{ |h,k| h[k.to_s] = {} }
+      @saved   = Hash.new{ |h,k| h[k.to_s] = {} }
+
+      read
+      refresh
+    end
+
+    # Get current digest for a given ruleset.
+    def [](ruleset)
+      for_ruleset(ruleset)
+    end
+
+    # The digest file's path.
+    #
+    # Returns [String]
+    def filename
+      @filename
+    end
+
+    # Remove all digests.
+    def clear_all
+      FileUtils.rm(filename)
+    end
+
+    # Load digest from file system.
+    #
+    # Returns nothing.
+    def read
+      return unless File.exist?(filename)
+
+      name = DEFAULT_NAME
+      save = Hash.new{ |h,k| h[k.to_s] = {} }
+
+      File.read(filename).lines.each do |line|
+        if md = /^\[(\w+)\]$/.match(line)
+          name = md[1]
+        end
+        if md = /^(\w+)\s+(.*?)$/.match(line)
+          save[name][md[2]] = md[1]
+        end
+      end
+
+      save.each do |name, digest|
+        @saved[name] = digest
+      end
+    end
+
+    # Refresh current digest for a given ruleset, or all rulesets if not given.
+    #
+    # Returns nothing.
+    def refresh(ruleset=nil)
+      if ruleset
+        ruleset = getruleset(ruleset)
+        current[ruleset.name.to_s] = ruleset.watchlist.digest
+      else
+        system.rulesets.each do |name, ruleset|
+          refresh(ruleset)
+        end
+      end
+    end
+
+    # Save current digest.
+    #
+    # Returns nothing.
+    def save(ruleset=nil)
+      if ruleset
+        ruleset = getruleset(ruleset)
+        refresh(ruleset)
+        saved[ruleset.name.to_s] = current[ruleset.name.to_s]
+      else
+        refresh
+        saved = current
+      end
+
+      dir = File.dirname(filename)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.open(filename, 'w') do |f|
+        f << to_s
+      end
+    end
+
+    # Remove digest.
+    def remove(ruleset)
+      case ruleset
+      when Ruleset
+        current.remove(ruleset.name)
+      else
+        current.remove(ruleset.to_str)
+      end
+      save
+    end
+
+    # Produce the representation of the digest that is stored to disk.
+    #
+    # Returns digest file format. [String] 
+    def to_s
+      s = ""
+      saved.each do |name, list|
+        s << "[#{name}]\n"
+        list.each do |path, id|
+          s << "#{id} #{path}\n"
+        end
+        s << "\n"
+      end
+      s
+    end
+
+    # Compute the sha1 identifer for a file.
+    #
+    # file - path to a file
+    #
+    # Returns [String] SHA1 digest string.
+    def checksum(file)
+      sha = ::Digest::SHA1.new
+      File.open(file, 'r') do |fh|
+        fh.each_line do |l|
+          sha << l
+        end
+      end
+      sha.hexdigest
+    end
+
+    # Filter files of those to be ignored.
+    #
+    # ruleset - instance of {Ruleset}
+    # files   - files to be filtered
+    #
+    # Return [Array<String>]
+    def filter(ruleset, files)
+      #case ruleset.ignore
+      #when Watchlist
+        ruleset.digest.filter(files)
+      #when Array
+      #  files.reject!{ |path| ignore.any?{ |ig| /^#{ig}/ =~ path } }
+      #else
+      #  files
+      #end
+    end
+
+    #
+    def for_ruleset(ruleset)
+      For.instance(self, getruleset(ruleset))
+    end
+
+  private
+
+    #
+    def getruleset(ruleset)
+      case ruleset
+      when Ruleset
+        ruleset
+      else
+        system.rulesets[ruleset.to_sym]
+      end
+    end
+
+    ##
+    #
+    class For
+
+      #
+      def self.instance(digest, ruleset)
+        @instance ||= {}
+        @instance[[digest, ruleset]] ||= new(digest, ruleset)
+      end
+
+      def initialize(digest, ruleset)
+        @digest  = digest
+        @ruleset = ruleset
+      end
+
+      attr :digest
+
+      attr :ruleset
+
+      def name
+        ruleset.name.to_s
+      end
+
+      def current
+        digest.current[name]
+      end
+
+      def saved
+        digest.saved[name]
+      end
+
+      # Filter files.
+      #
+      # Return [Array<String>]
+      def filter(files)
+        ruleset.watchlist.filter(files)
+        #case ruleset.ignore
+        #when Ignore
+        #  ruleset.ignore.filter(list)
+        #when Array
+        #  list.reject!{ |path| ignore.any?{ |ig| /^#{ig}/ =~ path } }
+        #else
+        #  list
+        #end
+      end
+
+    end
+
+  end
+
+end