origen 0.1.3 → 0.2.0

data/lib/origen/specs/checkers.rb

@@ -1,103 +1,109 @@
-# rubocop:disable Style/RescueModifier:
-def name_audit(name)
-  return name if name.nil?
-  return nil unless name.is_a?(Symbol) || name.is_a?(String)
-  if name == :inspect
-    Origen.log.debug ':inspect is a reserved spec name'
-    return nil
-  end
-  if name.match(/^\d/)
-    Origen.log.debug "Spec #{name} starts with a number"
-    return nil
-  end
-  if name.match(/\s+/)
-    Origen.log.debug "Spec #{name} contains white space, removing it"
-    name.delete!(/\s+/)
-  end
-  name.is_a?(String) ? name.downcase.to_sym : name
-end
-
-# Check that min, max are not mixed with typ.  If a user wants
-# a baseline value for a spec use target as it will not be
-# checked against pass/fail
-def limits_ok?
-  status = true
-  if (@min.exp.to_s.include? '/') || (@max.exp.to_s.include? '/')
-    return status
-  end
-  if @min.exp.nil? ^ @max.exp.nil?
-    @limit_type = :single_sided
-    if @typ.exp
-      # status = false
-      Origen.log.debug "Spec #{@name} has a typical limit defined with either min or max.  They are mutually exclusive, use 'target' when using min or max"
-    end
-  elsif @min.exp && @max.exp
-    @limit_type = :double_sided
-    # Both min and max must be numerical to compare them
-    if @min.value.is_a?(Numeric) && @max.value.is_a?(Numeric)
-      # Check that min and max make sense
-      if @max.value <= @min.value || @min.value >= @max.value
-        status = false
-        Origen.log.debug "Spec #{@name} has min (#{@min.value}) and max (#{@max.value}) reversed"
+module Origen
+  module Specs
+    module Checkers
+      # rubocop:disable Style/RescueModifier:
+      def name_audit(name)
+        return name if name.nil?
+        return nil unless name.is_a?(Symbol) || name.is_a?(String)
+        if name == :inspect
+          Origen.log.debug ':inspect is a reserved spec name'
+          return nil
+        end
+        if name.match(/^\d/)
+          Origen.log.debug "Spec #{name} starts with a number"
+          return nil
+        end
+        if name.match(/\s+/)
+          Origen.log.debug "Spec #{name} contains white space, removing it"
+          name.delete!(/\s+/)
+        end
+        name.is_a?(String) ? name.downcase.to_sym : name
       end
-      # Check that target is OK
-      unless @target.nil?
-        if @target.value <= @min.value || @target.value >= @max.value
-          status = false
-          Origen.log.debug "Spec #{@name} has a target (#{@target.value}) that is not within the min (#{@min.value}) and max #{@max.value}) values"
+
+      # Check that min, max are not mixed with typ.  If a user wants
+      # a baseline value for a spec use target as it will not be
+      # checked against pass/fail
+      def limits_ok?
+        status = true
+        if (@min.exp.to_s.include? '/') || (@max.exp.to_s.include? '/')
+          return status
+        end
+        if @min.exp.nil? ^ @max.exp.nil?
+          @limit_type = :single_sided
+          if @typ.exp
+            # status = false
+            Origen.log.debug "Spec #{@name} has a typical limit defined with either min or max.  They are mutually exclusive, use 'target' when using min or max"
+          end
+        elsif @min.exp && @max.exp
+          @limit_type = :double_sided
+          # Both min and max must be numerical to compare them
+          if @min.value.is_a?(Numeric) && @max.value.is_a?(Numeric)
+            # Check that min and max make sense
+            if @max.value <= @min.value || @min.value >= @max.value
+              status = false
+              Origen.log.debug "Spec #{@name} has min (#{@min.value}) and max (#{@max.value}) reversed"
+            end
+            # Check that target is OK
+            unless @target.nil?
+              if @target.value <= @min.value || @target.value >= @max.value
+                status = false
+                Origen.log.debug "Spec #{@name} has a target (#{@target.value}) that is not within the min (#{@min.value}) and max #{@max.value}) values"
+              end
+            end
+          end
         end
+        status
       end
-    end
-  end
-  status
-end
 
-def get_mode
-  spec_mode = nil
-  if current_mode.nil?
-    if self == Origen.top_level
-      spec_mode = :global
-    else
-      spec_mode = :local
-    end
-  else
-    spec_mode = current_mode.name
-  end
-  spec_mode
-end
+      def get_mode
+        spec_mode = nil
+        if current_mode.nil?
+          if self == Origen.top_level
+            spec_mode = :global
+          else
+            spec_mode = :local
+          end
+        else
+          spec_mode = current_mode.name
+        end
+        spec_mode
+      end
 
-def evaluate_limit(limit)
-  return limit if limit.is_a?(Numeric) || limit.is_a?(Symbol)
-  return nil if limit.nil?
-  limit.gsub!("\n", ' ')
-  limit.scrub!
-  result = false
-  if !!(limit.match(/^\d+\.\d+$/)) || !!(limit.match(/^-\d+\.\d+$/))
-    result = Float(limit).round(4) rescue false # Use the same four digits of accuracy as the Spec model
-  elsif !!(limit.match(/\d+\.\d+\s+\d+\.\d+/)) # workaround for multiple specs authoring bug
-    Origen.log.debug "Found two numbers without an operator in the limit string '#{limit}', choosing the first..."
-    first_number = limit.match(/(\d+\.\d+)\s+\d+\.\d+/).captures.first
-    result = Float(first_number).round(4) rescue false # Use the same four digits of accuracy as the Spec model
-  # elsif !!(limit.match(/^tbd$/i)) # unique case of TBD or To Be Determined, will convert to symbol
-  #  limit = limit.downcase.to_sym
-  else
-    result = Integer(limit) rescue false
-  end
-  if result == false
-    # Attempt to eval the limit because users could write a limit like "3.3 + 50.mV"
-    # which would not work with the code above but should eval to a number 3.35
-    begin
-      result = eval(limit)
-      return result.round(4) if result.is_a? Numeric
-      rescue SyntaxError, NameError, TypeError
-        Origen.log.debug "Limit '#{limit}' had to be rescued, storing it as a #{limit.class}"
-        if limit.is_a? Symbol
-          return limit
+      def evaluate_limit(limit)
+        return limit if limit.is_a?(Numeric) || limit.is_a?(Symbol)
+        return nil if limit.nil?
+        limit.gsub!("\n", ' ')
+        limit.scrub!
+        result = false
+        if !!(limit.match(/^\d+\.\d+$/)) || !!(limit.match(/^-\d+\.\d+$/))
+          result = Float(limit).round(4) rescue false # Use the same four digits of accuracy as the Spec model
+        elsif !!(limit.match(/\d+\.\d+\s+\d+\.\d+/)) # workaround for multiple specs authoring bug
+          Origen.log.debug "Found two numbers without an operator in the limit string '#{limit}', choosing the first..."
+          first_number = limit.match(/(\d+\.\d+)\s+\d+\.\d+/).captures.first
+          result = Float(first_number).round(4) rescue false # Use the same four digits of accuracy as the Spec model
+        # elsif !!(limit.match(/^tbd$/i)) # unique case of TBD or To Be Determined, will convert to symbol
+        #  limit = limit.downcase.to_sym
         else
-          return "#{limit}"
+          result = Integer(limit) rescue false
         end
+        if result == false
+          # Attempt to eval the limit because users could write a limit like "3.3 + 50.mV"
+          # which would not work with the code above but should eval to a number 3.35
+          begin
+            result = eval(limit)
+            return result.round(4) if result.is_a? Numeric
+            rescue SyntaxError, NameError, TypeError
+              Origen.log.debug "Limit '#{limit}' had to be rescued, storing it as a #{limit.class}"
+              if limit.is_a? Symbol
+                return limit
+              else
+                return "#{limit}"
+              end
+          end
+        else
+          return result
+        end
+      end
     end
-  else
-    return result
   end
 end

data/lib/origen/specs/creation_info.rb

@@ -1,12 +1,32 @@
 module Origen
   module Specs
-    # This class is used to store spec note information used to document IP
+    # Ruby Data Class that contains Creation Information for the IP Block
     class Creation_Info
-      attr_accessor :author, :date, :revision, :source, :tool, :tool_version
+      attr_accessor :author, :date, :revision, :source, :tool, :tool_version, :ip_version
 
-      def initialize(author, date, src_info = {}, tool_info = {})
+      # Initialize the Creation Info block to store data for latest version of the file.
+      #
+      # ==== Parameters
+      #
+      # * author    # Author/Subject Matter Expert for the IP Block
+      # * date      # Date that the File was released to Downstream Audiences
+      # ==== Source Information
+      #
+      # * :revision # Revision Information
+      # * :source   # Where the Information came from
+      #
+      # ==== Tool Info
+      #
+      # * :tool      # Tool that created the initial XML file
+      # * :version   # Version of the Tool that created the XML file
+      #
+      # ==== Example
+      #
+      #   Creation_Info.new("author", "07/10/2015", :revision => "5.4", :source => "CSV", :tool => "oRiGeN", :tool_version => "0.0.6")
+      def initialize(author, date, ip_version, src_info = {}, tool_info = {})
         @author = author
         @date = date
+        @ip_version = ip_version
         @revision = src_info[:revision]
         @source = src_info[:source]
         @tool = tool_info[:tool]

data/lib/origen/specs/spec.rb

@@ -3,7 +3,8 @@ module Origen
     class Spec
       autoload :Note, 'origen/specs/note'
       autoload :Exhibit, 'origen/specs/exhibit'
-      require_relative 'checkers'
+      include Checkers
+      extend Checkers
 
       SpecAttribute = Struct.new(:name, :type, :required, :author, :description)
 
@@ -106,6 +107,12 @@ module Origen
         fail "Spec #{name} failed the limits audit!" unless limits_ok?
       end
 
+      def inspect
+        $dut.send(:specs_to_table_string, [self])
+      rescue
+        super
+      end
+
       def method_missing(method, *args, &block)
         ivar = "@#{method.to_s.gsub('=', '')}"
         ivar_sym = ":#{ivar}"

data/lib/origen/users/user.rb

@@ -66,16 +66,25 @@ module Origen
       end
 
       def name
-        @name || @id
+        @name || name_from_rc || @id
+      end
+
+      def name_from_rc
+        RevisionControl::Git.user_name
       end
 
       def email
-        return @email if @email
-        if Origen.site_config.email_domain
-          "#{id}@#{Origen.site_config.email_domain}"
+        @email || email_from_rc || begin
+          if Origen.site_config.email_domain
+            "#{id}@#{Origen.site_config.email_domain}"
+          end
         end
       end
 
+      def email_from_rc
+        RevisionControl::Git.user_email
+      end
+
       # Fetch user data from the FSL application directory
       #
       # @example

data/lib/origen/utility.rb

@@ -8,5 +8,6 @@ module Origen
     autoload :TimeAndDate, 'origen/utility/time_and_date'
     autoload :InputCapture, 'origen/utility/input_capture'
     autoload :BlockArgs, 'origen/utility/block_args'
+    autoload :FileDiff,  'origen/utility/file_diff.rb'
   end
 end

data/lib/origen/utility/diff.rb

@@ -101,9 +101,13 @@ module Origen
           if @comment_char
             # Screen off any inline comments at the end of line
             begin
-              [@comment_char].flatten.each do |_char|
-                if line =~ /(.*)#{@char}.*/
-                  return Regexp.last_match[1].strip
+              [@comment_char].flatten.each do |comchar|
+                unless line =~ /^\s*#{comchar}/
+                  if line =~ /(.*)\s*#{comchar}.*/
+                    return Regexp.last_match[1].strip
+                  else
+                    return line.strip
+                  end
                 end
               end
             # This rescue is a crude way to guard against non-ASCII files that find

data/lib/origen/utility/file_diff.rb

@@ -0,0 +1,213 @@
+module Origen
+  module Utility
+    module FileDiff
+      class InputFile < Array
+        attr_accessor :pointer
+
+        def initialize
+          self.pointer = 0
+        end
+
+        def current_line
+          self[pointer]
+        end
+
+        def advance_pointer!
+          self.pointer += 1
+        end
+
+        def find_current_line_in(other)
+          index = (other[other.pointer..-1] || []).index(current_line)
+          index.nil? ? nil : other.pointer + index
+        end
+      end
+
+      class OutputFile < Array
+        class Line < String
+          attr_accessor :type, :original_number
+          def initialize(type, input_file)
+            self.type = type
+            return unless input_file
+            replace(input_file.current_line)
+            self.original_number = input_file.pointer + 1
+            input_file.advance_pointer!
+          end
+        end
+
+        def add_line(type, input_file = nil)
+          push(Line.new(type, input_file))
+        end
+      end
+
+      # Diff Processor (Origen::Utility::Processor) provides an easy way to diff the contents of two files
+      # and display the differences as an HTML file or a TXT file.
+      # Very basic functionality, but can be expanded to add more features in the future.
+      # Comments are not ignored for now (maybe a future enhancement)
+      # Each difference is displayed in a different color in the HTML page
+      # Legend:
+      #       - New: Light Green
+      #       - Modified: Light Gray
+      #       - Deleted: Pink
+      # Usage:
+      #       processor = Origen::Utility::FileDiff::Processor.new("#{Origen.root}/left.txt", "#{Origen.root}/right.txt")
+      #
+      # To Generate a HTML file (diff.html) showing the differences
+      #       Origen::Utility::FileDiff::Formatter::Html.new(processor.process!, "#{Origen.root}/diff.html").format
+      #
+      # To Generate a TXT file (diff.txt) showing the differences
+      #       Origen::Utility::FileDiff::Formatter::Text.new(processor.process!, "#{Origen.root}/diff.txt").format
+      class Processor
+        attr_accessor :source, :target
+        attr_accessor :source_output, :target_output
+        def initialize(source_file_name, target_file_name)
+          self.source = InputFile.new
+          self.target = InputFile.new
+          self.source_output = OutputFile.new
+          self.target_output = OutputFile.new
+          IO.readlines(source_file_name).each do |line|
+            source << line
+          end
+          IO.readlines(target_file_name).each do |line|
+            target << line
+          end
+        end
+
+        def handle_exactly_matched
+          source_output.add_line(:unchanged, source)
+          target_output.add_line(:unchanged, target)
+        end
+
+        def handle_line_changed
+          source_output.add_line(:changed, source)
+          target_output.add_line(:changed, target)
+        end
+
+        def handle_block_added(size)
+          size.times do
+            source_output.add_line(:added) # Empty line in the left side of the diff
+            target_output.add_line(:added, target)
+          end
+        end
+
+        def handle_block_deleted(size)
+          size.times do
+            source_output.add_line(:deleted, source)
+            target_output.add_line(:deleted)  # Empty line in the right side of the diff
+          end
+        end
+
+        def process!
+          while  source.pointer < source.size && target.pointer < target.size
+            matched = source.find_current_line_in(target)
+            if matched
+              if matched > target.pointer
+                deleted = target.find_current_line_in(source)
+                handle_block_deleted(deleted - source.pointer) if deleted
+              end
+              handle_block_added(matched - target.pointer)
+              handle_exactly_matched
+            else
+              found = target.find_current_line_in(source)
+              if found
+                handle_block_deleted(found - source.pointer)
+              else
+                handle_line_changed
+              end
+            end
+          end
+          handle_block_deleted(source.size - source.pointer)
+          handle_block_added(target.size - target.pointer)
+
+          self
+        end
+      end
+
+      module Formatter
+        class Base
+          attr_accessor :source_output, :target_output, :file
+          def initialize(processed_diff, output_file_name)
+            self.source_output = processed_diff.source_output
+            self.target_output = processed_diff.target_output
+            self.file = File.open(output_file_name, 'w')
+          end
+        end
+
+        class Html < Base
+          def format
+            tag(:style) { content('td{vertical-align: middle} pre{margin: 0px} .added{background-color: lightgreen;}.deleted{background-color: pink;}.changed{background-color: lightgray;}.line{background-color: lightblue}') }
+            tag :table, cellpaddig: 0, cellspacing: 0 do
+              source_output.each_with_index do |src, i|
+                tgt = target_output[i]
+                tag :tr do
+                  tag(:td, class: :line)     { tag(:pre) { content(src.original_number) } }
+                  tag(:td, class: src.type)  { tag(:pre) { content(src) } }
+                  tag(:td, class: :line)     { tag(:pre) { content(tgt.original_number) } }
+                  tag(:td, class: tgt.type)  { tag(:pre) { content(tgt) } }
+                end
+              end
+            end
+          end
+
+          private
+
+          def tag(name, options = {}, &block)
+            file.puts %(<#{name})
+            file.puts options.collect { |attribute, value| %(#{attribute}="#{value}") }
+            file.puts '>'
+            yield
+            file.puts "</#{name}>"
+          end
+
+          def content(inner_text)
+            file.puts(inner_text.to_s == '' ? '&nbsp;' : inner_text)
+          end
+        end
+
+        class Text < Base
+          def format
+            pointer = 0
+            while pointer < target_output.size
+              size = 1
+              type = source_output[pointer].type
+              case type
+              when :added
+                added(pointer,    size = get_block_size(pointer, :added))
+              when :deleted
+                deleted(pointer,  size = get_block_size(pointer, :deleted))
+              when :changed
+                changed(pointer,  size = get_block_size(pointer, :changed))
+              end
+              file.puts unless type == :unchanged
+              pointer += size
+            end
+          end
+
+          private
+
+          def get_block_size(pointer, type)
+            size = 1
+            size += 1 while target_output[pointer + size].type == type
+            size
+          end
+
+          def added(pointer, size)
+            file.puts(target_output[pointer].original_number)
+            0.upto(size - 1) { |i| file.puts("+ #{target_output[pointer + i]}") }
+          end
+
+          def deleted(pointer, size)
+            file.puts(source_output[pointer].original_number)
+            0.upto(size - 1) { |i| file.puts("- #{source_output[pointer + i]}") }
+          end
+
+          def changed(pointer, size)
+            file.puts("#{source_output[pointer].original_number},#{target_output[pointer].original_number}")
+            0.upto(size - 1) { |i| file.puts("source<< #{source_output[pointer + i]}") }
+            file.puts('=======')
+            0.upto(size - 1) { |i| file.puts("target>> #{target_output[pointer + i]}") }
+          end
+        end
+      end
+    end
+  end
+end