RubyGems - FileSet - Versions diffs - 0.1 - Mend

FileSet 0.1

Files changed (4) hide show

data/doc/README ADDED

@@ -0,0 +1,62 @@
+== Fileset
+=== Simple file management
+Applications tend to need preferences and configuration files, which can be a bit of a pain to maintain.  Fileset allows you to describe a directory structure with raw files or YAML documents, and then populate the local directories of the install target.
+=== Usage
+Essentially, FileSet lets you do this:
+==== Search paths
+ set = FileSet.new([""] + %w{etc myapp}, %w{~ .myapp}, %{.myapp})
+When you create a fileset, the directories you give it define where in the
+filesystem it will work.
+Throughout, FileSet uses arrays of strings to reference files, which is a little cheaper when manipulating file paths, and slightly more platform agnostic than strings delimited by '/'.  Development so far has been entirely in Linux, so I'd imagine this will work pretty well on OS X, and mostly all right on Windows - although I wouldn't expect Windows-style %ESCAPES% to work.
+==== Definition
+ set.define do
+   dir 'www' do
+     file 'index.html', align(<<-EOF)
+     <<<
+     <html><body>
+       <h1 class="ironic">Sparse Docco</h1>
+     </body></html>
+     EOF
+   end
+   dir 'conf' do
+     yaml_file 'uses.yaml', {'count' => 1001}
+   end
+   dir 'empty'
+ end
+A few features:
+* a simple DSL for definition of files
+* Basic text or yaml file definition
+* Left flush alignment of file text (aligned an optional '<<<')
+* Definition blocks can be repeated, as can dir blocks, so the FileSet can be handed around to different program modules to collect their file requirements
+==== Filesystem population
+ set.populate
+This step creates directories and writes files.  The first directory listed in the search path used to initialize the FileSet that can be written to is the destination for the files.  The intention is that an administrator will be able to deploy system-wide configuration, while users will still be able to install default configs in their home directories.
+FileSet::populate won't overwrite existing files, so re-populating won't wipe out the configuration changes your users have made.
+FileSet::populate is intentionally left as a separate step, so that it can be initiated as appropriate to the application.  Some apps may want to populate automatically every time they're run, others might want to wait for a commandline switch.
+If populate is never run, the default values in the define block will be returned if the files are read.
+==== File access
+ set.load(%w{www index.html}) #=> "<html><body>...."
+ conf = set.get_file(%w{conf uses.yaml})
+ conf.contents['count'] += 1
+ conf.store
+FileSet#load returns the contents of the file: either a string or the data stored in the YAML document.
+FileSet#get_file returns a wrapper that allows the contents of the file to be accessed, changed, and then rewritten with FileSet#store.

data/doc/Specifications ADDED

@@ -0,0 +1,28 @@
+FileSet retrieving files
+- should get default text files
+- should get text files from library files
+- should get default nested files
+- should get text files from filesystem
+- should get yaml files named with strings
+- should get yaml files from the filesystem
+- should get yaml files named with symbols
+FileSet defined with the DSL
+- should create files on populate
+- should not clobber existing files in populate
+- should allow empty directory definition
+- should get files once populated
+FileSet defined programmatically
+- should create files on populate
+- should not clobber existing files in populate
+- should allow empty directory definition
+- should get files once populated
+FileSet - the unpath method:
+- state => ["state"]
+Finished in 0.156611 seconds
+16 examples, 0 failures

data/lib/fileset.rb ADDED

@@ -0,0 +1,301 @@
+require 'fileutils'
+module FileSetWorks
+  class LiveFile
+    def initialize(path, filerep)
+      @path = path
+      @rep = filerep
+    end
+    def load
+      ::File::open(@path, "r") do |file|
+        @rep.load(file)
+      end
+    end
+    def store
+      ::File::open(@path, "w") do |file|
+        @rep.store(file)
+      end
+    end
+    def contents
+      return @rep.contents
+    end
+    def contents=(new_contents)
+      return @rep.contents=(new_contents)
+    end
+  end
+  module Population
+    class EveryPath
+      def initialize(file_rep, search_paths)
+        @rep = file_rep
+        @search_paths = search_paths
+      end
+      def populate
+        catch :done do
+          paths do |sp|
+            begin
+              per_path(sp)
+            rescue SystemCallError
+              next
+            end
+          end
+        end
+      end
+      def paths
+        @search_paths.each do |sp|
+          yield sp
+        end
+      end
+      def per_path(search_path)
+        @rep.create_in(search_path)
+      end
+    end
+    class LowestPath < EveryPath
+      def per_path(search_path)
+        @rep.create_in(search_path)
+        throw :done
+      end
+      def paths
+        @search_paths.reverse.each do |sp|
+          yield sp
+        end
+      end
+    end
+    class HighestPath < EveryPath
+      def per_path(search_path)
+        @rep.create_in(search_path)
+        throw :done
+      end
+    end
+  end
+  class FilesetItem
+    def initialize(path, populator = default_populator())
+      @path = path
+      @populator = populator
+    end
+    def default_populator
+      Population::LowestPath
+    end
+    def populate(search_paths)
+      @populator.new(self, search_paths).populate
+    end
+    def create_in(search_path)
+      path = ::File::join(search_path, @path)
+      return if ::File::exists?(path)
+      init_self(path)
+    end
+  end
+  class File < FilesetItem
+    def initialize(path, data, populator = default_populator())
+      super(path, populator)
+      @contents = data
+    end
+    attr_reader :path
+    attr_accessor :contents
+    def load(file)
+      @contents = file.read
+      return @contents
+    end
+    def store(file)
+      file.write(@contents)
+    end
+    def init_self(path)
+      ::File::open(path, "w") do |file|
+        store(file)
+      end
+    end
+  end
+  class YAMLFile < File
+    #TODO: YAML::Stream
+    def load(file)
+      @contents = YAML::load(file)
+      return @contents
+    end
+    def store(file)
+      YAML::dump(@contents, file)
+    end
+  end
+  class Directory < FilesetItem
+    def default_populator
+      Population::EveryPath
+    end
+    def init_self(path)
+      FileUtils::mkdir(path)
+    end
+  end
+end
+class FileSet
+  def initialize(search_paths)
+    @prefix = []
+    @files = {}
+    @search_paths = search_paths.map{|p| unpath([*p])}
+  end
+  def find(path)
+    path = unpath(path)
+    @search_paths.reverse.map do |sp|
+      ::File::join(sp + path)
+    end.find do |path|
+      ::File::exists?(path)
+    end
+  end
+  def load(*path)
+    get_file(path).contents
+  end
+  def get_file(path)
+    path = unpath(path)
+    file_rep = @files[path]
+    unless (file_path = find(path)).nil?
+      file = FileSetWorks::LiveFile.new(file_path, file_rep)
+      file.load
+      return file
+    end
+    return file_rep
+  end
+  def populate()
+    @files.keys.sort do |left, right|
+      left.length <=> right.length
+    end.each do |key|
+      @files[key].populate(@search_paths)
+    end
+  end
+  def unpath(parts)
+    if Array === parts and parts.length == 1
+      parts = parts[0]
+    end
+    case parts
+    when Array
+      if (parts.find{|part| not (String === part or Symbol === part)}.nil?)
+        parts = parts.map{|part| part.to_s}
+      else
+        raise "path must be composed of strings or symbols"
+      end
+    when String
+      parts = path_split(parts)
+    when Symbol
+      parts = [parts.to_s]
+    when ::File
+      parts = parts.path
+      parts = path_split(parts)
+    else
+      raise "path must be String, Array of Strings or File"
+    end
+    parts = parts.map do |part|
+      if /^~/ =~ part
+        ::File::expand_path(part).split(::File::Separator)
+      else
+        part
+      end
+    end.flatten
+    return parts
+  end
+  def define(&block)
+    self.instance_eval &block
+  end
+  def add_item(path, item)
+    if path.length > 1
+      case @files[path[0..-2]]
+      when FileSetWorks::Directory
+      when nil
+        add_dir(path[0..-2])
+      else
+        raise "Tried to add items below #{path[0..-2]} which is not a directory"
+      end
+    end
+    @files[path] = item
+  end
+  def add_dir(path)
+    add_item(path, FileSetWorks::Directory.new(path))
+  end
+  def add_file(path, data = nil)
+    add_item(path, FileSetWorks::File.new(path, data))
+  end
+  def dir(name)
+    path = @prefix + [name]
+    add_dir(path)
+    @prefix.push(name)
+    yield if block_given?
+    @prefix.pop
+  end
+  def file(name, data=nil)
+    path = @prefix + [name.to_s]
+    add_file(path, data)
+  end
+  def align(string)
+    lines = string.split(/\n/)
+    first = lines.shift
+    match = /^(\s*)<<</.match(first)
+    unless(match.nil?)
+      catch(:haircut) do
+        return lines.map do |line|
+          raise line if /^#{match[1]}|^\s*$/ !~ line
+          throw :haircut if /^#{match[1]}|^\s*$/ !~ line
+          line.sub(/^#{match[1]}/, "")
+        end.join("\n")
+      end
+    end
+    return string
+  end
+  def yaml_file(name)
+    path = @prefix + [name.to_s]
+    @files[path] = FileSetWorks::YAMLFile::new(path, yield )
+  end
+  private
+  def path_split(path)
+    path.split(::File::Separator)
+  end
+  def contents_from(*path)
+    path = unpath(path)
+    m = /(.*):\d+/.match(caller[0])
+    dir = ::File::dirname(::File::expand_path(m[1]))
+    file_path = ::File::join(unpath(dir), path)
+    ::File::open(file_path, "r") do |file|
+       file.read
+    end
+  end
+end

metadata ADDED

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: FileSet
+version: !ruby/object:Gem::Version
+  version: "0.1"
+platform: ruby
+authors:
+- Judson Lester
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-12-29 00:00:00 -08:00
+default_executable:
+dependencies: []
+description: "  FileSet provides an API for accessing configuration and data files for your\n  application, including the population of default values, and managing search\n  paths.  Written to encourage a cross-platform approach to maintaining configs\n  for an application.\n"
+email: nyarly@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- doc/README
+- doc/Specifications
+files:
+- lib/fileset.rb
+- doc/README
+- doc/Specifications
+has_rdoc: true
+homepage: http://fileset.rubyforge.org/
+licenses: []
+post_install_message: Another tidy package brought to you by Judson
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- FileSet-0.1 RDoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+requirements: []
+rubyforge_project: fileset
+rubygems_version: 1.3.5
+signing_key:
+specification_version: 3
+summary: Manage configuration and data files simply
+test_files: []