nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/lib/yard/cli/config.rb

@@ -0,0 +1,136 @@
+module YARD
+  module CLI
+    # CLI command to view or edit configuration options
+    # @since 0.6.2
+    class Config < Command
+      # @return [Symbol, nil] the key to view/edit, if any
+      attr_accessor :key
+
+      # @return [Array, nil] the list of values to set (or single value), if modifying
+      attr_accessor :values
+
+      # @return [Boolean] whether to reset the {#key}
+      attr_accessor :reset
+
+      # @return [Boolean] whether the value being set should be inside a list
+      attr_accessor :as_list
+
+      # @return [Boolean] whether to append values to existing key
+      attr_accessor :append
+
+      def initialize
+        super
+        self.key = nil
+        self.values = []
+        self.reset = false
+        self.append = false
+        self.as_list = false
+      end
+
+      def description
+        'Views or edits current global configuration'
+      end
+
+      def run(*args)
+        optparse(*args)
+        if key
+          if reset || values.size > 0
+            modify_item
+          else
+            view_item
+          end
+        else
+          list_configuration
+        end
+      end
+
+      private
+
+      def modify_item
+        if reset
+          log.debug "Resetting #{key}"
+          YARD::Config.options[key] = YARD::Config::DEFAULT_CONFIG_OPTIONS[key]
+        else
+          log.debug "Setting #{key} to #{values.inspect}"
+          items, current_items = encode_values, YARD::Config.options[key]
+          items = [current_items].flatten + [items].flatten if append
+          YARD::Config.options[key] = items
+        end
+        YARD::Config.save
+      end
+
+      def view_item
+        log.debug "Viewing #{key}"
+        puts YARD::Config.options[key].inspect
+      end
+
+      def list_configuration
+        log.debug "Listing configuration"
+        require 'yaml'
+        puts YAML.dump(YARD::Config.options).sub(/\A--.*\n/, '').gsub(/\n\n/, "\n")
+      end
+
+      def encode_values
+        if values.size == 1 && !as_list
+          encode_value(values.first)
+        else
+          values.map {|v| encode_value(v) }
+        end
+      end
+
+      def encode_value(value)
+        case value
+        when /^-?\d+/; value.to_i
+        when "true"; true
+        when "false"; false
+        else value
+        end
+      end
+
+      def optparse(*args)
+        list = false
+        self.as_list = false
+        self.append = false
+        opts = OptionParser.new
+        opts.banner = "Usage: yard config [options] [item [value ...]]"
+        opts.separator ""
+        opts.separator "Example: yard config load_plugins true"
+        opts.separator ""
+        opts.separator "Views and sets configuration items. If an item is provided"
+        opts.separator "With no value, the item is viewed. If a value is provided,"
+        opts.separator "the item is modified. Specifying no item is equivalent to --list."
+        opts.separator "If you specify multiple space delimited values, these are"
+        opts.separator "parsed as an array of values."
+        opts.separator ""
+        opts.separator "Note that `true` and `false` are reserved words."
+        opts.separator ""
+        opts.separator "General options:"
+
+        opts.on('-l', '--list', 'List current configuration') do
+          list = true
+        end
+        opts.on('-r', '--reset', 'Resets the specific item to default') do
+          self.reset = true
+        end
+
+        opts.separator ""
+        opts.separator "Modifying keys:"
+
+        opts.on('-a', '--append', 'Appends items to existing key values') do
+          self.append = true
+        end
+        opts.on('--as-list', 'Forces the value(s) to be wrapped in an array') do
+          self.as_list = true
+        end
+
+        common_options(opts)
+        parse_options(opts, args)
+        args = [] if list
+        self.key = args.shift.to_sym if args.size >= 1
+        self.values = args if args.size >= 1
+        args
+      end
+
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/lib/yard/cli/diff.rb

@@ -0,0 +1,201 @@
+require 'tmpdir'
+require 'fileutils'
+require 'open-uri'
+
+module YARD
+  module CLI
+    # CLI command to return the objects that were added/removed from 2 versions
+    # of a project (library, gem, working copy).
+    # @since 0.6.0
+    class Diff < Command
+      def initialize
+        super
+        @list_all = false
+        @use_git = false
+        @old_git_commit = nil
+        @old_path = Dir.pwd
+        log.show_backtraces = true
+      end
+
+      def description
+        'Returns the object diff of two gems or .yardoc files'
+      end
+
+      def run(*args)
+        registry = optparse(*args).map do |gemfile|
+          if @use_git
+            load_git_commit(gemfile)
+            Registry.all.map {|o| o.path }
+          else
+            if load_gem_data(gemfile)
+              log.info "Found #{gemfile}"
+              Registry.all.map {|o| o.path }
+            else
+              log.error "Cannot find gem #{gemfile}"
+              nil
+            end
+          end
+        end.compact
+
+        return if registry.size != 2
+
+        [   ["Added objects", registry[1] - registry[0]],
+            ["Removed objects", registry[0] - registry[1]]].each do |name, objects|
+          next if objects.empty?
+          last_object = nil
+          all_objects_notice = false
+          puts name + ":"
+          objects.sort.each do |object|
+            if !@list_all && last_object && object =~ /#{Regexp.quote last_object}(::|\.|#)/
+              print " (...)" unless all_objects_notice
+              all_objects_notice = true
+              next
+            else
+              puts
+            end
+            all_objects_notice = false
+            print "  " + object
+            last_object = object
+          end
+          puts
+          puts
+        end
+      end
+
+      private
+      
+      def load_git_commit(commit)
+        commit_path = 'git_commit' + commit.gsub(/\W/, '_')
+        tmpdir = File.join(Dir.tmpdir, commit_path)
+        log.info "Expanding #{commit} to #{tmpdir}..."
+        Dir.chdir(@old_path)
+        FileUtils.mkdir_p(tmpdir)
+        FileUtils.cp_r('.', tmpdir)
+        Dir.chdir(tmpdir)
+        log.info("git says: " + `git reset --hard #{commit}`.chomp)
+        generate_yardoc(tmpdir)
+        Dir.chdir(@old_path)
+        cleanup(commit_path)
+      end
+
+      def load_gem_data(gemfile)
+        require_rubygems
+        Registry.clear
+
+        # First check for argument as .yardoc file
+        [File.join(gemfile, '.yardoc'), gemfile].each do |yardoc|
+          log.info "Searching for .yardoc db at #{yardoc}"
+          if File.directory?(yardoc)
+            Registry.load_yardoc(yardoc)
+            Registry.load_all
+            return true
+          end
+        end
+
+        # Next check installed RubyGems
+        gemfile_without_ext = gemfile.sub(/\.gem$/, '')
+        log.info "Searching for installed gem #{gemfile_without_ext}"
+        Gem.source_index.find_name('').find do |spec|
+          if spec.full_name == gemfile_without_ext
+            if yardoc = Registry.yardoc_file_for_gem(spec.name, "= #{spec.version}")
+              Registry.load_yardoc(yardoc)
+              Registry.load_all
+            else
+              log.enter_level(Logger::ERROR) do
+                olddir = Dir.pwd
+                Gems.run(spec.name, spec.version.to_s)
+                Dir.chdir(olddir)
+              end
+            end
+            return true
+          end
+        end
+
+        # Look for local .gem file
+        gemfile += '.gem' unless gemfile =~ /\.gem$/
+        log.info "Searching for local gem file #{gemfile}"
+        if File.exist?(gemfile)
+          File.open(gemfile, 'rb') do |io|
+            expand_and_parse(gemfile, io)
+          end
+          return true
+        end
+
+        # Remote gemfile from rubygems.org
+        url = "http://rubygems.org/downloads/#{gemfile}"
+        log.info "Searching for remote gem file #{url}"
+        begin
+          open(url) {|io| expand_and_parse(gemfile, io) }
+          return true
+        rescue OpenURI::HTTPError
+        end
+        false
+      end
+
+      def expand_and_parse(gemfile, io)
+        dir = expand_gem(gemfile, io)
+        generate_yardoc(dir)
+        cleanup(gemfile)
+      end
+
+      def generate_yardoc(dir)
+        olddir = Dir.pwd
+        Dir.chdir(dir)
+        log.enter_level(Logger::ERROR) { Yardoc.run('-n', '--no-save') }
+        Dir.chdir(olddir)
+      end
+
+      def expand_gem(gemfile, io)
+        tmpdir = File.join(Dir.tmpdir, gemfile)
+        log.info "Expanding #{gemfile} to #{tmpdir}..."
+        FileUtils.mkdir_p(tmpdir)
+        Gem::Package.open(io) do |pkg|
+          pkg.each do |entry|
+            pkg.extract_entry(tmpdir, entry)
+          end
+        end
+        tmpdir
+      end
+
+      def require_rubygems
+        require 'rubygems'
+        require 'rubygems/package'
+      rescue LoadError => e
+        log.error "Missing RubyGems, cannot run this command."
+        raise(e)
+      end
+
+      def cleanup(gemfile)
+        dir = File.join(Dir.tmpdir, gemfile)
+        log.info "Cleaning up #{dir}..."
+        FileUtils.rm_rf(dir)
+      end
+
+      def optparse(*args)
+        opts = OptionParser.new
+        opts.banner = "Usage: yard diff [options] oldgem newgem"
+        opts.separator ""
+        opts.separator "Example: yard diff yard-0.5.6 yard-0.5.8"
+        opts.separator ""
+        opts.separator "If the files don't exist locally, they will be grabbed using the `gem fetch`"
+        opts.separator "command. If the gem is a .yardoc directory, it will be used. Finally, if the"
+        opts.separator "gem name matches an installed gem (full name-version syntax), that gem will be used."
+
+        opts.on('-a', '--all', 'List all objects, even if they are inside added/removed module/class') do
+          @list_all = true
+        end
+        opts.on('--git', 'Compare versions from two git commit/branches') do
+          @use_git = true
+        end
+        common_options(opts)
+        parse_options(opts, args)
+        unless args.size == 2
+          puts opts.banner
+          exit(0)
+        end
+
+        args
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/lib/yard/cli/gems.rb

@@ -0,0 +1,83 @@
+module YARD
+  module CLI
+    # @since 0.6.0
+    class Gems < Command
+      def initialize
+        @rebuild = false
+        @gems = []
+      end
+
+      def description; "Builds YARD index for gems" end
+
+      # Runs the commandline utility, parsing arguments and generating
+      # YARD indexes for gems.
+      #
+      # @param [Array<String>] args the list of arguments
+      # @return [void]
+      def run(*args)
+        require 'rubygems'
+        optparse(*args)
+        build_gems
+      end
+
+      private
+
+      # Builds .yardoc files for all non-existing gems
+      # @param [Array] gems
+      def build_gems
+        require 'rubygems'
+        @gems.each do |spec|
+          ver = "= #{spec.version}"
+          dir = Registry.yardoc_file_for_gem(spec.name, ver)
+          if dir && File.directory?(dir) && !@rebuild
+            log.debug "#{spec.name} index already exists at '#{dir}'"
+          else
+            yfile = Registry.yardoc_file_for_gem(spec.name, ver, true)
+            next unless yfile
+            next unless File.directory?(spec.full_gem_path)
+            Registry.clear
+            Dir.chdir(spec.full_gem_path)
+            log.info "Building yardoc index for gem: #{spec.full_name}"
+            Yardoc.run('--no-stats', '-n', '-b', yfile)
+          end
+        end
+      end
+
+      def add_gems(gems)
+        0.step(gems.size - 1, 2) do |index|
+          gem, ver_require = gems[index], gems[index + 1] || ">= 0"
+          specs = Gem.source_index.find_name(gem, ver_require)
+          if specs.empty?
+            log.warn "#{gem} #{ver_require} could not be found in RubyGems index"
+          else
+            @gems += specs
+          end
+        end
+      end
+
+      # Parses options
+      def optparse(*args)
+        opts = OptionParser.new
+        opts.banner = 'Usage: yard gems [options] [gem_name [version]]'
+        opts.separator ""
+        opts.separator "#{description}. If no gem_name is given,"
+        opts.separator "all gems are built."
+        opts.separator ""
+        opts.on('--rebuild', 'Rebuilds index') do
+          @rebuild = true
+        end
+
+        common_options(opts)
+        parse_options(opts, args)
+        add_gems(args)
+
+
+        if !args.empty? && @gems.empty?
+          log.error "No specified gems could be found for command"
+        elsif @gems.empty?
+          @gems += Gem.source_index.find_name('') if @gems.empty?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/lib/yard/cli/graph.rb

@@ -0,0 +1,103 @@
+module YARD
+  module CLI
+    # A command-line utility to generate Graphviz graphs from
+    # a set of objects
+    #
+    # @see Graph#run
+    # @since 0.6.0
+    class Graph < Command
+      # The options parsed out of the commandline.
+      # Default options are:
+      #   :format => :dot
+      attr_reader :options
+
+      # The set of objects to include in the graph.
+      attr_reader :objects
+
+      # Creates a new instance of the command-line utility
+      def initialize
+        super
+        @serializer = YARD::Serializers::StdoutSerializer.new
+        @options = SymbolHash[:format => :dot]
+      end
+
+      def description
+        "Graphs class diagram using Graphviz"
+      end
+
+      # Runs the command-line utility.
+      #
+      # @example
+      #   grapher = Graph.new
+      #   grapher.run('--private')
+      # @param [Array<String>] args each tokenized argument
+      def run(*args)
+        Registry.load
+        optparse(*args)
+
+        contents = objects.map {|o| o.format(options) }.join("\n")
+        Templates::Engine.render(:format => :dot, :type => :layout,
+          :verifier => @verifier, :serializer => @serializer,
+          :contents => contents)
+      end
+
+      private
+
+      # Parses commandline options.
+      # @param [Array<String>] args each tokenized argument
+      def optparse(*args)
+        visibilities = []
+        opts = OptionParser.new
+
+        opts.separator ""
+        opts.separator "General Options:"
+
+        opts.on('-b', '--db FILE', 'Use a specified .yardoc db to load from or save to. (defaults to .yardoc)') do |yfile|
+          YARD::Registry.yardoc_file = yfile
+        end
+
+        opts.on('--full', 'Full class diagrams (show methods and attributes).') do
+          options[:full] = true
+        end
+
+        opts.on('-d', '--dependencies', 'Show mixins in dependency graph.') do
+          options[:dependencies] = true
+        end
+
+        opts.on('--no-public', "Don't show public methods. (default shows public)") do
+          visibilities.delete(:public)
+        end
+
+        opts.on('--protected', "Show or don't show protected methods. (default hides protected)") do
+          visibilities.push(:protected)
+        end
+
+        opts.on('--private', "Show or don't show private methods. (default hides private)") do
+          visibilities.push(:private)
+        end
+
+        opts.separator ""
+        opts.separator "Output options:"
+
+        opts.on('--dot [OPTIONS]', 'Send the results directly to `dot` with optional arguments.') do |dotopts|
+          @serializer = Serializers::ProcessSerializer.new('dot ' + dotopts.to_s)
+        end
+
+        opts.on('-f', '--file [FILE]', 'Writes output to a file instead of stdout.') do |file|
+          @serializer = Serializers::FileSystemSerializer.new(:basepath => '.', :extension => nil)
+          @serializer.instance_eval "def serialized_path(object) #{file.inspect} end"
+        end
+
+        common_options(opts)
+        parse_options(opts, args)
+
+        @verifier = Verifier.new("object.type != :method || #{visibilities.uniq.inspect}.include?(object.visibility)")
+        if args.first
+          @objects = args.map {|o| Registry.at(o) }.compact
+        else
+          @objects = [Registry.root]
+        end
+      end
+    end
+  end
+end