roll 1.1.0 → 1.2.0

data/lib/roll/metadata.rb

@@ -1,77 +1,282 @@
+require 'yaml'
+
 module Roll
 
+  #= Library Metadata
   #--
   # TODO: Use POM? If available?
+  #
+  # TODO: Improve loading and parsing of metadata.
+  # We want this to be as fast and as lazy as possible.
   #--
   class Metadata
 
-    #TODO: hide most methods
+    # New metadata object.
+    def initialize(location, name=nil, options={})
+      @location = location
+      @name     = name
+      @version  = options[:version]
+      @loadpath = options[:loadpath]
+      #load_metadata
+    end
 
+    # Location of library.
     attr :location
 
+    # Release date.
+    attr_accessor :date
+
+    # Alias for release date.
+    alias_method :released, :date
+
+    # In code name, e.g. "ActiveRecord"
+    attr_accessor :codename
+
+    # Local load paths.
+    def loadpath
+      @loadpath || (
+        load_metadata
+        @loadpath ||= ['lib']
+      )
+    end
+
     #
-    def initialize(location)
-      @location = location
-      @cache = {}
+    def loadpath=(path)
+      case path
+      when nil
+        path = ['lib']
+      when String
+        path = path.strip.split(/[,;:\ \n\t]/).map{|s| s.strip}
+      end
+      @loadpath = path
     end
 
-    # Get library name.
+    # Name of library.
     def name
-      @cache[:name] ||= read('name')
+      @name || (
+        if @loaded
+          nil
+        else
+          load_metadata
+          @name
+        end
+      )
+    end
+
+    # Set name.
+    def name=(string)
+      @name = string if string
     end
 
-    # Get library version. 
-    #--
-    # TODO: handle VERSION file
-    # TODO: handle YAML
-    #++
+    # Version number.
+    #
+    # Technically, a library should not appear in a ledger list
+    # if it lacks a VERSION file. However, just in case this
+    # occurs (say by a hand edited environment) we fallback
+    # to a version of '0.0.0'.
     def version
-      @cache[:version] ||= Version.new(read(:version))
+      @version || (
+        load_metadata
+        @version ||= Version.new('0.0.0')
+      )
     end
 
-    # Get library active state.
-    def active
-      return @cache[:active] if @cache.key?(:active)
-      @cache[:active] = (
-        case read(:active).to_s.downcase
-        when 'false', 'no'
-          false
-        else
-          true
+    # Set version, converts string into Version number class.
+    def version=(string)
+      @version = Version.new(string) if string
+    end
+
+    # TODO: Improve. Is this even needed?
+    def requires
+      @requires ||= (
+        req = []
+        if file = require_file
+          data = YAML.load(File.new(file))
+          data.each do |name, list|
+            req.concat(list || [])
+          end
         end
+        req
       )
     end
 
-    # Get library release date. 
-    #--
-    # TODO: default date to what?
-    #++
-    def released
-      @cache[:released] ||= read(:released) || "1900-01-01"
+    #
+    def require_file
+      @require_file ||= (
+        pattern = File.join(location, "{REQUIRE,.require}{,.yml,.yaml}")
+        Dir.glob(pattern, File::FNM_CASEFOLD).first
+      )
     end
 
-    # Get library loadpath.
-    def loadpath
-      @cache[:loadpath] ||= (
-        val = read(:loadpath).to_s.strip.split(/\s*\n/)  # TODO: handle YAML
-        val = ['lib'] if val.empty?
-        val
+    # TODO: Deprecate active, if you don't want it exclude from environment.
+    # Is active, i.e. not omitted.
+    #def active  ; true ; end
+    # Is active, i.e. not omitted.
+    #def active? ; true ; end
+
+  private
+
+    # Package file path.
+    def package_file
+      @package_file ||= (
+        paths = Dir.glob(File.join(location, "{,.}{package}{.yml,.yaml,}"), File::FNM_CASEFOLD)
+        paths.select{ |f| File.file?(f) }.first
+      )
+    end
+
+    # Version file path.
+    def version_file
+      @version_file ||= (
+        paths = Dir.glob(File.join(location, "{VERSION}{,.txt,.yml,.yaml}"), File::FNM_CASEFOLD)
+        paths.select{ |f| File.file?(f) }.first
       )
     end
 
     #
-    def requires
-      @cache[:requires] ||= (
-        if entry = read(:requires)
-          entry.strip.split("\n").map do |line|
-            line.strip.split(/\s+/)
-          end
+    def load_metadata
+      @loaded = true
+      load_package || load_fallback
+    end
+
+    #
+    def load_package
+      if package_file
+        data = YAML.load(File.new(package_file))
+        data = data.inject({}){|h,(k,v)| h[k.to_s] = v; h}
+        self.name     = data['name']
+        self.version  = data['vers'] || data['version']
+        self.loadpath = data['path'] || data['loadpath']
+        self.codename = data['code'] || data['codename']
+        true
+      else
+        false
+      end
+    end
+
+    # TODO: Instead of supporting gemspecs as is, create a tool
+    # that will add a .package file to each one.
+
+    #
+    #def load_gemspec
+    #  return false unless File.basename(File.dirname(location)) == 'gems'
+    #  specfile = File.join(location, '..', '..', 'specifications', File.basename(location) + '.gemspec')
+    #  if File.exist?(specfile)
+    #    fakegem = FakeGem.load(specfile)
+    #    self.name     = fakegem.name
+    #    self.version  = fakegem.version
+    #    self.loadpath = fakegem.require_paths
+    #    true
+    #  else
+    #    false
+    #  end 
+    #end
+
+    # THINK: Is this reliable enough?
+    def load_fallback
+      load_location
+      load_version unless @version
+      if not @version
+        self.version = '0.0.0'
+      end
+      @name
+    end
+
+    #
+    def load_location
+      fname = File.basename(location)
+      if /\-\d/ =~ fname
+        i = fname.rindex('-')
+        name, vers = fname[0...i], fname[i+1..-1]
+        self.name    = name
+        self.version = vers
+      else
+        self.name = fname
+      end
+    end
+
+    # Try to determine name from lib/*.rb file.
+    # Ideally this would work, but there are too many projects that do not
+    # follow best practices, so currently THIS IS NOT USED.
+    def load_loadpath
+      #libs = loadpath.map{ |lp| Dir.glob(File.join(lp,'*.rb')) }.flatten
+      libs = Dir.glob(File.join(location, 'lib', '*.rb'))
+      if !libs.empty?
+        self.name = File.basename(libs.first).chomp('.rb')
+        true
+      else
+        false
+      end
+    end
+
+    # Load VERSION file, if it exists.
+    def load_version
+      if version_file
+        ext = File.extname(version_file)
+        if ext == '.yml' or ext == '.yaml'
+          data = YAML.load(File.new(version_file))
+          parse_version_hash(data)
         else
-          []
+          text = File.read(version_file).strip
+          if text[0..3] == '---' or text.index('major:')
+            data = YAML.load(text)
+            parse_version_hash(data)
+          else
+            parse_version_string(text)
+          end
         end
-      )
+        true if @version
+      else
+        false
+      end
+    end
+
+    # Parse hash-based VERSION file.
+    def parse_version_hash(data)
+      data = data.inject({}){ |h,(k,v)| h[k.to_sym] = v; h }
+      self.name = data[:name] if data[:name]
+      self.date = data[:date] if data[:date]
+      # jeweler
+      if data[:major]
+        self.version = data.values_at(:major, :minor, :patch, :build).compact.join('.')
+      else
+        vers = data[:vers] || data[:version]
+        self.version = (Array === vers ? vers.join('.') : vers)
+      end
+      self.codename = data.values_at(:code, :codename).compact.first
+    end
+
+    # Parse string-based VERSION file.
+    def parse_version_string(text)
+      text = text.strip
+      # name
+      if md = /^(\w+)(\-\d|\ )/.match(text)
+        self.name = md[1]
+      end
+      # version
+      if md = /(\d+\.)+(\w+\.)?(\d+)/.match(text)
+        self.version = md[0]
+      end
+      # date
+      # TODO: convert to date/time
+      if md = /\d\d\d\d-\d\d-\d\d/.match(text)
+        self.date = md[0]
+      end
     end
 
+=begin
+    ## Get library active state.
+    #def active
+    #  return @cache[:active] if @cache.key?(:active)
+    #  @cache[:active] = (
+    #    case read(:active).to_s.downcase
+    #    when 'false', 'no'
+    #      false
+    #    else
+    #      true
+    #    end
+    #  )
+    #end
+
     #
     def method_missing(name, *args)
       if @cache.key?(name)
@@ -80,11 +285,11 @@ module Roll
         @cache[name] = read(name)
       end
     end
+=end
 
-  private
-
-    #
-    def read(name)
+=begin
+    # Retrieve entry from meta directory.
+    def meta(name)
       file = Dir[File.join(location, "{meta,.meta}", name.to_s)].first
       if file
         text = File.read(file)
@@ -98,14 +303,40 @@ module Roll
         nil
       end
     end
+=end
 
-    #
-    def require_yaml
-      @require_yaml ||=(
-        require 'yaml'
-        true
-      )
+    # Ecapsulate the fake parsing of a gemspec.
+    module FakeGem
+      module Gem #:nodoc:
+        class Specification #:nodoc:
+          attr :fake_options
+          def initialize(&block)
+            @fake_options = {}
+            yield(self)
+          end
+          def method_missing(sym, *args)
+            name = sym.to_s
+            case name
+            when /=$/
+              @fake_options[name.chomp('=')] = args.first
+            else
+              @fake_options[name]
+            end
+          end
+        end
+        class Requirement
+          def initialize(*a)
+          end
+        end
+      end
+      #
+      def self.load(file)
+        text = File.read(file)
+        fake_spec = eval(text, binding)
+        fake_spec
+      end
     end
+
   end
 
 end

data/lib/roll/original.rb

@@ -2,9 +2,9 @@
 RUBY_IGNORE_CALLERS = [] unless defined? RUBY_IGNORE_CALLERS
 RUBY_IGNORE_CALLERS << %r{roll/kernel\.rb$}
 RUBY_IGNORE_CALLERS << %r{roll/original\.rb$}
- 
+
 module ::Kernel
-  alias_method :original_require, :require
-  alias_method :original_load, :load
+  alias_method :roll_original_require, :require
+  alias_method :roll_original_load, :load
 end
 

data/lib/roll/version.rb

@@ -1,11 +1,9 @@
 module Roll
 
-  # = Version
+  # = Version Number
   #
-  # VersionNumber is a simplified form of a Tuple class
-  # desgined specifically for dealing with version numbers.
-  #
-  class Version #< Tuple
+  # Essentially a tuple (immutable array).
+  class Version
 
     #include Enumerable
     include Comparable
@@ -48,6 +46,7 @@ module Roll
 
   private
 
+    # TODO: deal with string portions of version number
     def initialize(*args)
       args = args.join('.').split(/\W+/)
       @tuple = args.collect { |i| i.to_i }
@@ -72,7 +71,7 @@ module Roll
     def <=>(other)
       #other = other.to_t
       [@tuple.size, other.size].max.times do |i|
-        c = @tuple[i] <=> other[i]
+        c = (@tuple[i] || 0) <=> (other[i] || 0)
         return c if c != 0
       end
       0
@@ -99,7 +98,7 @@ module Roll
 
     # Teeny is third number in the version series.
 
-    def teeny ; @tuple[2] || 0 ; end
+    def patch ; @tuple[2] || 0 ; end
 
     # Delegate to the array.
 

data/script/setup

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Setup.rb, 2010-02-07 08:33:15
+# Setup.rb, 2010-06-01 10:27:20
 #
 # This is a stand-alone bundle of the setup.rb application.
 # You can place it in your projects script/ directory, or
@@ -29,7 +29,8 @@ end
 module Setup
   META_EXTENSION_DIR = '.setup'
   FILETYPES = %w( bin lib ext data etc man doc )
-  INSTALL_RECORD = 'SetupReceipt'  #'.cache/setup/installedfiles'
+  INSTALL_RECORD = 'SetupReceipt'
+  CONFIG_FILE = 'SetupConfig'
 end
 module Setup
   class Project
@@ -109,7 +110,6 @@ module Setup
       configuration.compile? && project.compiles?
     end
     def all
-      config
       if compile?
         make
       end
@@ -123,23 +123,18 @@ module Setup
       end
     end
     def config
-      log_header('Configure')
-      if configuration.save_config
-        io.puts "Configuration saved." unless quiet?
-      else
-        io.puts "Configuration current." unless quiet?
-      end
+      log_header('Custom Configuration')
+      configuration.save_config
+      io.puts "Edit #{CONFIG_FILE} to customize configuration." unless quiet?
       puts configuration if trace? && !quiet?
       compiler.configure if compile? #compiler.compiles?
     end
     def make
-      abort "must run 'setup config' first" unless configuration.exist?
       log_header('Compile')
       compiler.compile
     end
     alias_method :setup, :make
     def install
-      abort "must run 'setup config' first" unless configuration.exist?
       log_header('Install')
       installer.install
     end
@@ -331,7 +326,6 @@ require 'shellwords'
 module Setup
   class Configuration
     RBCONFIG  = ::Config::CONFIG
-    CONFIG_FILE = 'SetupConfig'  # '.cache/setup/config'
     META_CONFIG_FILE = META_EXTENSION_DIR + '/configuration.rb'
     def self.options
       @@options ||= []
@@ -393,9 +387,9 @@ module Setup
       initialize_metaconfig
       initialize_defaults
       initialize_environment
-      initialize_configfile
+      initialize_configfile unless values[:reset]
       values.each{ |k,v| __send__("#{k}=", v) }
-      yeild(self) if block_given?
+      yield(self) if block_given?
     end
     def initialize_metaconfig
       if File.exist?(META_CONFIG_FILE)
@@ -407,7 +401,7 @@ module Setup
       self.type    = 'site'
       self.no_ri   = true
       self.no_test = true
-      self.no_doc  = false
+      self.no_doc  = true
       self.no_ext  = false
     end
     def initialize_environment
@@ -418,7 +412,7 @@ module Setup
       end
     end
     def initialize_configfile
-      if File.exist?(CONFIG_FILE)
+      if exist?
         erb = ERB.new(File.read(CONFIG_FILE))
         txt = erb.result(binding)
         dat = YAML.load(txt)
@@ -436,6 +430,7 @@ module Setup
         end
       end
     end
+    attr_accessor :reset
     def base_bindir
       @base_bindir ||= subprefix('bindir')
     end
@@ -924,7 +919,7 @@ module Setup
       return unless config.doc?
       return unless directory?('doc')
       return unless project.name
-      dir = File.join(config.docdir, "ruby-{project.name}")
+      dir = File.join(config.docdir, "ruby-#{project.name}")
       report_transfer('doc', dir)
       files = files('doc')
       install_files('doc', files, dir, 0644)
@@ -1287,7 +1282,8 @@ module Setup
             end
           end
         else
-          opts = shortcut ? ["-#{shortcut}", "--#{optname} #{type.to_s.upcase}", desc] : ["--#{optname} #{type.to_s.upcase}", desc]
+          opts = shortcut ? ["-#{shortcut}", "--#{optname} #{type.to_s.upcase}", desc] :
+                            ["--#{optname} #{type.to_s.upcase}", desc]
           parser.on(*opts) do |val|
             configuration.__send__("#{name}=", val)
           end