ergo 0.3.0

data/lib/ergo/core_ext/true_class.rb

@@ -0,0 +1,58 @@
+# We are going to try doing it this way. If i proves a problem
+# we'll make a special class.
+#
+class TrueClass
+  def empty?
+    false
+  end
+
+  def &(other)
+    other
+  end
+
+  def |(other)
+    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
+
+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

data/lib/ergo/digest.rb

@@ -0,0 +1,196 @@
+module Ergo
+
+  ##
+  # 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.
+    MASTER_NAME = 'Master'
+
+    # The digest file to use if the root directory has a `log/` directory.
+    DIRECTORY = ".ergo/digest"
+
+    # Get the name of the most recent digest given a selection of names
+    # from which to choose.
+    #
+    # names - Selection of names. [Array<String>]
+    #
+    # Returns the digests name. [String]
+    def self.latest(*names)
+      names = names.select do |name|
+        File.exist?(File.join(DIRECTORY, "#{name}.digest"))
+      end
+      names.max do |name|
+         File.mtime(File.join(DIRECTORY, "#{name}.digest"))
+      end
+    end
+
+    # Remove all digests.
+    def self.clear_digests
+      Dir.glob(File.join(DIRECTORY, "*.digest")).each do |file|
+        FileUtils.rm(file)
+      end
+    end
+
+    # Remove digest by name.
+    def self.remove_digest(name)
+      file = File.join(DIRECTORY, "#{name}.digest")
+      if file.exist?(file)
+        FileUtils.rm(file)
+      end
+    end
+
+    # Instance of Ignore is used to filter "boring files". 
+    #
+    # Returns [Ignore]
+    attr :ignore
+
+    # Name of digest, which corresponds to the rule bookmark.
+    #
+    # Returns [Ignore]
+    attr :name
+
+    # Set of files as they appear on disk.
+    attr :current
+
+    # Set of files as saved in the digest.
+    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(options={})
+      @ignore = options[:ignore]
+      @name   = options[:name] || MASTER_NAME
+
+      @current = {}
+      @saved   = {}
+
+      read
+      refresh
+    end
+
+    # The digest file's path.
+    #
+    # Returns [String]
+    def filename
+      File.join(DIRECTORY, "#{name}.digest")
+    end
+
+    # Load digest from file system.
+    #
+    # Returns nothing.
+    def read
+      file = filename
+
+      # if the digest doesn't exist fallback to master digest
+      unless File.exist?(file)
+        file = File.join(DIRECTORY, "#{MASTER_NAME}.digest")
+      end
+
+      return unless File.exist?(file)
+
+      File.read(file).lines.each do |line|
+        if md = /^(\w+)\s+(.*?)$/.match(line)
+          @saved[md[2]] = md[1]
+        end
+      end
+    end
+
+=begin
+    # Gather current digest for all files.
+    #
+    # Returns nothing.
+    def refresh
+      Dir['**/*'].each do |path|
+        if File.directory?(path)
+          # how to handle directories as a whole?
+        elsif File.exist?(path)
+          id = checksum(path)
+          @current[path] = id
+        end
+      end
+    end
+=end
+
+    # Gather current digest for all files.
+    #
+    # Returns nothing.
+    def refresh
+      list = Dir['**/*']
+      list = filter(list)
+      list.each do |path|
+        if File.directory?(path)
+          # how to handle directories as a whole?
+        elsif File.exist?(path)
+          id = checksum(path)
+          @current[path] = id
+        end
+      end
+    end
+
+    # Save current digest.
+    #
+    # Returns nothing.
+    def save
+      FileUtils.mkdir_p(DIRECTORY) unless File.directory?(DIRECTORY)
+      File.open(filename, 'w') do |f|
+        f << to_s
+      end
+    end
+
+    # Remove digest.
+    def remove
+      if File.exist?(filename)
+        FileUtils.rm(filename)
+      end
+    end
+
+    # Produce the test representation of the digest that is stored to disk.
+    #
+    # Returns digest file format. [String] 
+    def to_s
+      s = ""
+      current.each do |path, id|
+        s << "#{id} #{path}\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.
+    #
+    # Return [Array<String>]
+    def filter(list)
+      case ignore
+      when Ignore
+        ignore.filter(list)
+      when Array
+        list.reject{ |path| ignore.any?{ |ig| /^#{ig}/ =~ path } }
+      else
+        list
+      end
+    end
+
+  end
+
+end

data/lib/ergo/ignore.rb

@@ -0,0 +1,146 @@
+module Ergo
+
+  # This file can be used as an alternative to using the #ignore method 
+  # to define what paths to ignore.
+  IGNORE_FILE = '.ergo/ignore'
+
+  ##
+  # Encapsulates list of file globs to be ignored.
+  #
+  class Ignore
+    include Enumerable
+
+    # Initialize new instance of Ignore.
+    #
+    # Returns nothing.
+    def initialize(options={})
+      @file = options[:file]
+      @root = options[:root]
+
+      @ignore = load_ignore
+    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
+
+    # Returns [Array<String>]
+    #def ignore
+    #  @ignore ||= load_ignore
+    #end
+
+    # Ignore file.
+    def file
+      @file ||= (
+        Dir["{.gitignore,.hgignore,#{IGNORE_FILE}}"].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
+
+    # 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
+
+    # 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/ergo/match.rb

@@ -0,0 +1,26 @@
+module Ergo
+
+  # 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 intialize(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/ergo/rule.rb

@@ -0,0 +1,134 @@
+module Ergo
+
+  # Rule class encapsulates a *rule* definition.
+  #
+  class Rule
+    # Initialize new instanance of Rule.
+    #
+    # state     - State condition. [Logic]
+    # procedure - Procedure to run if logic condition is met. [Proc]
+    #
+    # Options
+    #   desc - Description of rule. [String]
+    #   mark - List of bookmark names. [Array<String>]
+    #
+    def initialize(state, options={}, &procedure)
+      self.state   = state
+      self.desc    = options[:desc] || options[:description]
+      self.mark    = options[:mark] || options[:bookmarks]
+      self.private = options[:private]
+
+      @proc = procedure
+    end
+
+    # Access logic condition.
+    #
+    # Returns [State]
+    attr :state
+
+    # Description of rule.
+    #
+    # Returns [String]
+    def description
+      @description
+    end
+
+    # Returns the description.
+    #
+    # Returns [String]
+    alias :to_s :description
+
+    # Rule bookmarks.
+    #
+    # Returns [Array<String>]
+    def bookmarks
+      @bookmarks
+    end
+
+    #
+    def bookmark?(name)
+      @bookmarks.include?(name.to_s)
+    end
+    alias :mark? :bookmark?
+
+    # Is the rule private? A private rule does not run with the "master book",
+    # only when it's specific book is invoked.
+    def private?
+      @private
+    end
+
+    # Rule procedure.
+    #
+    # Returns [Proc]
+    def to_proc
+      @proc
+    end
+
+    # Apply rule, running the rule's procedure if the state
+    # condition is satisfied.
+    #
+    # Returns nothing.
+    def apply(digest)
+      case state
+      when true
+        call
+      when false, nil
+      else
+        result_set = state.call(digest)
+        if result_set && !result_set.empty?
+          call(result_set)
+        end
+      end
+    end
+
+    # Alias for #apply.
+    alias :invoke :apply
+
+    # Convenience method for producing a rule list.
+    #
+    # Rertuns [Array]
+    def to_a
+      [description, bookmarks, private?]
+    end
+
+  protected
+
+    # Set state of rule.
+    def state=(state)
+      #raise unless State === state || Boolean === state
+      @state = state
+    end
+
+    # Set bookmark(s) of rule.
+    def mark=(names)
+      @bookmarks = Array(names).map{ |b| b.to_s }
+    end
+
+    # Set privacy of rule. A private rule does not run with the "master book",
+    # only when it's specific book is invoked.
+    def private=(boolean)
+      @private = !! boolean
+    end
+
+    # Set description of rule.
+    def desc=(string)
+      @description = string.to_s
+    end
+
+    # Run rule procedure.
+    #
+    # result_set - The result set returned by the logic condition.
+    #
+    # Returns whatever the procedure returns. [Object]
+    def call(*result_set)
+      if @proc.arity == 0
+        @proc.call
+      else
+        #@procedure.call(session, *args)
+        @proc.call(*result_set)
+      end
+    end
+
+  end
+
+end