shomen 0.1.0

data/lib/shomen/cli/tomdoc.rb

@@ -0,0 +1,119 @@
+module Shomen
+
+  require 'shomen/cli/abstract'
+
+  module CLI
+
+    # RDoc command line interface.
+    class TomDocCommand < Abstract
+
+      #
+      def self.run(*argv)
+        new.run(argv)
+      end
+
+      # New Shomen TomDoc command line interface.
+      def initialize
+      end
+
+      #
+      def run(argv)
+        require 'shomen/tomdoc'
+
+        defaults = {}
+        defaults[:format]  = 'json'
+        defaults[:force]   = false
+        defaults[:source]  = true
+
+        options = parse(argv, :format, :force, :visibility, :main, :source, defaults)
+
+        if !options[:force] && !root?
+          $stderr.puts "Not a project directory. Use --force to override."
+          exit -1
+        end
+
+        if argv.empty?
+          if File.exist?('.document')
+            files = File.read('.document').split("\n")
+            files = files.reject{ |f| f.strip == '' or f.strip =~ /^\#/ }
+            files = files.map{ |f| Dir[f] }.flatten
+          else
+            files = ['lib']
+          end
+        else
+          files = argv
+        end
+
+        # TODO: limit extensions of files
+        files = files.map{ |f| File.directory?(f) ? Dir[File.join(f, '**/*')] : f }.flatten
+
+        main       = options[:main] || Dir.glob('{README.*,README}').first
+        visibility = options[:visibility].to_s
+        format     = options[:format]
+
+        case format
+        when 'json', 'yaml'
+        else
+          $stderr.puts "ERROR: Format must be 'yaml` or 'json`."
+          exit -1
+        end
+
+        argf = argf(files)
+
+        tomdoc = TomDoc::Generators::Shomen.new() #@options) ignore and pattern
+        tomdoc.generate(argf.read)
+
+        case format
+        when 'yaml'
+          $stdout.puts(tomdoc.table.to_yaml)
+        else
+          $stdout.puts(tomdoc.table.to_json)
+        end
+      end
+
+      # ARGF faker.
+      def argf(files)
+        buffer = ''
+
+        files.select{ |arg| File.exists?(arg) }.each do |file|
+          buffer << File.read(file)
+        end
+
+        require 'stringio'
+        StringIO.new(buffer)
+      end
+
+=begin
+      on "-n", "--pattern=PATTERN",
+        "Limit results to strings matching PATTERN." do |pattern|
+
+        @options[:pattern] = pattern
+      end
+
+      on "-i", "--ignore",
+        "Ignore validation, print all methods we find with comments.." do
+
+        @options[:validate] = false
+      end
+=end
+
+      #
+      def option_visibility(parser, options)
+        parser.on('-v', '--visibility TYPE') do |type|
+          options[:visibility] = type
+        end
+      end
+
+      #
+      def option_main(parser, options)
+        parser.on('-m', '--main FILE') do |file|
+          options[:main] = file
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/shomen/cli/yard.rb

@@ -0,0 +1,118 @@
+module Shomen
+
+  module CLI
+
+    require 'shomen/cli/abstract'
+
+    # YARD command line interface.
+    #
+    # Unlike the RDoc command, this passes ARGV on to YARD's actual CLI interface,
+    # so all YARD commandline options are supported, albeit some options have
+    # no baring on the generation of a Shomen model).
+    #
+    # The yard command provides a utility to generate
+    # a Shomen doc file using YARD's .yardoc cache.
+    #
+    class YARDCommand < Abstract
+
+      #
+      def self.run(*argv)
+        new.run(argv)
+      end
+
+      # New Shomen YARD command line interface.
+      def initialize
+      end
+
+      #
+      def run(argv)
+        require 'shomen/yard'
+
+        force = argv.delete('--force')
+
+        if !(force or root?)
+          $stderr.puts "ERROR: Not a project directory. Use --force to override."
+          exit -1
+        end
+
+        # TODO: support -y/--yaml or -j/--json ?
+
+        format = (
+          if i = argv.index('--format') || argv.index('-f')
+            argv[i+1]
+            argv.delete_at(i)
+            argv.delete_at(i)
+          else
+            'json'
+          end
+        )
+
+        case format
+        when 'json', 'yaml'
+        else
+          $stderr.puts "ERROR: Format must be 'yaml` or 'json`."
+          exit -1
+        end
+
+        argv.unshift('-n')  # do not generate yard documentation
+        argv.unshift('-q')  # supress yard's usual output
+
+        YARD::Registry.clear  # clear the registry in memory to remove any previous runs
+
+        yard = YARD::CLI::Yardoc.new
+        yard.run(*argv)
+
+        files    = yard.options[:files].map(&:filename) + yard.files
+        database = yard.options[:db]
+
+        options = {}
+        options[:format] = format
+        options[:files]  = files
+        options[:db]     = database
+
+        #options = parse(argv, :yaml, :clear, :db, :yardopts, :force, defaults)
+
+        yard = Shomen::YardAdaptor.new(options)
+        yard.generate
+
+        case format
+        when 'yaml'
+          $stdout.puts(yard.table.to_yaml)
+        else
+          $stdout.puts(yard.table.to_json)
+        end
+      end
+
+      #
+      #def option_yaml(parser, options)
+      #  parser.on('-y', '--yaml', 'output YAML instead of JSON') do
+      #    options[:format] = :yaml
+      #  end
+      #end
+
+      #
+      #def option_clear(parser, options)
+      #  parser.on('-c', '--clear') do
+      #    options[:clear] = true
+      #  end
+      #end
+
+      #
+      #def option_db(parser, options)
+      #  parser.on('-b', '--db DIR') do |dir|
+      #    options[:db] = dir
+      #  end
+      #end
+
+      #
+      #def option_yardopts(parser, options)
+      #  parser.on('--yardopts FILE') do |file|
+      #    options[:yardopts] = file
+      #  end
+      #end
+
+    end
+
+  end
+
+end

data/lib/shomen/core_ext/hash.rb

@@ -0,0 +1,3 @@
+class Hash
+  def to_h; self; end
+end

data/lib/shomen/metadata.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+
+module Shomen
+
+  # Encapsulate metadata, which preferably comes from a .ruby file,
+  # but can fallback to a gemspec.
+  #
+  class Metadata
+    include Enumerable
+
+    # Present working directoty.
+    PWD = Dir.pwd
+
+    # Glob pattern for looking up gemspec.
+    GEMSPEC_PATTERN = '{.gemspec,*.gemspec}'
+
+    #
+    def initialize
+      @data = (
+        data = {}
+        if dotruby
+          data.merge!(YAML.load_file(dotruby))
+        elsif gemspec
+          # prefereably use dotruby library to convert,
+          # but wait until it's more mainstream
+          require 'rubygems/specification'
+          spec = ::Gem::Specification.load(gemspec)
+          data['name']        = spec.name,
+          data['title']       = spec.name.capitalize,
+          data['version']     = spec.version.to_s,
+          data['authors']     = [spec.author],
+          data['summary']     = spec.summary,
+          data['description'] = spec.description,
+          data['resources']   = {'homepage' => spec.homepage},
+        else
+          # TODO: Raise error instead ?
+          data['name'] = File.basename(Dir.pwd)
+        end
+        data['path']   = '(metadata)'
+        data['markup'] = 'rdoc'
+        data
+      )
+    end
+
+    #
+    def dotruby
+      file = File.join(PWD, '.ruby')
+      return nil unless File.exist?(file)
+      file
+    end
+
+    #
+    def gemspec
+      file = Dir[File.join(PWD, GEMSPEC_PATTERN)].first
+      return nil unless file && File.exist?(file)
+      file
+    end
+
+    #
+    def [](name)
+      @data[name]
+    end
+
+    #
+    def size
+      @data.size
+    end
+
+    #
+    def each(&blk)
+      @data.each(&blk)
+    end
+
+    #
+    def to_h
+      @data
+    end
+
+  end
+
+end

data/lib/shomen/model.rb

@@ -0,0 +1,21 @@
+if RUBY_VERSION > '1.9'
+  require_relative 'model/abstract'
+  require_relative 'model/document'
+  require_relative 'model/script'
+  require_relative 'model/module'
+  require_relative 'model/class'
+  require_relative 'model/method'
+  require_relative 'model/attribute'
+#  require_relative 'model/function'
+  require_relative 'model/constant'
+else
+  require 'shomen/model/abstract'
+  require 'shomen/model/document'
+  require 'shomen/model/script'
+  require 'shomen/model/module'
+  require 'shomen/model/class'
+  require 'shomen/model/method'
+  require 'shomen/model/attribute'
+#  require 'shomen/model/function'
+  require 'shomen/model/constant'
+end

data/lib/shomen/model/abstract.rb

@@ -0,0 +1,84 @@
+module Shomen
+
+  require 'shomen/core_ext/hash'
+
+  module Model
+
+    # Baseclass for all model classes.
+    #
+    class AbstractPrime
+      #
+      def self.attr_accessor(name)
+        name = name.to_s
+        define_method(name) do
+          self[name]
+        end
+        define_method(name+'=') do |x|
+          self[name] = x
+        end
+      end
+
+      #
+      def self.type
+        name.split('::').last.downcase
+      end
+
+      #
+      def initialize(settings={})
+        @table = {}
+        settings.each do |k,v|
+          s = "#{k}=".gsub('-','_')
+          __send__(s,v)
+        end
+      end
+
+      #
+      def [](k)
+        @table[k.to_s]
+      end
+
+      #
+      def []=(k,v)
+        @table[k.to_s] = v
+      end
+
+      #
+      def to_h
+        t = {}
+        @table.each do |k,v|
+          if v.respond_to?(:to_h)
+            t[k] = v.to_h
+          else
+            t[k] = v
+          end
+        end
+        t
+      end
+
+    end
+
+    #
+    class Abstract < AbstractPrime
+
+      #
+      def initialize(settings={})
+        super(settings)
+        @table['!'] = self.class.type
+      end
+
+      # Full name.
+      attr_accessor :path
+
+      # Hash of label => description.
+      attr_accessor :tags
+
+      #
+      def type
+        self['!']
+      end
+
+    end
+
+  end
+
+end

data/lib/shomen/model/attribute.rb

@@ -0,0 +1,25 @@
+module Shomen
+
+  module Model
+
+    require 'shomen/model/method'
+
+    #
+    class Attribute < Method
+      #
+      def self.type; 'attribute'; end
+
+      #
+      def initialize(settings={})
+        super(settings)
+        self['!'] = settings['singleton'] ? 'class-attribute' : 'attribute'
+      end
+
+      # 'R', 'W' or 'RW'
+      attr_accessor :rw
+
+    end
+
+  end
+
+end