origen 0.0.1 → 0.0.2

data/lib/origen/code_generators/actions.rb

@@ -0,0 +1,258 @@
+require 'open-uri'
+require 'rbconfig'
+
+module Origen
+  module CodeGenerators
+    module Actions
+      def initialize(*args) # :nodoc:
+        if args.last.is_a?(Hash)
+          @config = args.last.delete(:config) || {}
+        end
+        super
+        @in_group = nil
+      end
+
+      def config
+        @config
+      end
+
+      # Removes (comments out) the specified configuration setting from +config/application.rb+
+      #
+      #   comment_config :semantically_version
+      def comment_config(*args)
+        options = args.extract_options!
+        name = args.first.to_s
+
+        # Set the message to be shown in logs
+        log :comment, name
+
+        file = File.join(Origen.root, 'config', 'application.rb')
+        comment_lines(file, /^\s*config.#{name}\s*=.*\n/)
+      end
+
+      # Adds an entry into +config/application.rb+
+      def add_config(*args)
+        options = args.extract_options!
+        name, value = args
+
+        # Set the message to be shown in logs
+        message = name.to_s
+        if value ||= options.delete(:value)
+          message << " (#{value})"
+        end
+        log :insert, message
+
+        file = File.join(Origen.root, 'config', 'application.rb')
+        value = quote(value) if value.is_a?(String)
+        value = ":#{value}" if value.is_a?(Symbol)
+        insert_into_file file, "  config.#{name} = #{value}\n\n", after: /^\s*class.*\n/
+      end
+
+      # Adds an entry into +Gemfile+ for the supplied gem.
+      #
+      #   gem "rspec", group: :test
+      #   gem "technoweenie-restful-authentication", lib: "restful-authentication", source: "http://gems.github.com/"
+      #   gem "rails", "3.0", git: "git://github.com/rails/rails"
+      def gem(*args)
+        options = args.extract_options!
+        name, version = args
+
+        # Set the message to be shown in logs. Uses the git repo if one is given,
+        # otherwise use name (version).
+        parts, message = [quote(name)], name
+        if version ||= options.delete(:version)
+          parts << quote(version)
+          message << " (#{version})"
+        end
+        message = options[:git] if options[:git]
+
+        log :gemfile, message
+
+        options.each do |option, value|
+          parts << "#{option}: #{quote(value)}"
+        end
+
+        in_root do
+          str = "gem #{parts.join(', ')}"
+          str = '  ' + str if @in_group
+          str = "\n" + str
+          append_file 'Gemfile', str, verbose: false
+        end
+      end
+
+      # Wraps gem entries inside a group.
+      #
+      #   gem_group :development, :test do
+      #     gem "rspec-rails"
+      #   end
+      def gem_group(*names, &block)
+        name = names.map(&:inspect).join(', ')
+        log :gemfile, "group #{name}"
+
+        in_root do
+          append_file 'Gemfile', "\ngroup #{name} do", force: true
+
+          @in_group = true
+          instance_eval(&block)
+          @in_group = false
+
+          append_file 'Gemfile', "\nend\n", force: true
+        end
+      end
+
+      # Add the given source to +Gemfile+
+      #
+      #   add_source "http://gems.github.com/"
+      def add_source(source, _options = {})
+        log :source, source
+
+        in_root do
+          prepend_file 'Gemfile', "source #{quote(source)}\n", verbose: false
+        end
+      end
+
+      # Adds a line inside the Application class for <tt>config/application.rb</tt>.
+      #
+      # If options <tt>:env</tt> is specified, the line is appended to the corresponding
+      # file in <tt>config/environments</tt>.
+      #
+      #   environment do
+      #     "config.autoload_paths += %W(#{config.root}/extras)"
+      #   end
+      #
+      #   environment(nil, env: "development") do
+      #     "config.autoload_paths += %W(#{config.root}/extras)"
+      #   end
+      def environment(data = nil, options = {})
+        sentinel = /class [a-z_:]+ < Rails::Application/i
+        env_file_sentinel = /Rails\.application\.configure do/
+        data = yield if !data && block_given?
+
+        in_root do
+          if options[:env].nil?
+            inject_into_file 'config/application.rb', "\n    #{data}", after: sentinel, verbose: false
+          else
+            Array(options[:env]).each do |env|
+              inject_into_file "config/environments/#{env}.rb", "\n  #{data}", after: env_file_sentinel, verbose: false
+            end
+          end
+        end
+      end
+      alias_method :application, :environment
+
+      # Run a command in git.
+      #
+      #   git :init
+      #   git add: "this.file that.rb"
+      #   git add: "onefile.rb", rm: "badfile.cxx"
+      def git(commands = {})
+        if commands.is_a?(Symbol)
+          run "git #{commands}"
+        else
+          commands.each do |cmd, options|
+            run "git #{cmd} #{options}"
+          end
+        end
+      end
+
+      # Create a new file in the lib/ directory. Code can be specified
+      # in a block or a data string can be given.
+      #
+      #   lib("crypto.rb") do
+      #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+      #   end
+      #
+      #   lib("foreign.rb", "# Foreign code is fun")
+      def lib(filename, data = nil, &block)
+        log :lib, filename
+        create_file("lib/#{filename}", data, verbose: false, &block)
+      end
+
+      # Create a new +Rakefile+ with the provided code (either in a block or a string).
+      #
+      #   rakefile("bootstrap.rake") do
+      #     project = ask("What is the UNIX name of your project?")
+      #
+      #     <<-TASK
+      #       namespace :#{project} do
+      #         task :bootstrap do
+      #           puts "I like boots!"
+      #         end
+      #       end
+      #     TASK
+      #   end
+      #
+      #   rakefile('seed.rake', 'puts "Planting seeds"')
+      def rakefile(filename, data = nil, &block)
+        log :rakefile, filename
+        create_file("lib/tasks/#{filename}", data, verbose: false, &block)
+      end
+
+      # Generate something using a generator from Rails or a plugin.
+      # The second parameter is the argument string that is passed to
+      # the generator or an Array that is joined.
+      #
+      #   generate(:authenticated, "user session")
+      def generate(what, *args)
+        log :generate, what
+        argument = args.flat_map(&:to_s).join(' ')
+
+        in_root { run_ruby_script("bin/rails generate #{what} #{argument}", verbose: false) }
+      end
+
+      # Runs the supplied rake task
+      #
+      #   rake("db:migrate")
+      #   rake("db:migrate", env: "production")
+      #   rake("gems:install", sudo: true)
+      def rake(command, options = {})
+        log :rake, command
+        env  = options[:env] || ENV['RAILS_ENV'] || 'development'
+        sudo = options[:sudo] && RbConfig::CONFIG['host_os'] !~ /mswin|mingw/ ? 'sudo ' : ''
+        in_root { run("#{sudo}#{extify(:rake)} #{command} RAILS_ENV=#{env}", verbose: false) }
+      end
+
+      # Reads the given file at the source root and prints it in the console.
+      #
+      #   readme "README"
+      def readme(path)
+        log File.read(find_in_source_paths(path))
+      end
+
+      protected
+
+      # Define log for backwards compatibility. If just one argument is sent,
+      # invoke say, otherwise invoke say_status. Differently from say and
+      # similarly to say_status, this method respects the quiet? option given.
+      def log(*args)
+        if args.size == 1
+          say args.first.to_s unless options.quiet?
+        else
+          args << (behavior == :invoke ? :green : :red)
+          say_status(*args)
+        end
+      end
+
+      # Add an extension to the given name based on the platform.
+      def extify(name)
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+          "#{name}.bat"
+        else
+          name
+        end
+      end
+
+      # Surround string with single quotes if there is no quotes.
+      # Otherwise fall back to double quotes
+      def quote(value)
+        return value.inspect unless value.is_a? String
+
+        if value.include?("'")
+          value.inspect
+        else
+          "'#{value}'"
+        end
+      end
+    end
+  end
+end

data/lib/origen/code_generators/base.rb

@@ -0,0 +1,57 @@
+require 'thor/group'
+module Origen
+  module CodeGenerators
+    class Error < Thor::Error # :nodoc:
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+      include Origen::CodeGenerators::Actions
+
+      add_runtime_options!
+      strict_args_position!
+
+      # Convenience method to get the top-level namespace from the class name.
+      # It is returned as a lower cased and underscored string.
+      def self.namespace(name = nil)
+        @namespace ||= begin
+          names = super.split(':')
+          if names.size == 1
+            nil
+          else
+            names.first.sub(/^r_gen/, 'origen')
+          end
+        end
+      end
+
+      # Sets the base_name taking into account the current class namespace.
+      def self.name
+        @name ||= begin
+          to_s.split('::').last.sub(/(CodeGenerator|Generator)$/, '').underscore
+        end
+      end
+
+      # Cache source root and add lib/generators/base/generator/templates to
+      # source paths.
+      def self.inherited(base) #:nodoc:
+        super
+        if base.name && base.name !~ /Base$/
+          if base.namespace == 'origen'
+            Origen::CodeGenerators.origen_generators[base.name] = base
+          else
+            Origen::CodeGenerators.plugin_generators[base.namespace] ||= {}
+            Origen::CodeGenerators.plugin_generators[base.namespace][base.name] = base
+          end
+        end
+        # Give all generators access to Origen core files in their source path,
+        # with their own app as highest priority
+        base.source_paths << Origen.root if Origen.app_loaded?
+        base.source_paths << Origen.top
+      end
+
+      def self.banner
+        "origen add #{namespace == 'origen' ? '' : namespace + ':'}#{name} [options]"
+      end
+    end
+  end
+end

data/lib/origen/code_generators/bundler.rb

@@ -0,0 +1,17 @@
+module Origen
+  module CodeGenerators
+    class Bundler < Origen::CodeGenerators::Base
+      desc <<-END
+This generator will add the necessary files to convert the app to use bundler for gem
+mangement (including Origen plugins).
+END
+      def create_gemspec_file
+        if config[:type] == :application
+          template 'templates/code_generators/gemfile_app.rb', File.join(Origen.root, 'Gemfile')
+        else
+          template 'templates/code_generators/gemfile_plugin.rb', File.join(Origen.root, 'Gemfile')
+        end
+      end
+    end
+  end
+end

data/lib/origen/code_generators/gem_setup.rb

@@ -0,0 +1,49 @@
+module Origen
+  module CodeGenerators
+    class GemSetup < Origen::CodeGenerators::Base
+      desc <<-END
+This generator creates a gemspec file in the top-level directory to allow it
+to be packed up and distributed as a gem.
+END
+      def create_gemspec_file
+        @summary = ask 'Describe your plugin in a few words:'
+        template 'templates/code_generators/gemspec.rb', File.join(Origen.root, "#{Origen.app.name}.gemspec")
+      end
+
+      def create_master_require_file
+        file = "#{Origen.root}/lib/#{Origen.app.name}.rb"
+        if File.exist?(file)
+          prepend_to_file file, <<-END
+require "origen"
+require_relative "../config/application.rb"
+require_relative "../config/environment.rb"
+
+END
+        else
+          create_file file do
+            <<-END
+require "origen"
+require_relative "../config/application.rb"
+require_relative "../config/environment.rb"
+END
+          end
+        end
+      end
+
+      def verify_semver
+        unless Origen.app.version.semantic?
+          puts <<-END
+
+Warning, you application is not currently using semantic (1.2.3) versioning, this must be used if
+you want to publish your plugin as a gem.
+
+To upgrade your application to semantic versioning run the following command:
+
+  origen add semver
+
+END
+        end
+      end
+    end
+  end
+end

data/lib/origen/code_generators/rake.rb

@@ -0,0 +1,13 @@
+module Origen
+  module CodeGenerators
+    class Rake < Origen::CodeGenerators::Base
+      desc <<-END
+This generator will add the necessary files to convert the app to use rake for general
+build commands.
+END
+      def create_rake_file
+        template 'templates/code_generators/rakefile.rb', File.join(Origen.root, 'Rakefile')
+      end
+    end
+  end
+end

data/lib/origen/code_generators/rspec.rb

@@ -0,0 +1,12 @@
+module Origen
+  module CodeGenerators
+    class RSpec < Origen::CodeGenerators::Base
+      desc <<-END
+This generator will add the necessary files to use rspec for unit tests.
+END
+      def create_spec_helper_file
+        template 'templates/code_generators/spec_helper.rb', File.join(Origen.root, 'spec', 'spec_helper.rb')
+      end
+    end
+  end
+end

data/lib/origen/code_generators/semver.rb

@@ -0,0 +1,39 @@
+module Origen
+  module CodeGenerators
+    class Semver < Origen::CodeGenerators::Base
+      desc <<-END
+This generator will convert an application to use semantic (1.2.3) style versioning.
+It can also be used to bring a legacy version file up to date with the latest structure.
+END
+      def create_version_file
+        if config[:change]
+          @version = config[:change]
+        else
+          @version = Origen.app.version
+          # Ensure > 0.0.0 due to Bundler issues resolving 0.0.0.preX versions
+          until @version.semantic? && @version.greater_than_or_equal_to?(VersionString.new('0.0.1'))
+            ver = ask 'What version do you want to start from (this must be > 0.0.0) ? [0.1.0]'
+            if !ver || ver.empty?
+              @version = VersionString.new('0.1.0')
+            else
+              @version = VersionString.new(ver)
+            end
+          end
+        end
+        template 'templates/code_generators/version.rb', File.join(Origen.root, 'config', 'version.rb'), force: true
+      end
+
+      def set_configuration
+        unless Origen.app.config.semantically_version
+          comment_config :semantically_version
+          add_config :semantically_version, true
+        end
+      end
+
+      def print_version
+        puts
+        puts "You're new app version is: #{Origen.app.version(refresh: true)}"
+      end
+    end
+  end
+end

data/lib/origen/code_generators/timever.rb

@@ -0,0 +1,37 @@
+module Origen
+  module CodeGenerators
+    class Timever < Origen::CodeGenerators::Base
+      desc <<-END
+This generator will convert an application to use timestamp (sm_2014_12_04_11_11) versioning.
+It can also be used to bring a legacy version file up to date with the latest structure.
+END
+      def create_version_file
+        if config[:change]
+          @version = config[:change]
+        else
+          @version = Origen.app.version
+          unless @version.timestamp?
+            if @version.production?
+              @version = VersionString.production_timestamp
+            else
+              @version = VersionString.development_timestamp
+            end
+          end
+        end
+        template 'templates/code_generators/version_time.rb', File.join(Origen.root, 'config', 'version.rb'), force: true
+      end
+
+      def set_configuration
+        if Origen.app.config.semantically_version
+          comment_config :semantically_version
+          add_config :semantically_version, false
+        end
+      end
+
+      def print_version
+        puts
+        puts "You're new app version is: #{Origen.app.version(refresh: true)}"
+      end
+    end
+  end
+end

data/lib/origen/code_generators.rb

@@ -0,0 +1,111 @@
+require 'thor/group'
+
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+
+module Origen
+  module CodeGenerators
+    autoload :Base,            'origen/code_generators/base'
+    autoload :Actions,         'origen/code_generators/actions'
+
+    # Remove the color from output.
+    def self.no_color!
+      Thor::Base.shell = Thor::Shell::Basic
+    end
+
+    def self.origen_generators
+      @origen_generators ||= {}
+    end
+
+    def self.plugin_generators
+      @plugin_generators ||= {}
+    end
+
+    def self.load_generators
+      return if @generators_loaded
+      # Load Origen's generators
+      Dir.glob("#{Origen.top}/lib/origen/code_generators/**/*.rb").sort.each do |file|
+        require file
+      end
+      # Load generators from plugins, TBD what the rules will be here
+      @generators_loaded = true
+    end
+
+    # Receives a namespace, arguments and the behavior to invoke the generator.
+    # It's used as the default entry point for generate, destroy and update
+    # commands.
+    def self.invoke(name, args = ARGV, config = {})
+      load_generators
+      if klass = find_by_name(name)
+        args << '--help' if args.empty? && klass.arguments.any?(&:required?)
+        klass.start(args, config)
+      end
+    end
+
+    def self.find_by_name(name)
+      names = name.split(':')
+      case names.size
+      when 1
+        gen = origen_generators[names.first]
+        return gen if gen
+      when 2
+        if names.first == 'origen'
+          gen = origen_generators[names.first]
+        else
+          gen = plugin_generators[names.first][names.last]
+        end
+        return gen if gen
+      end
+      puts "Couldn't find a feature generator named: #{name}"
+      puts
+      puts 'This is the list of available features:'
+      puts
+      print_generators
+      puts
+    end
+
+    # Show help message with available generators.
+    def self.help(command = 'add')
+      puts <<-END
+Add pre-built features and code snippets.
+
+This command will add pre-built code to your application to implement a given feature. In some
+cases this will be a complete feature and in others it will provide a starting point for you
+to further customize.
+
+END
+      puts "Usage: origen #{command} FEATURE [args] [options]"
+      puts
+      puts 'General options:'
+      puts "  -h, [--help]     # Print feature's options and usage"
+      puts '  -p, [--pretend]  # Run but do not make any changes'
+      puts '  -f, [--force]    # Overwrite files that already exist'
+      puts '  -s, [--skip]     # Skip files that already exist'
+      puts '  -q, [--quiet]    # Suppress status output'
+      puts
+      puts "The available features are listed below, run 'origen add <feature> -h' for more info."
+      puts
+
+      print_generators
+      puts
+    end
+
+    def self.print_generators
+      load_generators
+      origen_generators.each do |name, _gen|
+        puts name
+      end
+      plugin_generators.each do |namespace, generators|
+        puts
+        generators.each do |_name, gen|
+          puts "#{namespace}:#{gen}"
+        end
+      end
+    end
+  end
+end

data/lib/origen/commands/add.rb

@@ -0,0 +1,12 @@
+require 'origen/code_generators'
+
+# if no argument/-h/--help is passed to origen add command, then
+# it generates the help associated.
+if [nil, '-h', '--help'].include?(ARGV.first)
+  Origen::CodeGenerators.help 'add'
+  exit
+end
+
+name = ARGV.shift
+
+Origen::CodeGenerators.invoke name, ARGV # , behavior: :invoke, destination_root: Origen.root

data/lib/origen/commands/compile.rb

@@ -0,0 +1,62 @@
+require 'optparse'
+
+options = {}
+
+# App options are options that the application can supply to extend this command
+app_options = @application_options || []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Compile an ERB template file, list of files or a directory.
+If a directory is referenced the entire sub-directory structure will be copied to the output directory, compiling any ERB
+templates it finds in the process and copying any standard files accross without modification.
+
+ERB is a templating system from Ruby that allows you to embed snippets of Ruby code in any ASCII file to create dynamic
+content. Within the context of the origen generator this means that you can include Ruby snippets that reference the target
+objects to create dynamic test program sheets, C files, VB files, documentation, etc.
+
+To create an ERB template start with a base ASCII file and append .erb to the end of the file name, upon compilation the
+.erb extension will be removed.
+
+There is not much to the syntax, this snippet covers just about everything you need to know:
+   %       - A full line of Ruby is prefixed with %, this is removed by compilation
+   %#      - A full line Ruby comment, this is removed by compilation
+   <%#  %> - An embedded Ruby comment, this is removed by compilation
+   <%   %> - An embedded Ruby snippet, this is removed by compilation
+   <%=  %> - An embedded Ruby snippet that generates content, the result is output to the compiled file
+
+Full details of ERB syntax can be found here:
+   http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
+
+Usage: origen compile [space separated files, lists or directories] [options]
+  EOT
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
+  opts.on('-l', '--lsf [ACTION]', [:clear, :add], "Submit jobs to the LSF, optionally specify whether to 'clear' or 'add' to existing jobs") { |a| options[:lsf] = true; options[:lsf_action] = a }
+  opts.on('-w', '--wait', 'Wait for LSF processing to complete') { options[:wait_for_lsf_completion] = true }
+  opts.on('-c', '--continue', 'Continue on error (to the next file)') { options[:continue] = true }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-f', '--file FILE', String, 'Override the default log file') { |o| options[:log_file] = o }
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
+  opts.on('-n', '--name NAME', String, 'Override the default output file name') { |o| options[:output_file_name] = o }
+  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
+  opts.on('-z', '--zip', 'Gzip all output files (diff checking will be skipped)') { |o| options[:zip] = o }
+  app_options.each do |app_option|
+    opts.on(*app_option) {}
+  end
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+options[:patterns] = ARGV
+options[:compile] = true  # To let the generator know a compile job has been requested
+
+Origen.load_application
+Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+Origen.app.load_target!
+Origen.app.runner.generate(options)
+Origen.lsf.wait_for_completion if options[:wait_for_lsf_completion]

data/lib/origen/commands/ctags.rb

@@ -0,0 +1,9 @@
+puts 'Generating ctags file...'
+# system("ctags -R --exclude='.ref/**,output/**' #{ORIGEN_WORK} #{ORIGEN_TOP}/lib")
+Origen.load_application
+if Origen.top == Origen.root
+  system("ctags -R #{Origen.top}/lib -f #{Origen.root}/tags")
+else
+  system("ctags -R #{Origen.top}/lib #{Origen.root}/lib -f #{Origen.root}/tags")
+end
+puts 'Completed successfully'