exegesis 0.0.4 → 0.0.5

data/CHANGELOG

@@ -1,4 +1,14 @@
-= 0.0.3 - 0.0.4
+* 0.0.5
+	* Split up the project into three projects
+		- Exegesis remains as the FileSystem API
+		- Katuv is a new tool for defining and dealing with internal DSLs
+		- Eisegesis is the build tool proper, which uses Katuv and Exegesis to
+		provide build related functionality.
+	* Prepare for splitting out Drosophila, which contains the flyweight
+	implementation (mostly so I never have to write another Flyweight again)
+	* Update some docs to reflect the changes
+
+* 0.0.3 - 0.0.4
 	* Make sure Forwardable gem dependency gets loaded at the appropriate
 		load-level
 	* Skirt a very rare crash during tests (happens _literally_ only to my one
@@ -12,5 +22,4 @@
 	everything stays synced.
 
 * 0.0.1
-
 	Initial Release

data/NOTES.md

@@ -1,3 +1,10 @@
+# Nota Bene
+
+Much of this is out of date, now that things are split up. It remains as an
+interesting relic of a time long since forgotten. Some day it will be
+unceremoniously killed.
+
+
 # Basic structure
 
 ## Implementation
@@ -212,3 +219,20 @@ the various subdirs.
   - set up hooks (run tests, etc)
   - Set up standard docs (README, AUTHORS, LICENSE, etc)
 
+# Notes on how projects should work
+
+* Project is the thing that interfaces with rake.
+  - creating a project creates a series of directory tasks, provides the
+    exegesis DSL for specifying package deps/whatever in whatever language
+  - it should automatically generate `clean`, `distclean`, and `scaffold`
+    tasks, the last of which is just a task that depends on all the directory
+    tasks
+  - it should use the environment for configuration.
+
+* The Project should also automatically generate a default task which builds all
+  the binaries, tasks which build each binary individually, and a `install` task
+  which copies it to the appropriate place on the PATH
+
+* The Project should, in particular, support multi-threaded compilation.
+
+

data/lib/exegesis.rb

@@ -1,3 +1,4 @@
+module Exegesis; end
 
 ################################################################################
 #load order matters here. These are sorted into load-levels Level-0 files must
@@ -30,20 +31,3 @@ require 'exegesis/base_directory'
 #-------------------------------------------------------------------------------
 #load whenever
 require 'exegesis/version'
-
-################################################################################
-
-
-# Exegesis is a tool for automating many parts of the development of C projects.
-# Following a convention-over-configuration model.
-#
-# It provides tools to:
-#
-#   * Create skeleton projects
-#   * Build
-#   * Testing
-#   * Packaging
-#
-# Though C is presently the only supported language, it is the aim of Exegesis to
-# support tooling for other compiled languages.
-module Exegesis; end

data/lib/exegesis/base_directory.rb

@@ -13,17 +13,19 @@
 # Collaborators:
 #  [Directory]
 #  [SourceFile]
-class BaseDirectory < Directory
-  # @param root [String] the root path of the project
-  # @param searcher [FileSearcher] an object used to search for files in a given
-  #    directory
-  def initialize(root, searcher = FileSearcher)
-    super(nil, root, searcher)
-  end
+module Exegesis
+  class BaseDirectory < Directory
+    # @param root [String] the root path of the project
+    # @param searcher [FileSearcher] an object used to search for files in a given
+    #    directory
+    def initialize(root, searcher = FileSearcher)
+      super(nil, root, searcher)
+    end
 
-  # The path to the root of the project
-  def path
-    name
+    # The path to the root of the project
+    def path
+      name
+    end
+    alias root path
   end
-  alias root path
 end

data/lib/exegesis/directory.rb

@@ -11,23 +11,33 @@
 # Collaborators:
 #   SourceFile
 #   Directory
-class Directory
-  include FileSystemEntity
+module Exegesis
+  class Directory
+    include FileSystemEntity
 
-  delegate [:directories, :files] => :searcher
-  alias children directories
+    delegate [:directories, :files] => :searcher
+    alias children directories
 
-  private
+    def find_directory(dirname)
+      directories.select { |d| d.name == dirname || d.name + '/' == dirname }.first
+    end
 
-  attr_reader :searcher
+    def find_file(filename)
+      files.select { |f| f.name == filename }.first
+    end
 
-  # @param parent [Directory] the root directory or project of the project
-  # @param name [String] the name of the directory
-  # @param searcher [FileSearcher] an object used to search for files in a given
-  #    directory
-  def initialize(parent, name, searcher = FileSearcher)
-    @parent = parent
-    @name = name
-    @searcher = searcher.new(self)
+    private
+
+    attr_reader :searcher
+
+    # @param parent [Directory] the root directory or project of the project
+    # @param name [String] the name of the directory
+    # @param searcher [FileSearcher] an object used to search for files in a given
+    #    directory
+    def initialize(parent, name, searcher = FileSearcher)
+      @parent = parent
+      @name = name
+      @searcher = searcher.new(self)
+    end
   end
 end

data/lib/exegesis/file_searcher.rb

@@ -15,39 +15,41 @@
 #     Project, Directory
 #   Uses:
 #     Some system-level class like Dir, FileList, or Find
-class FileSearcher
-  # Create a new FileSearcher on the given path
-  #
-  # @param parent [Directory] the parent directory to search downward from
-  def initialize(parent, fs_interface = File)
-    @fs_interface = fs_interface
-    @parent = parent
-  end
+module Exegesis
+  class FileSearcher
+    # Create a new FileSearcher on the given path
+    #
+    # @param parent [Directory] the parent directory to search downward from
+    def initialize(parent, fs_interface = File)
+      @fs_interface = fs_interface
+      @parent = parent
+    end
 
-  #All of the directories in the given path
-  def directories
-    content.
-      select { |s| fs_interface.directory?(s) }.
-      map    { |s| Directory.create(parent, fs_interface.basename(s)) }
-  end
+    #All of the directories in the given path
+    def directories
+      content.
+        select { |s| fs_interface.directory?(s) }.
+        map    { |s| Directory.create(parent, fs_interface.basename(s)) }
+    end
 
-  #All of the files in the given path
-  def files
-    content.
-      select { |s| fs_interface.file?(s) }.
-      map    { |s| SourceFile.create(parent, fs_interface.basename(s)) }
-  end
+    #All of the files in the given path
+    def files
+      content.
+        select { |s| fs_interface.file?(s) }.
+        map    { |s| SourceFile.create(parent, fs_interface.basename(s)) }
+    end
 
-  #All of the content from the given path
-  def content
-    Dir[File.join(parent.path, '*')]
-  end
+    #All of the content from the given path
+    def content
+      Dir[File.join(parent.path, '*')]
+    end
 
-  def inspect
-    "FileSearcher(#{parent.path.inspect})"
-  end
+    def inspect
+      "FileSearcher(#{parent.path.inspect})"
+    end
 
-  private
+    private
 
-  attr_reader :parent, :fs_interface
+    attr_reader :parent, :fs_interface
+  end
 end

data/lib/exegesis/file_system_entity.rb

@@ -1,52 +1,52 @@
 # A collection of shared methods for Directories and SourceFiles
-module FileSystemEntity
-  def self.included(base)
-    base.send(:include , Registerable)
-    base.send(:extend  , Forwardable)
-    base.send(:include , Methods)
-  end
-
-  module Methods
-    def path
-      File.join(parent.path, name)
+module Exegesis
+  module FileSystemEntity
+    def self.included(base)
+      base.send(:include , Registerable)
+      base.send(:extend  , Forwardable)
+      base.send(:include , Methods)
     end
 
-    def inspect
-      "#{self.class.inspect}(#{path.inspect})"
-    end
+    module Methods
+      def path
+        File.join(parent.path, name)
+      end
 
-    attr_reader :parent, :name
-    alias container parent
+      def inspect
+        "#{self.class.inspect}(#{path.inspect})"
+      end
 
-    def basename
-      File.basename(name, ext)
-    end
+      attr_reader :parent, :name
+      alias container parent
 
-    def ext
-      @ext || ""
-    end
-    alias extension ext
+      def basename
+        File.basename(name, ext)
+      end
 
+      def ext
+        @ext || ""
+      end
+      alias extension ext
 
-    def visit(visitor)
-      visitor.on_enter if visitor.respond_to? :on_enter
+      def visit(visitor)
+        visitor.on_enter if visitor.respond_to? :on_enter
 
-      visitor.call(self.class, self)
+        visitor.call(self.class, self)
 
-      if respond_to?(:directories)
-        directories.each do |dir|
-          dir.visit(visitor)
+        if respond_to?(:directories)
+          directories.each do |dir|
+            dir.visit(visitor)
+          end
         end
-      end
 
-      if respond_to?(:files)
-        files.each do |file|
-          file.visit(visitor)
+        if respond_to?(:files)
+          files.each do |file|
+            file.visit(visitor)
+          end
         end
-      end
 
-      visitor.on_exit if visitor.respond_to? :on_exit
+        visitor.on_exit if visitor.respond_to? :on_exit
+      end
     end
   end
 end
-

data/lib/exegesis/flyweight.rb

@@ -10,121 +10,122 @@
 #   SourceFile
 #   Directory
 #   Project
-class Flyweight
-  extend Forwardable
-
-  # Create an empty Flyweight with the given key-processing proc.
-  #
-  # @param key_processor [Proc] a proc which turns an instance into it's key.
-  def initialize(&key_processor)
-    clear!
-
-    if block_given?
-      @key_processor = key_processor
-    else
-      @key_processor = proc { |id| id }
+module Exegesis
+  class Flyweight
+    extend Forwardable
+
+    # Create an empty Flyweight with the given key-processing proc.
+    #
+    # @param key_processor [Proc] a proc which turns an instance into it's key.
+    def initialize(&key_processor)
+      clear!
+
+      if block_given?
+        @key_processor = key_processor
+      else
+        @key_processor = proc { |id| id }
+      end
+
+      self
     end
 
-    self
-  end
-
-  # Register an instance in the flyweight. Throw an error if the key is already
-  # used.
-  #
-  # @param instance [Object] the instance to register in the flyweight
-  # @return [Object] the instance given
-  # @raise [AlreadyRegisteredError] when trying to register the same key twice
-  def register!(instance)
-    raise AlreadyRegisteredError if has_key?(instance)
-    register(instance)
-  end
+    # Register an instance in the flyweight. Throw an error if the key is already
+    # used.
+    #
+    # @param instance [Object] the instance to register in the flyweight
+    # @return [Object] the instance given
+    # @raise [AlreadyRegisteredError] when trying to register the same key twice
+    def register!(instance)
+      raise AlreadyRegisteredError if has_key?(instance)
+      register(instance)
+    end
 
-  # Register an instance in the flyweight.
-  #
-  # @param instance [Object] the instance to register in the flyweight
-  # @return [Object] the instance given
-  def register(instance)
-    key = build_key(instance)
-    key_registry[key] = instance
-  end
+    # Register an instance in the flyweight.
+    #
+    # @param instance [Object] the instance to register in the flyweight
+    # @return [Object] the instance given
+    def register(instance)
+      key = build_key(instance)
+      key_registry[key] = instance
+    end
 
-  # Remove an instance (by key or instance proper) from the flyweight. Throw an
-  # error if no such instance exists
-  #
-  # @param key_or_instance [Object] Either the key under which an instance is
-  #     registered, or the instance itself.
-  # @return [Object] the instance deleted from the flyweight
-  # @raise [NoFlyweightEntryError] when trying to delete a key that isn't
-  #     present in the flyweight
-  def unregister!(key_or_instance)
-    raise NoEntryError unless has_key?(key_or_instance)
-    unregister(key_or_instance)
-  end
+    # Remove an instance (by key or instance proper) from the flyweight. Throw an
+    # error if no such instance exists
+    #
+    # @param key_or_instance [Object] Either the key under which an instance is
+    #     registered, or the instance itself.
+    # @return [Object] the instance deleted from the flyweight
+    # @raise [NoFlyweightEntryError] when trying to delete a key that isn't
+    #     present in the flyweight
+    def unregister!(key_or_instance)
+      raise NoEntryError unless has_key?(key_or_instance)
+      unregister(key_or_instance)
+    end
 
-  # Remove an instance from the flyweight
-  #
-  # @param key_or_instance [Object] Either the key under which an instance is
-  #     registered, or the instance itself.
-  # @return [Object] the instance deleted from the flyweight
-  def unregister(key_or_instance)
-    proxy_across_keytypes(:delete, key_or_instance)
-  end
+    # Remove an instance from the flyweight
+    #
+    # @param key_or_instance [Object] Either the key under which an instance is
+    #     registered, or the instance itself.
+    # @return [Object] the instance deleted from the flyweight
+    def unregister(key_or_instance)
+      proxy_across_keytypes(:delete, key_or_instance)
+    end
 
-  # Whether the flyweight has the given key or instance registered
-  #
-  # @param key_or_instance [Object] Either the key under which an instance is
-  #     registered, or the instance itself.
-  # @return [Boolean] True if the Flyweight has the key or instance, false
-  #     otherwise
-  def has_key?(key_or_instance)
-    proxy_across_keytypes(:has_key?, key_or_instance)
-  end
+    # Whether the flyweight has the given key or instance registered
+    #
+    # @param key_or_instance [Object] Either the key under which an instance is
+    #     registered, or the instance itself.
+    # @return [Boolean] True if the Flyweight has the key or instance, false
+    #     otherwise
+    def has_key?(key_or_instance)
+      proxy_across_keytypes(:has_key?, key_or_instance)
+    end
 
-  # Access the entry under the given key or instance
-  #
-  # NB. If, given an instance that would generate a matching key to an already
-  # registered instance, but perhaps with different data, you'll get back a
-  # reference to the _registered_ instance.
-  #
-  # @param key_or_instance [Object] The key or instance to access.
-  # @return [Object, NilClass] the instance desired, or nil if it doesn't exist
-  def [](key_or_instance)
-    proxy_across_keytypes(:[], key_or_instance)
-  end
+    # Access the entry under the given key or instance
+    #
+    # NB. If, given an instance that would generate a matching key to an already
+    # registered instance, but perhaps with different data, you'll get back a
+    # reference to the _registered_ instance.
+    #
+    # @param key_or_instance [Object] The key or instance to access.
+    # @return [Object, NilClass] the instance desired, or nil if it doesn't exist
+    def [](key_or_instance)
+      proxy_across_keytypes(:[], key_or_instance)
+    end
 
-  # Clear the Flyweight of all entries.
-  def clear!
-    @key_registry = {}
-    self
-  end
-  alias reset! clear!
+    # Clear the Flyweight of all entries.
+    def clear!
+      @key_registry = {}
+      self
+    end
+    alias reset! clear!
 
-  def inspect
-    "Flyweight<#{object_id}, items=#{@key_registry.keys.count}>"
-  end
+    def inspect
+      "Flyweight<#{object_id}, items=#{@key_registry.keys.count}>"
+    end
 
-  private
+    private
 
-  # Build a key from an instance via the key_processor
-  def build_key(instance)
-    @key_processor.call(instance)
-  end
+    # Build a key from an instance via the key_processor
+    def build_key(instance)
+      @key_processor.call(instance)
+    end
 
-  # Proxy a method, aim to use the raw key first, but if that doesn't work, use
-  # the build_key helper and assume you were given an instance.
-  #
-  # NB. This is a bit dirty, but since we don't know what types we're given, we
-  # can't distinguish between key's and instance's without forcing the user to
-  # specifically tell us.
-  def proxy_across_keytypes(method, key)
-    key_registry.send(method, key) || key_registry.send(method, build_key(key))
-  end
+    # Proxy a method, aim to use the raw key first, but if that doesn't work, use
+    # the build_key helper and assume you were given an instance.
+    #
+    # NB. This is a bit dirty, but since we don't know what types we're given, we
+    # can't distinguish between key's and instance's without forcing the user to
+    # specifically tell us.
+    def proxy_across_keytypes(method, key)
+      key_registry.send(method, key) || key_registry.send(method, build_key(key))
+    end
 
-  attr_accessor :key_registry
+    attr_accessor :key_registry
 
-  # An error raised when trying to use an already used key
-  class AlreadyRegisteredError < ArgumentError ; end
-  # An error raised when trying to remove an unused key
-  class NoEntryError < ArgumentError ; end
+    # An error raised when trying to use an already used key
+    class AlreadyRegisteredError < ArgumentError ; end
+    # An error raised when trying to remove an unused key
+    class NoEntryError < ArgumentError ; end
+  end
 end
-