banalize 0.0.1

data/lib/banalize/exception.rb

@@ -0,0 +1,19 @@
+module Banalize
+  class BanalizeError < StandardError; end
+
+  class Runner
+    class Error < BanalizeError; end
+  end
+
+  class Registry < Parser
+    class Error              < BanalizeError; end
+    class RuntimeError       < BanalizeError; end
+    class ArgumentError      < BanalizeError; end
+  end
+
+  class Policy
+    class Error              < BanalizeError; end
+    class RuntimeError       < BanalizeError; end
+    class ArgumentError      < BanalizeError; end
+  end
+end

data/lib/banalize/files.rb

@@ -0,0 +1,74 @@
+module Banalize
+
+  require 'active_support/inflector'
+  require 'singleton'
+
+  ##
+  # Class for handling policies files: reading and loading.
+  #
+  class Files
+
+
+    include ::Singleton
+
+    ##
+    # Get list of all policy files installed in banalize.
+    #
+    #  Policies can come from Banalize distribution in
+    #  `./lib/policies` directory or suppplied by user from
+    #  `~/.banalize/policies` directory. This allows exteding Banalize
+    #  by creating own policies without need to repackage gem.
+    # 
+    # @return [Hash] Sets class level variable `@@files` with list of
+    #     policies. All policies are groupped in 3 arrays:
+    #     `@@files[:all]`, `@@files[:ruby]`, `@@files[:other]`
+    #
+    def self.files
+      all  = Dir.glob("#{File.dirname(File.dirname(__FILE__))}/policies/*")
+      all += Dir.glob("#{Banalize::USER[:policies]}/*") if Dir.exists? Banalize::USER[:policies]
+
+      all = all.grep(%r{/[^\.]})
+
+      ruby = all.dup.keep_if { |x| x=~ /\.rb$/ }
+
+      @@files ||= {
+        all:    all,
+        ruby:   ruby,
+        other:  (all - ruby)
+      }
+    end
+
+    ##
+    # Load and populate policies list with configuration of each
+    # policy.
+    #
+    # For Ruby policies it requries each file and then calls #config
+    # method for it.
+    def self.policies
+
+      files[:ruby].each { |f| require f }
+
+      @policies ||= (files[:other].map { |f| shell_config f }) +
+                     Banalize.policies.map(&:config)
+    end
+
+    ##
+    # Read configuration from Bash shell policy and return it as Hash
+    #
+    # @param [String] bash PATH to bash policy file
+    #
+    def self.shell_config bash
+      yaml = %x{ #{bash} config 2>&1 }
+      abort "Can not execute policy file #{bash}: \n    ERROR #{yaml} " unless $?.exitstatus == 0
+      hash = YAML.load(yaml) rescue  "Can not load YAML #{yaml}"
+
+      abort "Loaded policy metdata is not Hash: #{hash.to_s}" unless hash.is_a? Hash
+      hash.merge!({
+                    path: bash,
+                    policy: File.basename(bash).to_sym
+                  })
+
+      Policy::DEFAULT.merge Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
+  end
+end

data/lib/banalize/parser.rb

@@ -0,0 +1,46 @@
+module Banalize
+
+  class Parser
+
+    def initialize path
+      @shebang = Numbered.new
+      @comments = Numbered.new 
+      @code = Numbered.new
+
+      @shebang.add lines.shift if lines.first =~ /^#!/
+
+      lines.each_index do |idx|
+
+        next if lines[idx] =~ /^\s*$/
+
+        lineno = idx + 1 + (@shebang ? 1 : 0) # Compensate for base-0 and shebang line
+
+        if lines[idx] =~ /^\s*\#/
+          @comments.add lines[idx], lineno
+        else
+          @code.add lines[idx], lineno
+        end
+      end
+    end
+
+    ##
+    # Shebang contains first line of the script if it's in `#!`
+    # format. Otherwise it is nil.
+    attr_accessor :shebang
+
+    ##
+    # Contains all block comments of the file, excluding shebang line
+    #
+    # Only hash-comments are suported at this time. Comments in the
+    # style of here-documents are not.
+    attr_accessor :comments
+
+    ##
+    # Contains all non-comments of the script, excluding shebang line.
+    #
+    # Same as with comments, excluded from code blocks are only
+    # hash-comments, but here-documents even if they are not executing
+    # any action are included here.
+    attr_accessor :code
+  end
+end

data/lib/banalize/parser/numbered.rb

@@ -0,0 +1,102 @@
+module Banalize
+
+  ##
+  # Class numbered implements simple model of numbered lines data
+  # structure. It's Mash (think Hash). 
+  #
+  # Each pair is line_number => row. Line numbers are *not*
+  # necessarily sequential.
+  class Numbered < ::Mash
+
+    def initialize *p
+      @search = nil
+      super *p
+    end
+
+    ##
+    # Return true if values of instance have specifid pattern,
+    # returned by {#grep}.
+    #
+    # @see #grep
+    #
+    def has? *params
+      !grep(*params).empty?
+    end
+    alias :have? :has?
+    
+    ##
+    # Opposite of {#has?}
+    # @see #has?
+    def does_not_have? *p
+      ! has? *p
+    end
+    alias :dont_have? :does_not_have?
+
+
+    ##
+    # Helper method to display only line numbers of the search result.
+    #
+    # Comma separated string with line numbers of {#search}
+    #
+    def lines
+      line = search.keys.join ', '
+      if Banalize::TRUNCATE
+        line.truncate(
+                      Banalize::TRUNCATE,
+                      separator: ' ', 
+                      omission: "... (total #{search.keys.length})" 
+                      )
+      end
+    end
+
+    ##
+    # Search attribute always contains last result of search (grep)
+    # operation.
+    #
+    attr_accessor :search
+
+    ##
+    # Human readable form. Only lines without numbers.
+    #
+    def to_s
+      if self.count == 1 
+        self.values.first.to_s
+      else
+        self.values.to_s
+      end
+    end
+    
+    alias :inspect :to_s
+    
+    ##
+    # Grep lines of the Numbered object (i.e. values of the hash) and
+    # return all lines together with numbers that match
+    #
+    # @param [Regexp] pattern Search Regexp pattern for lines. It
+    #     should be regexp, not string, since regular Array grep is
+    #     not used here.
+    #
+    # @return [Numbered] Returns new instance of the same class
+    #     {Numbered} containing only lines matching the search.
+    #
+    def grep pattern
+      @search = self.class.new(self.select { |idx,line|  line =~ pattern })
+    end
+
+    ##
+    # Add new line to the collection of lines. 
+    #
+    # *Attention*: since {Numbered} is a hash, adding line with the
+    # number that already exists will overwrite existing one.
+    #
+    # ## Example
+    #
+    # ```
+    #       @shebang.add lines.shift if lines.first =~ /^#!/
+    # ```
+    def add line, number=0
+      self[number] = line.chomp
+    end
+
+  end
+end

data/lib/banalize/policy.rb

@@ -0,0 +1,95 @@
+module Banalize
+  ##
+  # Class defining use of Banalize policies. Mainly for accessing
+  # attributes created by Banalize::Files class methods.
+  #
+  class Policy
+
+    ##
+    # Default settings for policies
+    #
+    DEFAULT = {
+      style: :core,
+      severity: Severity.default,
+      description: 'No description'
+    }
+
+    def initialize policy
+
+      @config =
+        Files.policies.find { |x| x[:policy] == policy.to_sym } ||
+        raise(RuntimeError, "Policy ''#{policy}' not found among policy files")
+
+    end
+
+    attr_reader :config
+
+    # Find policy or list of policies by search criteria.
+    #
+    # Search can be policy name (Symbol or String), Hash with
+    # :policy and/or :severity keys or nil.
+    #
+    # - `nil` -  no filtering. Simply list of all policies returned.
+    #
+    # - `:severity` searched for policies with severity value same as
+    #   search or higher.
+    #
+    # - `:style` - can be Symbol or Array of symbols. If it's :core
+    #   or includes :core, all policies returned.
+    #
+    #
+    # @param [String, Symbol, Hash] search Name of a policy to check
+    #     against or hash having :severity and/or :policy keys.
+    #
+    # @return [Hash]
+    #
+    def self.search search=nil
+      case search
+
+      when nil # If nothing given return all
+        Files.policies
+
+      when Symbol, String
+        [Files.policies.find { |x| x[:policy] == search.to_sym }]
+
+      when Hash
+        res = Files.policies
+        #
+        if search.has_key? :style
+
+          search[:style] = [search[:style]].flatten
+
+          res = if search[:style].include?(:core)
+                  res           # `core` - includes everything
+                else
+                  res.select { |x| search[:style].include? x[:style] }
+                end
+        end
+        #
+        # Find policies with severity this or higher
+        #
+        res = res.select { |x| x[:severity] >= search[:severity] } if
+          search.has_key? :severity
+
+        res
+
+      else
+        raise ArgumentError, "Unknown search criteria: #{search.inspect}"
+
+      end.compact
+    end
+
+    ##
+    # Return values of config hash
+    #
+    def method_missing symbol, *args, &block
+      return config[symbol] if config.has_key? symbol
+      super symbol, *args, &block
+    end
+
+    def self.method_missing symbol, *args, &block
+      self.new(*args).send symbol
+    end
+
+  end
+end

data/lib/banalize/policy/severity.rb

@@ -0,0 +1,35 @@
+module Banalize
+  class Policy
+    class Severity
+
+      LIST = { gentle: 5, stern: 4, harsh: 3, cruel: 2, brutal: 1 }
+
+      def initialize severity
+        @severity = self.to_i severity
+      end
+
+      def self.default
+        :gentle
+      end
+
+      def self.to_i severity
+        case severity
+        when Symbol, String
+          LIST[severity.to_sym]
+        when Fixnum
+          severity
+        end
+      end
+      ##
+      # Describe available severities in a taxt format
+      #
+      def self.to_s
+        format  = "%-20s%s"
+        LIST.map do |k,v|
+          sprintf format , k.to_s.humanize, v
+        end.join "\n"
+        
+      end
+    end #severity
+  end
+end

data/lib/banalize/registry.rb

@@ -0,0 +1,219 @@
+module Banalize
+
+  require 'active_support/inflector'
+  require 'singleton'
+  ##
+  # Class defining use of Banalize policies DSL. Sets some sane
+  # default values for each of the DSL methods and registers new
+  # policy in the list of policies.
+  #
+  # Instance attributes
+  # -----------
+  # Class sets following attribute accessor methods:
+  #
+  # - {#lines}
+  # - {#path} 
+  # - {#errors}
+  #
+  # Other attributes are inherited from parent Parser class.
+  #
+  # Class methods
+  # ----------------------
+  # Class methods define DSL for Banalizer. These are:
+  #
+  # - {register}
+  # - {policy}
+  # - {synopsis}
+  # - {description}
+  # - {default}
+  # - {style}
+  # - {config}
+  class Registry < Parser
+
+    # Define new policy from loading Ruby file with policy.
+    #
+    # ## Example
+    #
+    #         # First argument to the `banalizer` method call defines
+    #         # policy name and short description (AKA synopsis).
+    #         # Both `description` and `policy_name` methods are
+    #         # optional in the block.
+    #
+    #         banalizer "Check that format of shebang is #!/usr/bin/env bash" do
+    #
+    #           severity    5 # Default is 1
+    #
+    #           synopsis "Can provide alternative description here"
+    #
+    #           style 'bug'
+    #
+    #           policy_name "Don't need to specify policy name,it is defined from argument to `describe` method"
+    #
+    #           # All method calls are optional. Only required things
+    #           # are policy description and definition of method
+    #           # `run`. Method `run` must be overwritten, otherwise
+    #           # it simply raises execption.
+    #           #
+    #           # Run method must return something that evaluates into
+    #           # `true` (policy check successful) or `false`.
+    #           #
+    #           def run
+    #             lines.first =~ %r{^\#!/usr/bin/env\s+bash}
+    #           end
+    #         end
+    #
+    # @param [String] myname name for the policy
+    # @param [Block] block
+    def self.register  myname, &block
+
+      klass  = myname.to_s.gsub(/\W/, '_').camelize
+
+      c = Object.const_set klass, Class.new(self , &block)
+
+      c.synopsis myname
+      c.default({})
+      c.severity Policy::DEFAULT[:severity] unless c.severity # Set default severity if it's not defined in block
+
+      # Override these with Styles file
+      begin
+        c.description $styles[myname][:description] 
+        c.severity    $styles[myname][:severity]
+      rescue NoMethodError => e
+      end
+      
+      return c
+    end
+
+    # TODO: how to load parsers ????
+
+    @@parsers = []
+    def self.parser name
+      @@parsers << name
+    end
+
+    ##
+    # Creates new instance of policy check.
+    #
+    # @param [String] path UNIX PATH to Bash script
+    #
+    def initialize path
+      raise RuntimeError, "File does not exist: #{path}" unless File.exists? path
+      @lines = IO.read(path).force_encoding("utf-8").split($/)
+      @path = path
+      @errors = Errors.new self
+
+      # Make class level default variable accessible as instance level
+      # variable and accessor
+
+      @default = self.class.default.merge($styles[self.class.config[:policy]] || {})
+
+      super path
+    end
+
+    attr_accessor :default
+
+    # Instance of Errors class to hold all error messages from tests
+    attr_accessor :errors
+
+    ##
+    # This method must be overwritten in children classes.
+    def run
+      raise ArgumentError, "You must override #run method in class ''#{self.class.policy_name}'"
+    end
+
+    # Lines of the tested bash file, split by \n's
+    attr_accessor :lines
+
+    # UNIX path to the tested file
+    attr_accessor :path
+
+    ##
+    # Name of this policy.
+    #
+    def self.policy name=nil
+      if name
+        @policy = name.to_sym
+      else
+        @policy ||= self.name.underscore.to_sym
+      end
+    end
+
+    ##
+    # Set defaults for the policy. Defaults are hash with values used
+    # in {#run} method. When defining defaults, define them as:
+    #
+    # ```
+    #   default :max => 20
+    # ```
+    #
+    # During run defaults accessible as default[:max]
+    #
+    # Defaults can be overwriten by personal style configuration file. See {file:CONFIGURATION.md} for details.
+    #
+    def self.default hash=nil
+      @default ||= hash 
+    end
+
+
+    ##
+    # Short summary of the policy. Synopsis comes from the name of the
+    # policy which is first parameter to the `banalizer` method, but
+    # can be overwwritten by calling systemu DSL method in the block
+    # for the `banalizer` method.
+    #
+    def self.synopsis desc=nil
+      @synopsis ||= desc.to_s.humanize
+    end
+
+    def self.description hlp=nil
+      if hlp
+        @description = hlp
+      else
+        @description ||= "No description available for #{self.name}"
+      end
+    end
+
+    ##
+    # Default style is 'bug'
+    #
+    def self.style p=Policy::DEFAULT[:style]
+      @style ||= p
+    end
+
+    ##
+    # Use lowest severity by default
+    #
+    def self.severity sev=nil
+      if sev
+        @severity = Banalize::Policy::Severity.to_i(sev)
+      else
+        @severity ||= Banalize::Policy::Severity.to_i(sev)
+      end
+    end
+
+
+    ##
+    # 
+    # Return configuration for the policy.
+    #
+    # Same as config parameter of 'other' checks.
+    #
+    # @return [Hash] Hash containing all configured attributes of the
+    #     policy check.
+    #
+    def self.config
+      {
+        policy:      policy,
+        synopsis:    synopsis,
+        style:       style,
+        severity:    severity,
+        description: description,
+        klass:       name,
+        default:     default
+      }
+    end
+
+
+
+  end
+end