indexer 0.1.0 → 0.2.0

data/lib/indexer/core_ext/hash/to_h.rb

@@ -0,0 +1,4 @@
+class Hash
+  def to_h; self; end unless method_defined?(:to_h)
+end
+

data/lib/indexer/core_ext/kernel/cli.rb

@@ -0,0 +1,54 @@
+module Kernel
+  private
+  #
+  # CLI is based on Clap library
+  # Copyright (c) 2010 Michel Martens
+  #
+  def cli(*args)
+    opts = args.pop
+    argv = (args.first || ARGV).dup
+    args = []
+
+    # Split option aliases.
+    opts = opts.inject({}) do |h,(k,v)|
+      k.to_s.split(/\s+/).each{|o| h[o]=v}; h
+    end
+
+    # Convert single dash flags into multiple flags.
+    argv = argv.inject([]) do |a, v|
+      if v[0,1] == '-' && v[1,1] != '-'
+        a.concat(v[1..-1].chars.map{|c| "-#{c}"})
+      else
+        a << v
+      end
+      a
+    end
+
+    while argv.any?
+      item = argv.shift
+      flag = opts[item]
+
+      if flag
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+
+    args
+  end
+end

data/lib/indexer/importer/html.rb

@@ -153,6 +153,11 @@ module Indexer
             entry['version'] = n.content.strip
           end
 
+          # TODO: better approach to optional field?
+          if n = node.at_css('.optional')
+            entry['optional'] = true  #n.content.strip != "false"
+          end
+
           if n = (node.at_css('.groups') || node.at_css('.group'))
             text = n.content.strip
             text = text.sub(/^[(]/, '').sub(/[)]$/, '').strip

data/lib/indexer/importer/markdown.rb

@@ -25,14 +25,32 @@ module Indexer
       #
       def load_markdown(file)
         require 'nokogiri'
-        require 'redcarpet'
 
+        text = File.read(file)
+
+        begin
+          require 'redcarpet'
+          html = render_with_redcarpet(text)
+        rescue LoadError
+          require 'kramdown'
+          html = render_with_kramdown(text)
+        end
+
+        doc = Nokogiri::HTML(html)
+
+        load_html(doc)
+      end
+
+      #
+      def render_with_redcarpet(text)
         renderer = Redcarpet::Render::HTML.new()
         markdown = Redcarpet::Markdown.new(renderer, :autolink=>true, :tables=>true, :space_after_headers=>true)
-        html     = markdown.render(File.read(file))
-        doc      = Nokogiri::HTML(html)
+        markdown.render(text)
+      end
 
-        load_html(doc)
+      #
+      def render_with_kramdown(text)
+        Kramdown::Document.new(text).to_html
       end
 
     end

data/lib/indexer/metadata.rb

@@ -51,7 +51,7 @@ module Indexer
     end
 
     #
-    # Create a new Meta::Spec given a Gem::Specification or .gemspec file.
+    # Create a new Metadata instance given a Gem::Specification or .gemspec file.
     #
     # @param [Gem::Specification,String] gemspec
     #   RubyGems Gem::Specification object or path to .gemspec file.
@@ -319,17 +319,20 @@ module Indexer
 
     # TODO: should we warn if directory does not exist?
 
-    # Sets the require paths of the project.
+    # Sets the named paths of the project.
     #
-    # @param [Array<String>, String] paths
-    #   The require-paths or a glob-pattern.
+    # @param [Hash[String]=Array<String>] path_map
+    #   Mappaing of names to list of paths.
     #
-    def load_path=(paths)
-      @data[:load_path] = \
-        Array(paths).map do |path|
-          Valid.path!(path)
-          path
+    def paths=(path_map)
+      @data[:paths] = \
+        map = {}
+        path_map = path_map.to_hash if path_map.respond_to?(:to_hash)
+        Valid.hash!(path_map)
+        path_map.each do |name, paths|
+          map[name.to_s] = Array(paths).map{ |path| Valid.path!(path) }
         end
+        map
     end
 
     # List of language engine/version family supported.
@@ -534,6 +537,20 @@ module Indexer
 
     # -- Utility Methods ----------------------------------------------------
 
+    #
+    # Legacy method to common Ruby path via `paths['load']`.
+    #
+    def load_path
+      paths['load']
+    end
+
+    #
+    # Legacy method to set `paths['load']`.
+    #
+    def load_path=(path)
+      paths['load'] = Array(path).map{ |path| Valid.path!(path) }
+    end
+
     #
     # Adds a new requirement.
     #
@@ -599,7 +616,7 @@ module Indexer
       true
     end
 
-# TODO: What was used for again, load_path ?
+# TODO: What was used for again, load path ?
 =begin
   #
   # Iterates over the paths.

data/lib/indexer/validator.rb

@@ -101,11 +101,12 @@ module Indexer
       super(value)
     end
 
-    # Loadpath must be an Array of valid pathnames or a String of pathnames
-    # separated by colons or semi-colons.
-    def load_path=(value)
-      Valid.array!(value, :load_path)
-      value.each_with_index{ |path, i| Valid.path!(path, "load_path #{i}") }
+    # Paths must be a Hash of names mapped to an Array of valid pathnames.
+    def paths=(value)
+      Valid.hash!(value, :paths)
+      value.each do |name, paths|
+        paths.each_with_index{ |path, i| Valid.path!(path, "paths[#{name}] ##{i}") }
+      end
       super(value)
     end
 
@@ -294,7 +295,7 @@ module Indexer
         :resources     => [],
         :repositories  => [],
         :categories    => [],
-        :load_path     => ['lib'],
+        :paths         => {'load' => ['lib']},
         :copyrights    => []
       }
     end

data/lib/indexer/webui.rb

@@ -0,0 +1,167 @@
+#require 'fileutils'
+#require 'tmpdir'
+require 'optparse'
+require 'json'
+
+require 'rack'
+require 'rack/server'
+require 'rack/handler'
+require 'rack/builder'
+require 'rack/directory'
+require 'rack/file'
+
+module Indexer
+
+  module WebUI
+
+    # Server is a Rack-based server that simply serves up the editing page.
+    #
+    class Server 
+
+      ROOT =  File.join(File.dirname(__FILE__), 'webui')
+
+      # Rack configuration file.
+      #RACK_FILE = 'brite.ru'
+
+      #
+      #
+      #
+      def self.start(argv)
+        new(argv).start
+      end
+
+      #
+      # Server options, parsed from command line.
+      #
+      attr :options
+
+      #
+      # Setup new instance of Brite::Server.
+      #
+      def initialize(argv)
+        @options = ::Rack::Server::Options.new.parse!(argv)
+
+        @root = argv.first || Dir.pwd
+
+        @options[:app] = app
+        #@options[:pid] = "#{tmp_dir}/pids/server.pid"
+
+        @options[:Port] ||= '4444'
+      end
+
+      # THINK: Should we be using a local tmp directory instead?
+      #        Then again, why do we need them at all, really?
+
+      #
+      # Temporary directory used by the rack server.
+      #
+      def tmp_dir
+        @tmp_dir ||= File.join(Dir.tmpdir, 'indexer', root)
+      end
+
+      #
+      # Start the server.
+      #
+      def start
+#          ensure_site
+
+        # create required tmp directories if not found
+#          %w(cache pids sessions sockets).each do |dir_to_make|
+#            FileUtils.mkdir_p(File.join(tmp_dir, dir_to_make))
+#          end
+
+        ::Rack::Server.start(options)
+      end
+
+#        # Ensure root is a Brite Site.
+#        def ensure_site
+#          return true if File.exist?(rack_file)
+#          #return true if config.file
+#          abort "Where's the site?"
+#        end
+
+#        # Load Brite configuration.
+#        def config
+#          @config ||= Brite::Config.new(root)
+#        end
+
+      #
+      # Site root directory.
+      #
+      def root
+        ROOT
+      end
+
+      # Configuration file for server.
+      #def rack_file
+      #  RACK_FILE
+      #end
+
+      #
+      # If the site has a `brite.ru` file, that will be used to start the server,
+      # otherwise a standard Rack::Directory server ise used.
+      #
+      def app
+        @app ||= (
+          #if ::File.exist?(rack_file)
+          #  app, options = Rack::Builder.parse_file(rack_file, opt_parser)
+          #  @options.merge!(options)
+          #  app
+          #else
+            root = self.root
+            json = index_json
+
+            Rack::Builder.new do
+              use IndexHTML, root
+              map '/index' do
+                run Proc.new{ |env| [200, {"Content-Type" => "text/json"}, [json]] }
+              end
+              run Rack::Directory.new("#{root}")
+            end
+          #end
+        )
+      end
+
+      #
+      #
+      #
+      def index_json
+        YAML.load_file('.index').to_json
+      end
+
+      # Rack middleware to serve `index.html` file by default.
+      #
+      class IndexHTML
+        def initialize(app, root)
+          @app  = app
+          @root = root || Dir.pwd
+        end
+
+        def call(env)
+          path = Rack::Utils.unescape(env['PATH_INFO'])
+          index_file = File.join(@root, path, 'index.html')
+          if File.exists?(index_file)
+            [200, {'Content-Type' => 'text/html'}, File.new(index_file)]
+          else
+            @app.call(env) #Rack::Directory.new(@root).call(env)
+          end
+        end
+      end
+
+      #
+      #def log_path
+      #  "_brite.log"
+      #end
+
+      #
+      #def middleware
+      #  middlewares = []
+      #  #middlewares << [Rails::Rack::LogTailer, log_path] unless options[:daemonize]
+      #  #middlewares << [Rails::Rack::Debugger]  if options[:debugger]
+      #  Hash.new(middlewares)
+      #end
+    end
+
+  end
+
+end

data/lib/indexer/webui/assets/dotruby_binding.js

@@ -0,0 +1,41 @@
+
+// Remove list items.
+$('body').delegate(".remove", "click", function() {
+    var list = $(this).attr('list');
+
+    //retrieve the context
+    var context = ko.contextFor(this);
+    var parentArray = context.$parent[list];
+
+    //remove the data (context.$data) from the appropriate array on its parent (context.$parent)
+    parentArray.remove(context.$data);
+ 
+    return false;
+});
+
+// Add list items.
+$('body').delegate(".insert", "click", function() {
+    var list = $(this).attr('list');
+
+    //retrieve the context
+    var context = ko.contextFor(this);
+
+    var newItem = prompt("Enter new entry for " + list + ': ');
+
+    if (newItem != '' && newItem != null) {
+      context.$data[list].push(newItem);
+    };
+ 
+    return false;
+});
+
+//function save() {
+//  $(). ko.toJSON(DotRubyViewModel);
+//}
+
+function save() {
+  //var json = ko.toJSON(dotrubyInstance);
+  var json = JSON.stringify( ko.toJS(dotrubyInstance), null, 2 );
+  $('#lastSavedJson').val(json);
+};
+

data/lib/indexer/webui/assets/dotruby_model.js

@@ -0,0 +1,203 @@
+DotRuby = {
+
+  viewModel: function(data) {
+    var self = this;
+    var data = DotRuby.prepareData(data);
+
+    self.name            = ko.observable(data.name);
+    self.title           = ko.observable(data.title);
+    self.version         = ko.observable(data.version);
+    self.codename        = ko.observable(data.codename);
+    self.summary         = ko.observable(data.summary);
+    self.description     = ko.observable(data.description);
+    self.created         = ko.observable(data.created);
+    self.date            = ko.observable(data.date);
+    self.organization    = ko.observable(data.organization);
+    self.suite           = ko.observable(data.suite);
+    self.install_message = ko.observable(data.install_message);
+
+    self.authors         = ko.observableArray(data.authors);
+    self.repositories    = ko.observableArray(data.repositories);
+    self.requirements    = ko.observableArray(data.requirements);
+    self.dependencies    = ko.observableArray(data.dependencies);
+    self.conflicts       = ko.observableArray(data.conflicts);
+    self.alternatives    = ko.observableArray(data.alternatives);
+    self.resources       = ko.observableArray(data.resources);
+    self.copyrights      = ko.observableArray(data.copyrights);
+    self.load_path       = ko.observableArray(data.load_path);
+
+    self.addResource     = function(){
+      this.resources.push(new DotRuby.resourceModel( {label: '', uri: ''} ));
+    };
+
+    self.addRepository   = function(){
+      this.repositories.push(new DotRuby.repositoryModel( {label: '', uri: '', scm: ''} ));
+    };
+
+    self.addRequirement  = function(){
+      this.requirements.push(new DotRuby.requirementModel( {name: '', version: '', development: false, groups: [], engines: [], platforms: []} ));
+    };
+
+    self.addDependency   = function(){
+      this.dependencies.push(new DotRuby.dependencyModel( {name: '', version: '', development: false, groups: [], engines: [], platforms: []} ));
+    };
+
+    self.addCopyright    = function(){
+      this.copyrights.push(new DotRuby.copyrightModel( {holder: '', year: '', license: ''} ));
+    };
+
+    self.addAuthor       = function(){
+      this.authors.push(new DotRuby.authorModel( {name: '', email: '', website: ''} ));
+    };
+
+    self.addAlternative  = function(){
+      this.alternatives.push('');
+    };
+
+    self.addConflict     = function(){
+      this.conflicts.push('');
+    };
+
+    self.addLoadpath     = function(){
+      this.load_path.push('');
+    };
+
+    self.json            = function(){
+      // @todo Convert resources back to mapping
+      ko.toJSON(this) 
+    };
+  },
+
+  authorModel: function(data) {
+    var self = this;
+    self.name    = ko.observable(data.name);
+    self.email   = ko.observable(data.email);
+    self.website = ko.observable(data.website);
+    self.roles   = ko.observableArray(data.roles);
+  },
+
+  repositoryModel: function(data) {
+    var self = this;
+    self.label = ko.observable(data.label);
+    self.uri   = ko.observable(data.uri);
+    self.scm   = ko.observable(data.scm);
+  },
+
+  requirementModel: function(data) {
+    var self = this;
+    self.name        = ko.observable(data.name);
+    self.version     = ko.observable(data.version);
+    self.groups      = ko.observableArray(makeArray(data.groups));
+    self.platforms   = ko.observableArray(makeArray(data.platforms));
+    self.engines     = ko.observableArray(makeArray(data.engines));
+    self.development = ko.observable(data.development);
+    self.repository  = ko.observable(data.repository);
+  },
+
+  dependencyModel: function(data) {
+    var self = this;
+    self.name        = ko.observable(data.name);
+    self.version     = ko.observable(data.version);
+    self.groups      = ko.observableArray(makeArray(data.groups));
+    self.engines     = ko.observableArray(makeArray(data.engines));
+    self.platforms   = ko.observableArray(makeArray(data.platforms));
+    self.development = ko.observable(data.development);
+    self.repository  = ko.observable(data.repository);
+  },
+
+  resourceModel: function(data) {
+    var self = this;
+    self.label = ko.observable(data.label);
+    self.uri   = ko.observable(data.uri);
+  },
+
+  copyrightModel: function(data) {
+    var self = this;
+    self.holder  = ko.observable(data.holder);
+    self.year    = ko.observable(data.year);
+    self.license = ko.observable(data.license);
+  },
+
+  // take raw hash and convert elements to models
+  // also ensure all fields are accounted for
+  prepareData: function(data) {
+    newData = {
+      name: '',
+      version: '0.0.0',
+      date: '',
+      title: '',
+      organization: '',
+      summary: '',
+      description: '',
+      requirements: [],
+      dependencies: [],
+      alternatives: [],
+      repositories: [],
+      resources: [],
+      authors: [],
+      copyrights: []
+    };
+
+    _.each(data, function(val, key){
+      newData[key] = val;
+    });
+
+    newData.resources = _.map(data.resources, function(v,k){
+      return(new DotRuby.resourceModel({'label': k, 'uri': v}));
+    });
+
+    newData.requirements = _.map(data.requirements, function(a){
+      return(new DotRuby.requirementModel(a));
+    });
+
+    newData.dependencies = _.map(data.dependencies, function(a){
+      return(new DotRuby.dependencyModel(a));
+    });
+
+    newData.repositories = _.map(data.repositories, function(x){
+      return(new DotRuby.repositoryModel(x));
+    });
+
+    newData.authors = _.map(data.authors, function(x){
+      return(new DotRuby.authorModel(x));
+    });
+
+    newData.copyrights = _.map(data.copyrights, function(x){
+      return(new DotRuby.copyrightModel(x));
+    });
+
+    //newData.conflicts = _.map(data.conflicts, function(x){
+    //  return(new DotRuby.confictModel(x));
+    //});
+
+    //newData.alternatives = _.map(data.alternatives, function(x){
+    //  return(new DotRuby.copyrightModel(x));
+    //});
+
+    return newData;
+  },
+
+};
+
+//DotRuby.resourceModel.create = function(){
+//  return( new DotRuby.resourceModel({label: '', uri: ''}) );
+//};
+
+// support functions
+
+function makeArray(value){
+  if (typeof(value) == Array) {
+    return value;
+  } else {
+    return _.compact([value]);
+  }
+};
+
+function makeString(value){
+  if (typeof(value) == String) {
+    return value;
+  } else {
+    return '' + value;
+  }
+};
+