rulebow 0.4.0

data/lib/rulebow/fact.rb

@@ -0,0 +1,118 @@
+module Rulebow
+
+  ##
+  # Rulebow's logic system is a *set logic* system. That means an empty set, `[]`
+  # is treated as `false` and a non-empty set is `true`.
+  #
+  # Rulebow handles complex logic by building-up lazy logic constructs. It's logical
+  # operators are defined using single charcter symbols, e.g. `&` and `|`.
+  #
+  class Fact
+    #
+    def initialize(&procedure)
+      @procedure = procedure
+    end
+
+    #
+    def call(digest)
+      set @procedure.call(digest)
+    end
+
+    # set or
+    def |(other)
+      Fact.new{ |d| set(self.call(d)) | set(other.call(d)) }
+    end
+
+    # set and
+    def &(other)
+      Fact.new{ |d| set(self.call(d)) & set(other.call(d)) }
+    end
+
+  private
+
+    #
+    def set(value)
+      case value
+      when Array
+        value.compact
+      when Boolean
+        value ? true : []
+      else
+        [value]
+      end
+    end
+
+  end
+
+  ##
+  # This subclass of Fact is specialized for file change conditions.
+  #
+  class FileFact < Fact
+    # Initialize new instance of FileFact.
+    #
+    # pattern - File glob or regular expression. [String,Regexp]
+    # digest  - The system digest. [Digest]
+    #
+    def initialize(pattern, &coerce)
+      @pattern = pattern
+      @coerce  = coerce
+    end
+
+    # File glob or regular expression.
+    attr :pattern
+
+    #
+    attr :coerce
+
+    # Process logic.
+    def call(digest)
+      result = []
+
+      case pattern
+      when Regexp
+        list = Dir.glob('**/*', File::FNM_PATHNAME)
+        list = digest.filter(list)  # excludes ignored files (odd way to do it but if should work)
+        list.each do |fname|
+          if md = pattern.match(fname)
+            if digest.current[fname] != digest.saved[fname]
+              result << Match.new(fname, md)
+            end
+          end
+        end
+        # NOTE: The problem with using the digest list, is that if a rule
+        #       adds a new file to the project, then a subsequent rule needs
+        #       to be able to see it.
+        #@digest.current.keys.each do |fname|
+        #  if md = pattern.match(fname)
+        #    if @digest.current[fname] != @digest.saved[fname]
+        #      result << Match.new(fname, md)
+        #    end
+        #  end
+        #end
+      else
+        list = Dir.glob(pattern, File::FNM_PATHNAME)
+        list = digest.filter(list)   # excludes ignored files (odd way to do it but if should work)
+        list.each do |fname|
+          if digest.current[fname] != digest.saved[fname]
+            result << fname
+          end
+        end
+        #@digest.current.keys.each do |fname|
+        #  if md = File.fnmatch?(pattern, fname, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        #    if @digest.current[fname] != @digest.saved[fname]
+        #      result << Match.new(fname, md)
+        #    end
+        #  end
+        #end
+      end
+
+      if coerce
+        return [coerce.call(result)].flatten.compact
+      else
+        return result
+      end
+    end
+
+  end
+
+end

data/lib/rulebow/ignore.rb

@@ -0,0 +1,136 @@
+module Rulebow
+
+  ##
+  # Deprecated: Encapsulates list of file globs to be ignored.
+  # 
+  class Ignore
+    include Enumerable
+
+    # Initialize new instance of Ignore.
+    #
+    # Returns nothing.
+    def initialize(ignore)
+      @ignore = ignore.to_a
+    end
+
+    # Filter a list of files in accordance with the 
+    # ignore list.
+    #
+    # files - The list of files. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def filter(files)
+      list = []
+      files.each do |file|
+        hit = any? do |pattern|
+          match?(pattern, file)
+        end
+        list << file unless hit
+      end
+      list
+    end
+
+    # Ignore file.
+    #def file
+    #  @file ||= (
+    #    Dir["{.gitignore,.hgignore}"].first
+    #  )
+    #end
+
+    #
+    def each
+      to_a.each{ |g| yield g }
+    end
+
+    #
+    def size
+      to_a.size
+    end
+
+    #
+    def to_a
+      @ignore #||= load_ignore
+    end
+
+    #
+    def replace(*globs)
+      @ignore = globs.flatten
+    end
+
+    #
+    def concat(*globs)
+      @ignore.concat(globs.flatten)
+    end
+
+  #private
+
+    #def all_ignored_files
+    #  list = []
+    #  ignore.each do |glob|
+    #    if glob.start_with?('/')
+    #      list.concat Dir[File.join(@root, glob)]
+    #    else
+    #      list.concat Dir[File.join(@root, '**', glob)]
+    #    end
+    #  end
+    #  list
+    #end
+
+=begin
+    # Load ignore file. Removes blank lines and line starting with `#`.
+    #
+    # Returns [Array<String>]
+    def load_ignore
+      f = file
+      i = []
+      if f && File.exist?(f)
+        File.read(f).lines.each do |line|
+          glob = line.strip
+          next if glob.empty?
+          next if glob.start_with?('#')
+          i << glob
+        end
+      end
+      i
+    end
+=end
+
+    # Given a pattern and a file, does the file match the
+    # pattern? This code is based on the rules used by
+    # git's .gitignore file.
+    #
+    # TODO: The code is probably not quite right.
+    #
+    # Returns [Boolean]
+    def match?(pattern, file)
+      if pattern.start_with?('!')
+        return !match?(pattern.sub('!','').strip)
+      end
+
+      dir = pattern.end_with?('/')
+      pattern = pattern.chomp('/') if dir
+
+      if pattern.start_with?('/')
+        fnmatch?(pattern.sub('/',''), file)
+      else
+        if dir
+          fnmatch?(File.join(pattern, '**', '*'), file) ||
+          fnmatch?(pattern, file) && File.directory?(file)
+        elsif pattern.include?('/')
+          fnmatch?(pattern, file)
+        else
+          fnmatch?(File.join('**',pattern), file)
+        end
+      end
+    end
+
+    # Shortcut to `File.fnmatch?` method.
+    #
+    # Returns [Boolean]
+    def fnmatch?(pattern, file, mode=File::FNM_PATHNAME)
+      File.fnmatch?(pattern, file, File::FNM_PATHNAME)
+    end
+
+  end
+
+end

data/lib/rulebow/match.rb

@@ -0,0 +1,26 @@
+module Rulebow
+
+  # Match is a subclass of a string that also stores the 
+  # MatchData then matched against it in a Regexp comparison.
+  #
+  class Match < String
+    # Initialize a new instance of Match.
+    #
+    # string    - The string. [String]
+    # matchdata - The match data. [MatchData]
+    #
+    def initialize(string, matchdata)
+      replace(string)
+      @matchdata = matchdata
+    end
+
+    # The match data that resulted from
+    # a successful Regexp against the string.
+    #
+    # Returns [MatchData]
+    def matchdata
+      @matchdata
+    end
+  end
+
+end

data/lib/rulebow/rule.rb

@@ -0,0 +1,63 @@
+module Rulebow
+
+  # Rule class encapsulates a *rule* definition.
+  #
+  class Rule
+    # Initialize new instanance of Rule.
+    #
+    # fact   - Conditional fact. [Fact,Boolean]
+    # action - Procedure to run if logic condition is met. [Proc]
+    #
+    def initialize(fact, options={}, &action)
+      @fact   = fact
+      @action = action
+    end
+
+    # Access to the rule's logic condition. [Fact]
+    attr :fact
+
+    # Access to the rule's action procedure.
+    #
+    # Returns [Proc]
+    def to_proc
+      @action
+    end
+
+    # Apply rule, running the rule's procedure if the fact is true.
+    #
+    # Returns nothing.
+    def apply(digest)
+      case fact
+      when false, nil
+      when true
+        call()
+      else
+        result_set = fact.call(digest)
+        if result_set && !result_set.empty?
+          call(result_set)
+        end
+      end
+    end
+
+    # Alias for #apply.
+    alias :invoke :apply
+
+  protected
+
+    # Run rule procedure.
+    #
+    # result_set - The result set returned by the logic condition.
+    #
+    # Returns whatever the procedure returns. [Object]
+    def call(*result_set)
+      if @action.arity == 0
+        @action.call
+      else
+        #@action.call(session, *result_set)
+        @action.call(*result_set)
+      end
+    end
+
+  end
+
+end

data/lib/rulebow/ruleset.rb

@@ -0,0 +1,308 @@
+module Rulebow
+
+  ##
+  # Rulesets provides namespace isolation for facts, rules and methods.
+  #
+  class Ruleset < Module
+
+    # Instantiate new ruleset.
+    #
+    # Arguments
+    #    system - The system to which this ruleset belongs. [System]
+    #    name   - Name of the ruleset.
+    #
+    # Yields the script defining the ruleset rules.
+    def initialize(system, name, &block)
+      extend ShellUtils
+      extend system
+      extend self
+
+      @scripts  = []
+      @rules    = []
+      @docs     = []
+      @requires = []
+
+      @name, @chain = parse_ruleset_name(name)
+
+      @session = system.session
+
+      @watchlist = WatchList.new(:ignore=>system.ignore)
+
+      module_eval(&block) if block
+    end
+
+    # Ruleset name
+    attr :name
+
+    # Description of ruleset.
+    attr :docs
+
+    # Chain or dependencies.
+    attr :chain
+
+    # Session object can be used to passing information around between rulesets.
+    attr :session
+
+    # Rule scripts.
+    attr :scripts
+
+    # Array of defined facts.
+    #attr :facts
+
+    # Array of defined rules.
+    attr :rules
+
+    # Files to watch for this ruleset.
+    attr :watchlist
+
+    # Import from another file, or glob of files, relative to project root.
+    #
+    # TODO: Should importing be relative to the importing file? Currently
+    #       it is relative to the project root.
+    #
+    # Returns nothing.
+    def import(*globs)
+      globs.each do |glob|
+        #if File.relative?(glob)
+        #  dir = Dir.pwd  #session.root #File.dirname(caller[0])
+        #  glob = File.join(dir, glob)
+        #end
+        Dir[glob].each do |file|
+          next unless File.file?(file)  # add warning
+          next if @scripts.include?(file)
+          @scripts << file
+          module_eval(File.read(file), file)
+        end
+      end
+    end
+
+    # Add paths to be watched.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def watch(*globs)
+      @watchlist.accept(globs) unless globs.empty?
+      @watchlist
+    end
+
+    # Replace paths to be watched.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def watch!(*globs)
+      @watchlist.accept!(globs)
+    end
+
+    # Add paths to be ignored in file rules.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore(*globs)
+      @watchlist.ignore(globs) unless globs.empty?
+    end
+
+    # Replace globs in ignore list.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore!(*globs)
+      @watchlist.ignore!(globs)
+    end
+
+    # Define a dependency chain.
+    #
+    # Returns [Array<Symbol>]
+    def chain=(*rulesets)
+      @chain = rulesets.map{ |b| b.to_sym }
+    end
+
+    # Provide a ruleset description.
+    #
+    # Returns [String]
+    def desc(description)
+      @docs << description
+    end
+
+    # Define a rule. Rules are procedures that are tiggered 
+    # by logical facts.
+    #
+    # Examples
+    #   rule :rdocs? do |files|
+    #     sh "rdoc --output doc/rdoc " + files.join(" ")
+    #   end
+    #
+    # TODO: Allow for an expression array that conjoins them with AND logic.
+    #
+    # Returns [Rule]
+    def rule(expression, &block)
+      case expression
+      when Hash
+        expression.each do |fact, task|
+          fact = define_fact(fact)
+          task = define_task(task)
+          @rules << Rule.new(fact, &task)
+        end
+      else
+        fact = define_fact(expression)
+        @rules << Rule.new(fact, &block)
+      end
+
+      #rule = Rule.new(@_facts, get_rule_options, &procedure)
+      #@rules << rule
+      #clear_rule_options
+
+      return @rules
+    end
+
+    # Defines a fact. Facts define conditions that are used to trigger
+    # rules. Named facts are defined as methods to ensure that only one fact
+    # is ever defined for a given name. Calling fact again with the same name
+    # as a previously defined fact will redefine the condition of that fact.
+    #
+    # Examples
+    #   fact :no_doc? do
+    #     File.directory?('doc')
+    #   end
+    #
+    # Returns the name if name and condition is given. [Symbol]
+    # Returns a fact in only name or condition is given. [Fact]
+    def fact(name=nil, &condition)
+      if name && conditon
+        define_method(name) do
+          Fact.new(&condition)  # TODO: maybe we don't really need the cache after all
+        end
+        name
+      else
+        define_fact(name || condition)
+      end
+    end
+
+    # Will probably be deprecated.
+    alias :state :fact
+
+    # Define a file fact.
+    #
+    # TODO: Probably will add this back & limit `fact` so it can't be used for file facts.
+    #
+    # Returns [FileFact]
+    #def file(patterns, &coerce)
+    #  FileFact.new(patterns, &coerce)
+    #end
+
+    # Convenince method for defining environment variable facts.
+    #
+    # Examples
+    #   rule env('PATH'=>/foo/) => :dosomething
+    #
+    # Returns [Fact]
+    def env(name_to_pattern)
+      Fact.new do
+        name_to_pattern.any? do |name, re|
+          re === ENV[name.to_s]  # or `all?` instead?
+        end
+      end
+    end
+
+    # TODO: Private rulesets that can't be run from the CLI?
+    #       Hmmm... maybe instead it can work like rake, if docs is empty
+    #       it can't be run from the command line.
+    #
+    #def privatize
+    #  @privatized = true
+    #end
+
+    # Issue notification.
+    #
+    # Returns nothing.
+    def notify(message, options={})
+      title = options.delete(:title) || 'Rulebow Notification'
+      Notify.notify(title, message.to_s, options)
+    end
+
+    # Any requires made within a ruleset will not be actually 
+    # required until a rule is run.
+    #
+    # TODO: This feature has yet to be implemented.
+    #
+    # Returns nothing.
+    def require(feature=nil)
+      @requires << feature if feature
+      @requires
+    end
+
+    # Better inspection string.
+    def inspect
+      if chain.empty?
+        "#<Ruleset #{name}>"
+      else
+        "#<Ruleset #{name} " + chain.join(' ') + ">"
+      end
+    end
+
+    # TODO: Good idea?
+    def to_s
+      name.to_s
+    end
+
+  private
+
+    # Define a fact.
+    #
+    # Returns [Fact]
+    def define_fact(fact)
+      case fact
+      when Fact
+        fact
+      when String, Regexp
+        @watchlist.accept(fact)
+        FileFact.new(fact)
+      when Symbol
+        Fact.new{ send(fact) }
+      when true, false, nil
+        Fact.new{ fact }
+      else #when Proc
+        Fact.new(&fact)
+      end
+    end
+
+    #
+    def define_task(task)
+      case task
+      when Symbol
+        Proc.new do |*a|
+          meth = method(task)
+          if meth.arity == 0
+            meth.call
+          else
+            meth.call(*a)
+          end
+        end
+      else
+        task.to_proc
+      end
+    end
+
+    # Parse out a ruleset's name from it's ruleset dependencies.
+    #
+    # name - ruleset name
+    #
+    # Returns [Array]
+    def parse_ruleset_name(name)
+      if Hash === name
+        raise ArgumentError if name.size > 1       
+        list = [name.values].flatten.map{ |b| b.to_sym }
+        name = name.keys.first
+      else
+        list = []
+      end
+      return name.to_sym, list
+    end
+  end
+
+end
+
+