rulebow 0.4.0

data/lib/rulebow/system.rb

@@ -0,0 +1,153 @@
+module Rulebow
+
+  # Master system instance.
+  #
+  # Returns [System]
+  #def self.system
+  #  @system ||= System.new
+  #end
+
+  ##
+  #
+  class System < Module
+
+    RULEBOOK_GLOB = "{,.,_}{R,r}ulebook{,.rb}"
+
+    # Initialize new System instance.
+    #
+    def initialize(options={})
+      extend self
+      extend ShellUtils
+
+      @root   = options[:root]   || Dir.pwd
+      @ignore = options[:ignore] || [] #Ignore.new
+
+      @rulebook   = options[:rulebook]
+      @state_file = options[:statefile]
+
+      @session = OpenStruct.new
+
+      @scripts  = []
+      @rules    = []
+      #@facts    = []
+
+      @digests  = {}
+      @rulesets = {}
+
+      import(*rulebook)
+    end
+
+    # Project's root directory. [String]
+    attr :root
+
+    # Session variables. [Hash]
+    attr :session
+
+    # Digests [Hash]
+    attr :digests
+
+    # Rulesets indexed by name. [Hash]
+    attr :rulesets
+
+    # Rulebook file.
+    def rulebook
+      @rulebook ||= Dir[File.join(root, RULEBOOK_GLOB)].first
+    end
+
+    # State file.
+    def state_file
+      @state_file ||= rulebook.chomp('.rb') + '.state'
+    end
+
+    #
+    #def default(*rulesets)
+    #  ruleset :default => rulesets
+    #end
+
+    # Rulesets provide a separate space for rules which are only
+    # run when the ruleset name is specifically given.
+    #
+    # Return [Ruleset]
+    def ruleset(name_and_chain, &block)
+      name, chain = parse_ruleset_name(name_and_chain)
+      if @rulesets.key?(name)
+        ruleset = @rulesets[name]
+        ruleset.update(chain, &block)
+      else
+        ruleset = Ruleset.new(self, name_and_chain, &block)
+        @rulesets[name] = ruleset
+      end
+      ruleset
+    end
+
+    # Import from another file, or glob of files, relative to project root.
+    #
+    # TODO: Should importing be relative to the importing file?
+    #
+    # 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 ignored in file rules.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore(*globs)
+      @ignore.concat(globs) unless globs.empty?
+      @ignore
+    end
+
+    # Replace globs in ignore list.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore!(*globs)
+      @ignore.replace(globs)
+      @ignore
+    end
+
+    #
+    def inspect
+      "#<Rulebow::System>"
+    end
+
+    # Home directory.
+    #
+    # Returns [String]
+    def home
+      @home ||= File.expand_path('~')
+    end
+
+  private
+
+    # Parse out a ruleset's name from it's ruleset dependencies.
+    #
+    # 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

data/lib/rulebow/watchlist.rb

@@ -0,0 +1,203 @@
+module Rulebow
+
+  ##
+  # Encapsulates list of file globs to be watched.
+  # 
+  class WatchList
+
+    #include Enumerable
+
+    # Initialize new instance of Ignore.
+    #
+    # Returns nothing.
+    def initialize(options={})
+      @accept = options[:accept].to_a.flatten
+      @ignore = options[:ignore].to_a.flatten
+    end
+
+    # Project's root directory.
+    attr :root
+
+    # Filter a list of files in accordance with the 
+    # accept and ignore lists.
+    #
+    def filter(files)
+      filter_ignore(filter_accept(files))
+    end
+
+    # Filter a list of files in accordance with the 
+    # ignore list.
+    #
+    # files - The list of files. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def filter_accept(files)
+      list = []
+      files.each do |file|
+        hit = @accept.any? do |pattern|
+          match?(pattern, file)
+        end
+        list << file if hit
+      end
+      list
+    end
+
+    # Filter a list of files in accordance with the 
+    # ignore list.
+    #
+    # files - The list of files. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def filter_ignore(files)
+      list = []
+      files.each do |file|
+        hit = @ignore.any? do |pattern|
+          match?(pattern, file)
+        end
+        list << file unless hit
+      end
+      list
+    end
+
+    #
+    #def each
+    #  to_a.each{ |g| yield g }
+    #end
+
+    #
+    #def size
+    #  to_a.size
+    #end
+
+    #
+    #def to_a
+    #  @list
+    #end
+
+    #
+    def accept(*globs)
+      @accept.concat(globs.flatten)
+    end
+
+    #
+    def accept!(*globs)
+      @accept.replace(globs.flatten)
+    end
+
+    #
+    def ignore(*globs)
+      @ignore.concat(globs.flatten)
+    end
+
+    #
+    def ignore!(*globs)
+      @ignore.replace(globs.flatten)
+    end
+
+    # Get a current digest.
+    #
+    # Returns digest. [Hash]
+    def digest(root=nil)
+      if root
+        Dir.chdir(root) do
+          read_digest
+        end
+      else
+        read_digest
+      end
+    end
+
+  private
+
+    def read_digest
+      dig = {}
+      list = filter(Dir.glob('**/*', File::FNM_PATHNAME))
+      list.each do |path|
+        if File.directory?(path)
+          # TODO: how to handle directories as a whole?
+        elsif File.exist?(path)
+          dig[path] = checksum(path)
+        end
+      end
+      dig
+    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.
+    #
+    # TODO: Handle regular expressions.
+    #
+    # Returns [Boolean]
+    def match?(pattern, file)
+      if Regexp === pattern
+        return pattern.match(file) ? true : false
+      end
+
+      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
+
+    # 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
+
+=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
+
+  end
+
+end

data/man/.gitignore

@@ -0,0 +1,2 @@
+*.html
+*.1

data/man/ergo.1.ronn

@@ -0,0 +1,50 @@
+ergo(1) -- Ruby rules-based automated build tool
+===============================================
+
+## SYNOPSIS
+
+`ergo`
+`ergo` <bookmark> [<arg>...]<br>
+`ergo` `-R`|`--rules`<br>
+`ergo` `-h`|`--help`<br>
+
+
+## DESCRIPTION
+
+Ergo is an *autological* build tool, in that it is used to automate
+build procedure via logical rules-based programming. The developer only
+ever needs to run a single command, `ergo`, and the majority of maintenance
+details of a project are handled. Ergo largely replaces the need of more
+traditional task-based build tools, but it does not complete supplant them.
+They reamin a useful complement for one-off manual build procedures. 
+
+
+## OPTIONS
+
+These options act as subcommands:
+
+  * `-R`, `--rules`:
+    Display the described rules defined in the project's ergo script(s).
+
+  * `-h`, `--help`:
+    Display this help message.
+
+
+## ISSUES
+
+**Ergo** depends on **Ronn** to provide this man-page and command help message.
+Ronn depends on hpricot and rdiscount, extension libraries that are non-trivial
+to install on some systems. A more portable version of this program would be
+welcome.
+
+
+## COPYRIGHT
+
+Ergo is Copyright (c) 2009 Thomas Sawyer, Rubyworks
+
+Ergo is distributed in accordance to the **GPL-3** license.
+
+
+## SEE ALSO
+
+ronn(1), rake(1)

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: rulebow
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: notify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rulebow is an automated build tool with a set-logic based rule system.
+  Rulebow is the perfect tool for performing continuous integration during development.
+email:
+- transfire@gmail.com
+executables:
+- bow
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+- HISTORY.md
+files:
+- .index
+- .yardopts
+- bin/bow
+- demo/03_runner/01_applying_rules.md
+- demo/applique/ae.rb
+- demo/applique/rulebow.rb
+- demo/overview.md
+- lib/rulebow/cli.rb
+- lib/rulebow/core_ext/boolean.rb
+- lib/rulebow/core_ext/cli.rb
+- lib/rulebow/core_ext/true_class.rb
+- lib/rulebow/core_ext.rb
+- lib/rulebow/digest.rb
+- lib/rulebow/fact.rb
+- lib/rulebow/ignore.rb
+- lib/rulebow/match.rb
+- lib/rulebow/rule.rb
+- lib/rulebow/ruleset.rb
+- lib/rulebow/runner.rb
+- lib/rulebow/shellutils.rb
+- lib/rulebow/system.rb
+- lib/rulebow/watchlist.rb
+- lib/rulebow.rb
+- lib/rulebow.yml
+- man/.gitignore
+- man/ergo.1
+- man/ergo.1.html
+- man/ergo.1.ronn
+- README.md
+- HISTORY.md
+- LICENSE.txt
+homepage: http://rubyworks.github.com/rulebow
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: An autological build tool.
+test_files: []
+has_rdoc: