jsdm 0.2.20

data/Rakefile

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+spec = Gem::Specification.new do |s|
+  s.platform     = Gem::Platform::RUBY
+  s.name         = "jsdm"
+  s.author       = "Min Huang"
+  s.email        = "min.huang@alumni.usc.edu"
+  s.files        = Dir["lib/**/*"] + %w(Rakefile)
+  s.require_path = "lib"
+  s.has_rdoc     = true
+  s.homepage     = "http://www.borderstylo.com/#{s.name}"
+  s.version      = "0.2.20"
+  s.summary      = "Javascript dependency manager"
+  s.description  = "Use #require statements to declare dependencies"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar_bz2 = true
+end
+
+desc "Clean the build"
+task :clean do
+  FileUtils.rm_rf "pkg", :verbose => true
+end
+
+desc "Run tests (no arg), or single test (with arg)"
+task :test, :name do |t, args|
+  opts = args.name.nil? ? "" : "-n test_#{args.name}"
+  cmd = "ruby test/run_tests.rb #{opts}"
+  puts cmd
+  system(cmd) || raise("Build error")
+end
+
+task :install => [:test, :package] do
+  g = "pkg/#{spec.name}-#{spec.version}.gem"
+  system "sudo gem install -l #{g}"
+end
+
+task :default => :test

data/lib/jsdm/dependency_manager.rb

@@ -0,0 +1,42 @@
+require 'jsdm'
+require 'jsdm/depth_first_search'
+require 'jsdm/directed_graph'
+require 'jsdm/natural_loops'
+require 'jsdm/errors'
+
+class JSDM
+  class DependencyManager
+    attr_accessor :sources, :dependencies, :graph
+
+    def initialize(sources)
+      self.sources = sources
+      self.dependencies = []
+      self.graph = nil
+    end
+
+    def add_dependency(source, dependency)
+      unless JSDM.same_file? dependency, source
+        dependencies << [dependency, source]
+      end
+    end
+
+    def dependencies_of(source, acc = [])
+       ds = dependencies.select { |d| d.last == source }.
+                         map { |d| d.first }
+       return acc if ds.empty?
+       acc = acc | ds
+       ds.each { |d| acc = acc | dependencies_of(d, acc) }
+       acc
+    end
+
+    def process
+      self.sources = sources.uniq.delete_if { |e| e.empty? }
+      self.dependencies = dependencies.uniq.delete_if { |e| e.empty? }
+      self.graph = DirectedGraph.new sources, dependencies
+      result = DepthFirstSearch.dfs graph
+      loops = NaturalLoops.find graph, result[:back_edges]
+      raise CircularDependencyError.new(loops) unless loops.empty?
+      result[:sorted]
+    end
+  end
+end

data/lib/jsdm/dependency_resolver.rb

@@ -0,0 +1,26 @@
+require 'jsdm/errors'
+
+class JSDM
+  class DependencyResolver
+    attr_accessor :load_path
+
+    def initialize(load_path)
+      self.load_path = load_path
+    end
+
+    def process(entries)
+      entries = entries.map { |entry| process_single entry }
+      entries = entries.flatten
+      entries
+    end
+
+    def process_single(entry)
+      resolved = load_path.map { |path| Dir["#{path}/#{entry.strip}"] }
+      resolved = resolved.drop_while { |sources| sources.empty? }
+      resolved = resolved.first
+      raise FileNotFoundError.new(entry) if resolved.nil? || resolved.empty?
+      resolved
+    end
+  end
+end
+

data/lib/jsdm/depth_first_search.rb

@@ -0,0 +1,77 @@
+require 'set'
+
+class JSDM
+  class DepthFirstSearch
+    def initialize(graph)
+      self.graph            = graph
+      self.discovered_times = Hash.new { |h, k| h[k] = 0 }
+      self.finished_times   = Hash.new { |h, k| h[k] = 0 }
+      self.node_colors      = Hash.new { |h, k| h[k] = :white }
+      self.edge_colors      = Hash.new { |h, k| h[k] = [] }
+      self.predecessors     = Hash.new
+      self.sorted           = []
+      self.time             = 0
+    end
+
+    def process
+      graph.nodes.each { |u| visit(u) if node_colors[u] == :white }
+      return {
+        :discovered_times => discovered_times,
+        :finished_times   => finished_times,
+        :node_colors      => node_colors,
+        :edge_colors      => edge_colors,
+        :predecessors     => predecessors,
+        :sorted           => sorted,
+        :tree_edges       => edge_colors[:white],
+        :forward_edges    => edge_colors[:black].select do |e|
+                               t = discovered_times[e.first]
+                               u = discovered_times[e.last]
+                               t < u
+                             end,
+        :cross_edges      => edge_colors[:black].select do |e|
+                               t = discovered_times[e.first]
+                               u = discovered_times[e.last]
+                               t > u
+                             end,
+        :back_edges       => edge_colors[:gray]
+      }
+    end
+
+    def visit(u)
+      self.time += 1
+      discovered_times[u] = time
+      node_colors[u] = :gray
+      graph.successors(u).each do |v|
+        case node_colors[v]
+        when :white
+          edge_colors[:white] << [u, v]
+          predecessors[v] = u
+          visit(v)
+        when :gray
+          edge_colors[:gray]  << [u, v]
+        else
+          edge_colors[:black] << [u, v]
+        end
+      end
+      node_colors[u] = :black
+      finished_times[u] = time
+      sorted.unshift u
+      self.time += 1
+    end
+
+    def self.dfs(graph)
+      search = DepthFirstSearch.new(graph)
+      search.process
+    end
+
+    protected
+    attr_accessor :graph,
+                  :discovered_times,
+                  :finished_times,
+                  :node_colors,
+                  :edge_colors,
+                  :predecessors,
+                  :sorted,
+                  :time
+  end
+end

data/lib/jsdm/directed_graph.rb

@@ -0,0 +1,15 @@
+class JSDM
+  class DirectedGraph
+    attr_accessor :nodes, :arcs
+    private :nodes=, :arcs=
+
+    def initialize(nodes, arcs)
+      self.nodes = nodes
+      self.arcs  = arcs
+    end
+
+    def successors(node)
+      arcs.select { |a| a.first == node }.map { |a| a.last }
+    end
+  end
+end

data/lib/jsdm/errors.rb

@@ -0,0 +1,38 @@
+class JSDM
+  class CircularDependencyError < StandardError
+    attr_accessor :deps
+    private :deps=
+
+    def initialize(deps)
+      msg = 'The following sets of files are involved in circular ' +
+            'dependencies: ' +
+            deps.inspect
+      self.deps = deps
+      super(msg)
+    end
+  end
+
+  class FileNotFoundError < StandardError
+    attr_accessor :file
+    private :file=
+
+    def initialize(file)
+      super("File not found: #{file}")
+      self.file = file
+    end
+  end
+
+  class UnsatisfiableDependencyError < StandardError
+    attr_accessor :source, :dep
+    private :source=, :dep=
+
+    def initialize(source, dep)
+      msg = "File #{source} has unsatisfiable dependency:\n" +
+            "  #{dep}"
+      self.source = source
+      self.dep = dep
+      super(msg)
+    end
+  end
+end
+

data/lib/jsdm/natural_loops.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+class JSDM
+  class NaturalLoops
+    def self.find(graph, back_edges)
+      loops = Set.new
+      back_edges.each do |arc|
+        l = [arc.first, arc.last]
+        stack = []
+        stack.push arc.first if arc.first != arc.last
+        while !stack.empty?
+          u = stack.pop
+          neighbors = graph.arcs.
+                            select { |a| a.last == u }.
+                            map { |a| a.first }.each 
+          neighbors.each do |v|
+            if !l.include?(v)
+              l << v
+              stack.push v
+            end
+          end
+        end
+        loops << l.to_set
+      end
+      loops
+    end
+  end
+end

data/lib/jsdm/preprocessor.rb

@@ -0,0 +1,25 @@
+class JSDM
+  class Preprocessor
+    attr_accessor :sources, :comment_pattern, :require_pattern
+
+    def initialize(sources)
+      self.sources = sources
+      self.comment_pattern = /^\s*\/\/\s*/
+      self.require_pattern = /#{comment_pattern}#\s*require\s*/
+    end
+
+    def process_single(source)
+      File.open(source).
+           each_line.
+           take_while { |line| line =~ comment_pattern }.
+           select { |line| line =~ require_pattern }.
+           map { |line| line.sub!(require_pattern, "").split(",") }.
+           flatten.
+           map { |entry| entry.strip }
+    end
+
+    def process
+      sources.map { |source| [source, process_single(source)] }
+    end
+  end
+end

data/lib/jsdm.rb

@@ -0,0 +1,56 @@
+require 'jsdm/dependency_manager'
+require 'jsdm/dependency_resolver'
+require 'jsdm/errors'
+require 'jsdm/preprocessor'
+
+class JSDM
+  attr_accessor :load_path, :sources, :preprocessor, :manager, :resolver, :ext
+
+  def initialize(load_path = [])
+    self.load_path    = load_path
+    self.sources      = []
+    self.preprocessor = nil
+    self.manager      = nil
+    self.resolver     = nil
+    self.ext          = 'js'
+    process!
+  end
+
+  def process!
+    self.sources      = load_path.map { |path| Dir["#{path}/**/*.#{ext}"] }.
+                                  flatten.
+                                  sort
+    self.sources      = sources.sort { rand }
+    self.preprocessor = Preprocessor.new       sources
+    self.manager      = DependencyManager.new  sources
+    self.resolver     = DependencyResolver.new load_path
+    begin
+      source = nil
+      preprocessor.process.each do |element|
+        source = element.first
+        dependencies = resolver.process element.last
+        dependencies.each do |dependency|
+          manager.add_dependency source, dependency
+        end
+      end
+    rescue FileNotFoundError => e
+      raise UnsatisfiableDependencyError.new(source, e.file)
+    end
+    self.sources = manager.process
+    sources
+  end
+
+  def sources_for(source)
+    ds = manager.dependencies_of(source)
+    ds.push(source)
+    ds
+  end
+
+  def dependencies
+    manager.dependencies
+  end
+
+  def self.same_file?(a, b)
+    File.expand_path(a) == File.expand_path(b)
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: jsdm
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 20
+  version: 0.2.20
+platform: ruby
+authors: 
+- Min Huang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-31 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "Use #require statements to declare dependencies"
+email: min.huang@alumni.usc.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/jsdm.rb
+- lib/jsdm/dependency_manager.rb
+- lib/jsdm/errors.rb
+- lib/jsdm/depth_first_search.rb
+- lib/jsdm/preprocessor.rb
+- lib/jsdm/directed_graph.rb
+- lib/jsdm/natural_loops.rb
+- lib/jsdm/dependency_resolver.rb
+- Rakefile
+has_rdoc: true
+homepage: http://www.borderstylo.com/jsdm
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Javascript dependency manager
+test_files: []
+