origen 0.0.1 → 0.0.2

data/lib/origen/commands_global.rb

@@ -0,0 +1,76 @@
+require 'irb'
+require 'irb/completion'
+
+ARGV << '--help' if ARGV.empty?
+
+aliases = {
+  'i' => 'interactive',
+  'f' => 'fetch'
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+require 'origen/global_methods'
+include Origen::GlobalMethods
+
+if ARGV.delete('-d') || ARGV.delete('--debug')
+  begin
+    if RUBY_VERSION >= '2.0.0'
+      require 'byebug'
+    else
+      require 'rubygems'
+      require 'ruby-debug'
+    end
+  rescue LoadError
+    def debugger
+      caller[0] =~ /.*\/(\w+\.rb):(\d+).*/
+      puts 'The debugger gem is not installed, add the following to your Gemfile:'
+      puts
+      puts "if RUBY_VERSION >= '2.0.0'"
+      puts "  gem 'byebug', '~>3.5'"
+      puts 'else'
+      puts "  gem 'debugger', '~>1.6'"
+      puts 'end'
+      puts
+    end
+  end
+  Origen.enable_debugger
+else
+  def debugger
+    caller[0] =~ /.*\/(\w+\.rb):(\d+).*/
+    puts "#{Regexp.last_match[1]}:#{Regexp.last_match[2]} - debugger statement ignored, run again with '-d' to enable it"
+  end
+end
+
+case command
+
+when 'new'
+  require 'origen/commands/new'
+
+when '--version', '-v'
+  require 'origen/commands/version'
+
+when 'fetch', 'f'
+  require 'origen/commands/fetch'
+
+when 'interactive'
+  IRB.start
+
+else
+  puts 'Error: Command not recognized' unless ['-h', '--help'].include?(command)
+  puts <<-EOT
+Usage: origen COMMAND [ARGS]
+
+The following commands are available:
+ new          Create a new Origen application or plugin. "origen new my_app" creates a
+              new origen application workspace in "./my_app"
+ interactive  Start an interactive Origen console (short-cut alias: "i"), this is just
+              IRB with the 'origen' lib loaded automatically
+ fetch        Automatically creates the workspace for the requested plugin and
+              populates the latest version of the plugin (short-cut alias: "f")
+
+Many commands can be run with -h (or --help) for more information.
+  EOT
+  exit(1)
+end

data/lib/origen/controller.rb

@@ -0,0 +1,94 @@
+module Origen
+  module Controller
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def model(options = {})
+        options[:controller_class] = self
+        if options[:path]
+          @path_to_model = options[:path]
+        else
+          options[:model_class] = _resolve_model_class(options)
+        end
+        Origen.controllers << options
+      end
+
+      def path_to_model
+        @path_to_model
+      end
+
+      def _resolve_model_class(options)
+        class_name = options[:class_name]
+        if class_name
+          begin
+            klass = eval("#{_namespace}::#{class_name}")
+          rescue
+            begin
+              klass = eval(class_name)
+            rescue
+              begin
+                klass = eval("#{self}::#{class_name}")
+              rescue
+                puts "Could not find class: #{class_name}"
+                raise 'Unknown model class!'
+              end
+            end
+          end
+          klass
+        else
+          fail "You must supply a :class_name option when defining a controller's model!"
+        end
+      end
+
+      def _namespace
+        to_s.sub(/::[^:]*$/, '')
+      end
+    end
+
+    def is_a?(*args)
+      if model
+        super(*args) || model.is_a?(*args)
+      else
+        super(*args)
+      end
+    end
+
+    def model
+      @model ||= begin
+        if self.class.path_to_model
+          eval(self.class.path_to_model)
+        end
+      end
+    end
+
+    def respond_to?(*args)
+      if model
+        super(*args) || model.respond_to?(*args)
+      else
+        super(*args)
+      end
+    end
+
+    # Used to proxy all method and attribute requests not implemented on the controller
+    # to the model.
+    #
+    # On first call of a missing method a method is generated to avoid the missing lookup
+    # next time, this should be faster for repeated lookups of the same method, e.g. reg
+    def method_missing(method, *args, &block)
+      if model.respond_to?(method)
+        define_singleton_method(method) do |*args, &block|
+          model.send(method, *args, &block)
+        end
+        send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    private
+
+    def _model=(model)
+      @model = model
+    end
+  end
+end

data/lib/origen/core_ext/array.rb

@@ -0,0 +1,23 @@
+class Array
+  def ids
+    map(&:id)
+  end
+
+  def dups?
+    find { |e| rindex(e) != index(e) } ? true : false
+  end
+
+  def dups
+    (select { |e| rindex(e) != index(e) }).uniq
+  end
+
+  def dups_with_index
+    return {} unless self.dups?
+    hash = Hash.new { |h, k| h[k] = [] }
+    each_with_index do |val, idx|
+      hash[val] << idx
+    end
+    hash.delete_if { |_k, v| v.size == 1 }
+    hash
+  end
+end

data/lib/origen/core_ext/bignum.rb

@@ -0,0 +1,36 @@
+class Bignum
+  # Extend Fixnum to enable 10.cycles
+  def cycles
+    if block_given?
+      times do
+        yield
+        Origen.app.tester.cycle
+      end
+    else
+      Origen.app.tester.cycle(repeat: self)
+    end
+  end
+  alias_method :cycle, :cycles
+
+  alias_method :old_bit_select, :[]
+  def [](*args)
+    if args.length == 1 && !args.first.is_a?(Range)
+      old_bit_select(args.first)
+    else
+      if args.first.is_a?(Range)
+        msb = args.first.first
+        lsb = args.first.last
+      else
+        msb = args.first
+        lsb = args.last
+      end
+      (self >> lsb) & 0.ones_comp(msb - lsb + 1)
+    end
+  end
+
+  def ones_comp(num_bits)
+    self ^ ((1 << num_bits) - 1)
+  end
+  alias_method :ones_complement, :ones_comp
+  alias_method :ones_compliment, :ones_comp
+end

data/lib/origen/core_ext/enumerable.rb

@@ -0,0 +1,76 @@
+module Enumerable
+  PRIMATIVES = [TrueClass, FalseClass, NilClass, Integer, Float, String, Symbol, Regexp, Complex, Rational, Fixnum, Bignum]
+
+  def debug(msg)
+    Origen.log.debug(msg)
+  end
+
+  # Returns a list of primitives and/or complex objects found within an enumerable object
+  # It ignores empty or nil values by default but is configurable
+  # The method is recusive and will run until all enumerable objects have been examined
+  def list(options = {})
+    options = {
+      nil_or_empty: false,
+      flatten:      [], # Can be a single class or an array of classes to 'flatten' when enumerating (treated as a single value)
+      select:       [], # Select certain complex data types for enumeration
+      ignore:       [], # Ignore certain complex data types for enumeration
+      to_s:         false # If set to true this will convert a complex object called with 'flatten' option to a String
+    }.update(options)
+    list_array ||= []
+    [:ignore, :select, :flatten].each do |opt|
+      options[opt] = [options[opt]] unless options[opt].is_a? Array
+    end
+    unless options[:flatten].empty? || options[:select].empty?
+      fail "Cannot have the same arguments for 'flatten' and 'select' options" unless (options[:flatten] & options[:select]).empty?
+    end
+    unless options[:flatten].empty? || options[:ignore].empty?
+      fail "Cannot have the same arguments for 'flatten' and 'ignore' options" unless (options[:flatten] & options[:ignore]).empty?
+    end
+    unless options[:ignore].empty? || options[:select].empty?
+      fail "Cannot have the same arguments for 'ignore' and 'select' options" unless (options[:ignore] & options[:select]).empty?
+    end
+    if self.respond_to?(:empty?) && self.empty?
+      list_array << self if options[:nil_or_empty]
+    else
+      each do |k, v|
+        self.is_a?(Hash) ? item = v : item = k
+        klass = item.class.to_s
+        superklass = item.class.superclass.to_s
+        if options[:flatten].include? item.class
+          if item.respond_to?(:empty?)
+            next if item.empty? && options[:nil_or_empty] == false
+          end
+          debug "Adding current enumerable #{klass} to list as a flat object, will not enumerate through it..."
+          if options[:to_s] == true
+            list_array << "#{superklass}::#{klass}"
+          else
+            list_array << item
+          end
+          next
+        else
+          next unless options[:select].empty? || options[:select].include?(item.class) || PRIMATIVES.include?(item.class)
+          next if options[:ignore].include?(item.class)
+          case item
+          when NilClass
+            list_array << item if options[:nil_or_empty]
+          when Hash, Array, Range
+            # debugger if item == [] && $bac == 1
+            if item.empty?
+              list_array << [] if options[:nil_or_empty]
+            else
+              list_array += item.list(options)
+            end
+          when Struct
+            list_array += item.list(options)
+          when String
+            next if item.empty? && options[:nil_or_empty] == false
+            list_array << item
+          else
+            list_array << item
+          end
+        end
+      end
+    end
+    list_array
+  end
+end

data/lib/origen/core_ext/fixnum.rb

@@ -0,0 +1,46 @@
+class Fixnum
+  # Extend Fixnum to enable 10.cycles
+  def cycles
+    if block_given?
+      times do
+        yield
+        Origen.app.tester.cycle
+      end
+    else
+      Origen.app.tester.cycle(repeat: self)
+    end
+  end
+  alias_method :cycle, :cycles
+
+  alias_method :old_bit_select, :[]
+  def [](*args)
+    if args.length == 1 && !args.first.is_a?(Range)
+      old_bit_select(args.first)
+    else
+      if args.first.is_a?(Range)
+        msb = args.first.first
+        lsb = args.first.last
+      else
+        msb = args.first
+        lsb = args.last
+      end
+      (self >> lsb) & 0.ones_comp(msb - lsb + 1)
+    end
+  end
+
+  def ones_comp(num_bits)
+    self ^ ((1 << num_bits) - 1)
+  end
+  alias_method :ones_complement, :ones_comp
+  alias_method :ones_compliment, :ones_comp
+
+  def to_bool
+    if self == 1
+      return true
+    elsif self == 0
+      return false
+    else
+      return nil
+    end
+  end
+end

data/lib/origen/core_ext/hash.rb

@@ -0,0 +1,52 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+class Hash
+  def ids
+    keys
+  end
+
+  # Only updates the common keys that exist in self
+  def update_common(hash)
+    each_key do |k|
+      self[k] = hash[k] if hash.key? k
+    end
+  end
+
+  # Boolean method to check if self and another hash have intersecting keys
+  def intersect?(hash)
+    (keys.to_set & hash.keys.to_set).empty? ? false : true
+  end
+
+  # Returns a hash containing the intersecting keys between self and another hash
+  def intersections(hash)
+    (keys.to_set & hash.keys.to_set).to_a
+  end
+
+  # Filter a hash by a key filter of various types
+  def filter(filter)
+    filtered_hash = {}
+    select_logic = case filter
+      when String then 'k[Regexp.new(filter)]'
+      when (Fixnum || Integer || Float || Numeric) then "k[Regexp.new('#{filter}')]"
+      when Regexp then 'k[filter]'
+      when Symbol then 'k == filter'
+      when NilClass then true
+      else true
+    end
+    # rubocop:disable UnusedBlockArgument
+    filtered_hash = select do |k, v|
+      [TrueClass, FalseClass].include?(select_logic.class) ? select_logic : !!eval(select_logic)
+    end
+    filtered_hash
+  end
+
+  # Returns the longest key as measured by String#length
+  def longest_key
+    keys.map(&:to_s).max_by(&:length)
+  end
+
+  # Returns the longest key as measured by String#length
+  def longest_value
+    values.map(&:to_s).max_by(&:length)
+  end
+end

data/lib/origen/core_ext/module.rb

@@ -0,0 +1,14 @@
+class Module
+  def alias_accessor(new, orig)
+    alias_reader(new, orig)
+    alias_writer(new, orig)
+  end
+
+  def alias_writer(new, orig)
+    alias_method("#{new}=", "#{orig}=") if method_defined?("#{orig}=")
+  end
+
+  def alias_reader(new, orig)
+    alias_method(new, orig) if method_defined?(orig)
+  end
+end

data/lib/origen/core_ext/numeric.rb

@@ -0,0 +1,126 @@
+class Numeric
+  def to_hex
+    "0x#{to_s(16).upcase}"
+  end
+
+  def to_bin
+    "0b#{to_s(2)}"
+  end
+
+  # Converts a number to a String representing binary number
+  # Requires width of bit string for padding.  If the width is
+  # less than the number of bits required to represent the number
+  # the width argument is meaningless.
+  def to_bitstring(width)
+    '%0*b' % [width, self]
+  end
+
+  # Reverses the bit representation of a number and returns
+  # the new value.  Useful when changing register data based on bit order
+  def reverse_bits(width)
+    result = 0
+    0.upto(width - 1) do |i|
+      result += self[i] * 2**(width - 1 - i)
+    end
+    result
+  end
+
+  %w(GHz Ghz GTs Gts).each do |m|
+    define_method m do
+      self * 1_000_000_000
+    end
+  end
+
+  %w(MHz Mhz MTs Mts).each do |m|
+    define_method m do
+      self * 1_000_000
+    end
+  end
+
+  %w(GB).each do |m|
+    define_method m do
+      self * 1_024 * 1_024 * 1_024
+    end
+  end
+
+  %w(MB).each do |m|
+    define_method m do
+      self * 1_024 * 1_024
+    end
+  end
+
+  %w(to_GB).each do |m|
+    define_method m do
+      result = self / 1_024 / 1_024 / 1_024
+      if result == Integer(result)
+        return Integer(result)
+      else
+        return result
+      end
+    end
+  end
+
+  %w(to_MB).each do |m|
+    define_method m do
+      result = to_f / 1_024 / 1_024
+      if result == Integer(result)
+        return Integer(result)
+      else
+        return result
+      end
+    end
+  end
+
+  %w(kHz KHz Khz kO ko kOhm kohm).each do |m|
+    define_method m do
+      self * 1_000
+    end
+  end
+
+  %w(kB KB).each do |m|
+    define_method m do
+      self * 1_024
+    end
+  end
+
+  %w(to_kB to_KB).each do |m|
+    define_method m do
+      result = to_f / 1_024
+      if result == Integer(result)
+        return Integer(result)
+      else
+        return result
+      end
+    end
+  end
+
+  %w(v V s S a A Hz Ts Ohm ohm O o).each do |m|
+    define_method m do
+      self
+    end
+  end
+
+  %w(mv mV ms mS ma mA mo mO mOhm mohm).each do |m|
+    define_method m do
+      self / 1_000.0
+    end
+  end
+
+  %w(uv uV us uS ua uA).each do |m|
+    define_method m do
+      self / 1_000_000.0
+    end
+  end
+
+  %w(nv nV ns nS na nA).each do |m|
+    define_method m do
+      self / 1_000_000_000.0
+    end
+  end
+
+  %w(pv pV ps pS pa pA).each do |m|
+    define_method m do
+      self / 1_000_000_000_000.0
+    end
+  end
+end

data/lib/origen/core_ext/object.rb

@@ -0,0 +1,13 @@
+class Object
+  # Tries the given methods and returns the first one to return a value,
+  # ultimately returns nil if no value is found.
+  def try(*methods)
+    methods.each do |method|
+      if self.respond_to?(method)
+        val = send(method)
+        return val if val
+      end
+    end
+    nil
+  end
+end

data/lib/origen/core_ext/range.rb

@@ -0,0 +1,7 @@
+class Range
+  def reverse
+    first = self.first
+    last = self.last
+    last..first
+  end
+end

data/lib/origen/core_ext/string.rb

@@ -0,0 +1,124 @@
+require 'active_support/core_ext/string/inflections'
+begin
+  require 'scrub_rb'
+rescue LoadError
+  # Temporary patch as the scrub_rb gem is not installed to the central Ruby installation.
+  # This means that when running Origen outside of an application this functionality is not
+  # available (which is fine), within an application the gem will be loaded correctly by
+  # Bundler and the gem will require quite happily.
+end
+
+class String
+  def to_dec
+    if self =~ /0x(.*)/
+      Regexp.last_match[1].to_i(16)
+    elsif self =~ /0b(.*)/
+      Regexp.last_match[1].to_i(2)
+    else
+      to_i
+    end
+  end
+
+  def escape_underscores
+    gsub('_', '\_')
+  end
+  alias_method :escape_underscore, :escape_underscores
+
+  def camel_case
+    Origen.deprecate "String#camel_case! is deprecated, use String#camelcase instead, or if you want to get rid of spaces: my_string.gsub(' ', '_').camelcase"
+    gsub(/\s+/, '_').split('_').map(&:capitalize).join
+  end
+
+  def pad_leading_zeros(width)
+    str = self
+    (0..(width - size) - 1).each { str = '0' + str }
+    str
+  end
+
+  def to_lines(length)
+    lines = []
+    line = []
+    len = 0
+    split(/\s+/).each do |word|
+      if (len + word.length) > length
+        lines << line.join(' ')
+        line = []
+        len = 0
+      end
+      line << word
+      len += word.length + 1 # For the trailing space
+    end
+    lines << line.join(' ') unless line.empty?
+    lines
+  end
+
+  # Sanitizes the string for conversion to a symbol and returns a lower
+  # cased symbol version of the string
+  def symbolize
+    gsub(/(\n|\s|\(|\)|\.|\[|\]|-|{|})/, '_').downcase.to_sym
+  end
+
+  # acronyms
+  def to_snakecase!
+    Origen.deprecate 'String#to_snakecase! is deprecated, use String#underscore instead since it is aware of FSL acronyms'
+    gsub!(/\s+/, '')
+    g = gsub!(/(.)([A-Z])/, '\1_\2');
+    d = downcase!
+    g || d
+  end
+  alias_method :snakecase!, :to_snakecase!
+
+  def to_snakecase
+    Origen.deprecate 'String#to_snakecase is deprecated, use String#underscore instead since it is aware of FSL acronyms'
+    dup.tap(&:to_snakecase!)
+  end
+  alias_method :snakecase, :to_snakecase
+
+  def squeeze_lines
+    split(/\n+/).join(' ').squeeze(' ')
+  end
+
+  # Attempt to convert a String to a boolean answer
+  def to_bool
+    if self == true || self =~ (/^(true|t|yes|y|1)$/i)
+      return true
+    elsif self == false || self.empty? || self =~ (/^(false|f|no|n|0)$/i)
+      return false
+    else
+      return nil
+    end
+  end
+
+  # Check if a String is a numeric
+  def is_numeric?
+    return true if self =~ /\A\d+\Z/
+    true if Float(self) rescue false # rubocop:disable Style/RescueModifier
+  end
+  alias_method :numeric?, :is_numeric?
+
+  # Convert the String to a Numeric (Float or Integer)
+  def to_numeric
+    if self.numeric?
+      if to_i == to_f
+        to_i
+      else
+        to_f
+      end
+    else
+      fail "'#{self}' cannot be converted to a Numeric, exiting..."
+    end
+  end
+  alias_method :to_number, :to_numeric
+
+  # Capitalize every word
+  def titleize(options = {})
+    options = {
+      keep_specials: false
+    }.update(options)
+    if options[:keep_specials]
+      split.map(&:capitalize).join(' ')
+    else
+      split(/ |\_|\-/).map(&:capitalize).join(' ')
+    end
+  end
+end

data/lib/origen/core_ext.rb

@@ -0,0 +1,10 @@
+require 'origen/core_ext/object'
+require 'origen/core_ext/string'
+require 'origen/core_ext/fixnum'
+require 'origen/core_ext/bignum'
+require 'origen/core_ext/numeric'
+require 'origen/core_ext/module'
+require 'origen/core_ext/hash'
+require 'origen/core_ext/array'
+require 'origen/core_ext/range'
+require 'origen/core_ext/enumerable'