sourcery 0.1.0

data/.ruby

@@ -0,0 +1,44 @@
+---
+source:
+- Profile
+authors:
+- name: Trans
+  email: transfire@gmail.com
+copyrights:
+- holder: Rubyworks
+  year: '2009'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: detroit
+  groups:
+  - build
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git://github.com/rubyworks/sourcery.git
+  scm: git
+  name: upstream
+resources:
+  home: https://github.com/rubyworks/sourcery
+  code: https://github.com/rubyworks/sourcery
+  bugs: https://github.com/rubyworks/sourcery/issues
+  mail: https://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+name: sourcery
+title: Sourcery
+version: 0.1.0
+summary: New Age Ruby, Coding in the Astrological Plain.
+created: '2009-07-15'
+description: ! 'Sourcery puts a spell-casting layer between
+
+  the code you write and the code you ship. Using ERB templating
+
+  in this layer lets you write highly meta-magical code.'
+organization: rubyworks
+date: '2012-02-06'

data/bin/sourcery

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'sourcery'
+Sourcery.cli(*ARGV)
+

data/lib/sourcery.rb

@@ -0,0 +1,16 @@
+module Sourcery
+
+  def self.metadata
+    @metadata ||= (
+      require 'yaml'
+      YAML.load_file(File.dirname(__FILE__) + '/sourcery.yml')
+    )
+  end
+
+  def self.const_missing(name)
+    metadata[name.to_s.downcase] || super(name)
+  end
+
+end
+
+require 'sourcery/cli'

data/lib/sourcery/caster.rb

@@ -0,0 +1,187 @@
+module Sourcery
+
+  require 'sourcery/context'
+  require 'fileutils'
+  require 'erb'
+
+  # Spell Caster renders `src/` files to `lib/`.
+  #
+  class Caster
+
+    # Source directory, defaults to `src`.
+    attr :source
+
+    # Target directory, defaults to `lib`.
+    attr :target
+
+    #
+    attr :files
+
+    #
+    attr_accessor :ask
+
+    #
+    attr_accessor :skip
+
+    #
+    attr_accessor :stdout
+
+    #
+    #attr_accessor :delete
+
+    #
+    def initialize(options={})
+      @source = options[:source] || 'src'
+      @target = options[:target] || 'lib'
+      @force  = options[:ask]
+      @skip   = options[:skip]
+      @stdout = options[:stdout]
+      #@delete = options[:delete]
+
+      if options[:files]
+        @files = options[:files]
+      else
+        @files = collect_files(source)
+      end
+    end
+
+    # Collect all files from source except those starting with an `_` or `.`.
+    def collect_files(dir)
+      Dir[File.join(dir,'**/*')].reject do |f|
+        basename = File.basename(f)
+        basename.start_with?('_') or basename.start_with?('.')
+      end
+    end
+
+    #
+    def ask?
+      @ask
+    end
+
+    #
+    def skip?
+      @skip
+    end
+
+    #
+    #def delete? ; @delete ; end
+
+    #
+    def debug?
+      $DEBUG
+    end
+
+    #
+    def trial?
+      $TRIAL
+    end
+
+    #
+    def call
+      ensure_target_directory
+
+      copy_map = {}
+
+      files.each do |file|
+        output = target_file(file)
+        if output == file 
+          raise "output and source file are identical -- #{file}."
+        end
+        copy_map[file] = output
+      end
+
+      copy_map.each do |file, output|
+        render(file, output)
+      end
+    end
+
+    # Render and save ERB template `file` to `output` file.
+    def render(file, output)
+      if File.file?(output) && skip?
+        print_line('SKIP', output)
+      else
+        template = ERB.new(File.read(file))
+        result   = template.result(context.__binding__)
+        if stdout
+          puts result
+        else
+          save(result, output, file)
+        end
+      end
+    end
+
+    # Determine output file name given source `file`.
+    def target_file(file)
+      name = file.sub(source+'/', '')
+      File.join(target, name)
+    end
+
+    #
+    def context
+      @context ||= Context.new
+    end
+
+    #
+    def save(text, output, source_file)
+      name = output # relative_path(output)
+      if trial?
+        puts "  CAST #{name} (dryrun)"
+      else
+        save = false
+        if File.exist?(output)
+          if FileUtils.uptodate?(output, [source_file])
+            print_line('UNCHANGED', name)
+          elsif ask?
+            case ask("%11s %s?" % ['OVERWRITE', name])
+            when 'y', 'yes'
+              save = true
+            end
+          else
+            save = true
+          end
+        else
+          save = true
+        end
+
+        if save
+          save_file(output, text)
+          puts "  CAST #{name}"
+        end
+      end
+    end
+
+    #
+    def print_line(label, string)
+      "%11s %s" % [label, string]
+    end
+
+    # Save file and make it read-only.
+    def save_file(file, text)
+      #File.open(file, 'w'){ |f| << text }
+      mode = nil
+      if File.exist?(file)
+        mode = File.stat(file).mode
+        mask = mode | 0000200
+        File.chmod(mask, file)  # make writeable
+      end
+      File.open(file, 'w'){ |f| f << text }
+      mode = mode || File.stat(file).mode
+      mask = mode & (mode ^ 0000222)
+      File.chmod(mask, file)    # make read-only
+    end
+
+    #
+    def ask(prompt=nil)
+      $stdout << "#{prompt}"
+      $stdout.flush
+      $stdin.gets.chomp!
+    end
+
+    #
+    def ensure_target_directory
+      FileUtils.mkdir(target) unless File.directory?(target)
+    end
+
+  end
+
+end

data/lib/sourcery/cli.rb

@@ -0,0 +1,56 @@
+module Sourcery
+
+  require 'optparse'
+  require 'sourcery/caster'
+
+  #
+  def self.cli(*argv)
+    options = {}
+
+    usage = OptionParser.new do |use|
+      use.banner = 'Usage: sourcery [OPTIONS] [FILE1 FILE2 ...]'
+
+      #use.on('--delete', 'delete templates when finished') do
+      #  options[:delete] = true
+      #end
+
+      use.on('-a', '--ask', 'prompt user before overwrites') do
+        options[:ask] = true
+      end
+
+      use.on('-s', '--skip', 'automatically skip overwrites') do
+        options[:skip] = true
+      end
+
+      use.on('-o', '--stdout', 'dump output to stdout instead of saving') do
+        options[:stdout] = true
+      end
+
+      use.on('-t', '--trial', 'run in trial mode (no actual disk write)') do
+        $TRIAL = true
+      end
+
+      use.on('--debug', 'run in debug mode') do
+        $DEBUG = true
+      end
+
+      use.on_tail('-h', '--help', 'display this help information') do
+        puts use
+        exit
+      end
+
+      #use['<DIR>',       'directory to till; default is working directory']
+    end
+
+    usage.parse!(argv)
+
+    if !argv.empty?
+      options[:files] = argv
+    end
+
+    caster = Caster.new(options)
+
+    caster.call
+  end
+
+end

data/lib/sourcery/context.rb

@@ -0,0 +1,45 @@
+module Sourcery
+
+  require 'sourcery/metadata'
+
+  #
+  class Context
+
+    #
+    attr :metadata
+
+    #
+    def initialize(dir=nil)
+      @metadata = Metadata.new(dir)
+    end
+
+    #
+    def method_missing(s)
+      @metadata.send(s)
+    end
+
+    #
+    def root
+      metadata.root
+    end
+
+    #
+    def to_h
+      @metadata.to_h
+    end
+
+    # Processes through erb.
+    #def erb(text)
+    #  erb = ERB.new(text)
+    #  erb.result(binding)
+    #end
+
+    # Get a clean binding.
+    def __binding__
+      binding
+    end
+
+  end
+
+end
+

data/lib/sourcery/metadata.rb

@@ -0,0 +1,136 @@
+module Sourcery
+
+  #
+  class Metadata
+
+    #
+    # Project root pathname.
+    #
+    attr :root
+
+    #
+    # Initialize new Metadata object.
+    #
+    def initialize(root=nil)
+      #@root = self.class.root(root) || Dir.pwd
+      @root  = root || Dir.pwd
+      @cache = {}
+
+      raise "not a directory -- #{root}" unless File.directory?(root)
+
+      load_metadata
+    end
+
+    #
+    # If method is missing see if there is a metadata entry for it.
+    #
+    def method_missing(s, *a)
+      m = s.to_s
+      case m
+      when /=$/
+        raise ArgumentError if a.size != 1
+        @cache[s.to_s] = a.first
+      else
+        super(s, *a) unless a.empty?
+        @cache[s.to_s]
+      end
+    end
+
+    #
+    # Return copy of metadata store.
+    #
+    def to_h
+      @cache.dup
+    end
+
+  private
+
+    #
+    # Load metadata.
+    #
+    def load_metadata
+      load_metadata_from_directory
+      load_metadata_from_dotruby
+    end
+
+    #
+    # Load metadata from metadata directory.
+    #
+    def load_metadata_from_directory
+      entries = Dir.glob(File.join(meta_dir, '*'))
+      entries.each do |f|
+        val = File.read(f).strip
+        val = YAML.load(val) if val =~ /\A---/
+        @cache[File.basename(f)] = val
+      end
+    end
+
+    #
+    # Load metadata from .ruby file.
+    #
+    def load_metadata_from_dotruby
+      file = Dir[File.join(root, '.ruby')].first
+      if file
+        @cache.update(YAML.load_file(file))
+      end
+    end
+
+    #
+    # Locate the project's metadata directory. This is either
+    # `meta` or `.meta` or `var`.
+    #
+    def meta_dir
+      @meta_dir ||= Dir[File.join(root, '{meta,.meta,var}/')].first || '.meta/'
+    end
+
+    #
+    #def load_value(name)
+    #  file = File.join(metadir, name)
+    #  file = Dir[file].first
+    #  if file && File.file?(file)
+    #    #return erb(file).strip
+    #    return File.read(file).strip
+    #  end
+    #end
+
+  public
+
+    #
+    # Root directory is indicated by the presence of a +src/+ directory.
+    #
+    ROOT_INDICATORS = ['.ruby,var/,meta/,.meta/,.git,.hg,_darcs']
+
+    #
+    # Locate the project's root directory. This is determined
+    # by ascending up the directory tree from the current position
+    # until the ROOT_INDICATORS is matched. Returns +nil+ if not found.
+    #
+    def self.root(local=Dir.pwd)
+      local ||= Dir.pwd
+      Dir.chdir(local) do
+        dir = nil
+        ROOT_INDICATORS.find do |i|
+          dir = locate_root_at(i)
+        end
+        dir ? Pathname.new(File.dirname(dir)) : nil
+      end
+    end
+
+    #
+    # Helper method for `Metadata.root()`.
+    #
+    def self.locate_root_at(indicator)
+      root = nil
+      dir  = Dir.pwd
+      while !root && dir != '/'
+        find = File.join(dir, indicator)
+        root = Dir.glob(find, File::FNM_CASEFOLD).first
+        #break if root
+        dir = File.dirname(dir)
+      end
+      root ? Pathname.new(root) : nil
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: sourcery
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &14325640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *14325640
+description: ! 'Sourcery puts a spell-casting layer between
+
+  the code you write and the code you ship. Using ERB templating
+
+  in this layer lets you write highly meta-magical code.'
+email:
+- transfire@gmail.com
+executables:
+- sourcery
+extensions: []
+extra_rdoc_files: []
+files:
+- .ruby
+- bin/sourcery
+- lib/sourcery/caster.rb
+- lib/sourcery/cli.rb
+- lib/sourcery/context.rb
+- lib/sourcery/metadata.rb
+- lib/sourcery.rb
+homepage: https://github.com/rubyworks/sourcery
+licenses:
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: New Age Ruby, Coding in the Astrological Plain.
+test_files: []