csd 0.0.15 → 0.0.16

data/lib/active_support/xml_mini/nokogiri.rb

@@ -0,0 +1,78 @@
+require 'nokogiri'
+require 'active_support/core_ext/object/blank'
+
+# = XmlMini Nokogiri implementation
+module ActiveSupport
+  module XmlMini_Nokogiri #:nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || '')
+      end
+
+      char = data.getc
+      if char.nil?
+        {}
+      else
+        data.ungetc(char)
+        doc = Nokogiri::XML(data)
+        raise doc.errors.first if doc.errors.length > 0
+        doc.to_hash
+      end
+    end
+
+    module Conversions #:nodoc:
+      module Document #:nodoc:
+        def to_hash
+          root.to_hash
+        end
+      end
+
+      module Node #:nodoc:
+        CONTENT_ROOT = '__content__'.freeze
+
+        # Convert XML document to hash
+        #
+        # hash::
+        #   Hash to merge the converted element into.
+        def to_hash(hash={})
+          node_hash = {}
+
+          # Insert node hash into parent hash correctly.
+          case hash[name]
+            when Array then hash[name] << node_hash
+            when Hash  then hash[name] = [hash[name], node_hash]
+            when nil   then hash[name] = node_hash
+          end
+
+          # Handle child elements
+          children.each do |c|
+            if c.element?
+              c.to_hash(node_hash)
+            elsif c.text? || c.cdata?
+              node_hash[CONTENT_ROOT] ||= ''
+              node_hash[CONTENT_ROOT] << c.content
+            end
+          end
+
+          # Remove content node if it is blank and there are child tags
+          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+            node_hash.delete(CONTENT_ROOT)
+          end
+
+          # Handle attributes
+          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+
+          hash
+        end
+      end
+    end
+
+    Nokogiri::XML::Document.send(:include, Conversions::Document)
+    Nokogiri::XML::Node.send(:include, Conversions::Node)
+  end
+end

data/lib/active_support/xml_mini/nokogirisax.rb

@@ -0,0 +1,83 @@
+require 'nokogiri'
+require 'active_support/core_ext/object/blank'
+
+# = XmlMini Nokogiri implementation using a SAX-based parser
+module ActiveSupport
+  module XmlMini_NokogiriSAX
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder < Nokogiri::XML::SAX::Document
+
+      CONTENT_KEY   = '__content__'.freeze
+      HASH_SIZE_KEY = '__hash_size__'.freeze
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def start_document
+        @hash = {}
+        @hash_stack = [@hash]
+      end
+
+      def end_document
+        raise "Parse stack not empty!" if @hash_stack.size > 1
+      end
+
+      def error(error_message)
+        raise error_message
+      end
+
+      def start_element(name, attrs = [])
+        new_hash = { CONTENT_KEY => '' }
+        new_hash[attrs.shift] = attrs.shift while attrs.length > 0
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+          when Array then current_hash[name] << new_hash
+          when Hash  then current_hash[name] = [current_hash[name], new_hash]
+          when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :cdata_block, :characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || '')
+      end
+
+      char = data.getc
+      if char.nil?
+        {}
+      else
+        data.ungetc(char)
+        document = self.document_class.new
+        parser = Nokogiri::XML::SAX::Parser.new(document)
+        parser.parse(data)
+        document.hash
+      end
+    end
+  end
+end

data/lib/active_support/xml_mini/rexml.rb

@@ -0,0 +1,129 @@
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/object/blank'
+
+# = XmlMini ReXML implementation
+module ActiveSupport
+  module XmlMini_REXML #:nodoc:
+    extend self
+
+    CONTENT_KEY = '__content__'.freeze
+
+    # Parse an XML Document string or IO into a simple hash
+    #
+    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
+    # and uses the defaults from ActiveSupport
+    #
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || '')
+      end
+      
+      char = data.getc
+      if char.nil?
+        {}
+      else
+        data.ungetc(char)
+        silence_warnings { require 'rexml/document' } unless defined?(REXML::Document)
+        doc = REXML::Document.new(data)
+
+        if doc.root
+          merge_element!({}, doc.root)
+        else
+          raise REXML::ParseException,
+            "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
+    end
+
+    private
+      # Convert an XML element and merge into the hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      # element::
+      #   XML element to merge into hash
+      def merge_element!(hash, element)
+        merge!(hash, element.name, collapse(element))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element {|child| merge_element!(hash, child) }
+          merge_texts!(hash, element) unless empty_content?(element)
+          hash
+        else
+          merge_texts!(hash, element)
+        end
+      end
+
+      # Merge all the texts of an element into the hash
+      #
+      # hash::
+      #   Hash to add the converted element to.
+      # element::
+      #   XML element whose texts are to me merged into the hash
+      def merge_texts!(hash, element)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, CONTENT_KEY, texts)
+        end
+      end
+
+      # Adds a new key/value pair to an existing Hash. If the key to be added
+      # already exists and the existing value associated with key is not
+      # an Array, it will be wrapped in an Array. Then the new value is
+      # appended to that Array.
+      #
+      # hash::
+      #   Hash to add key/value pair to.
+      # key::
+      #   Key to be added.
+      # value::
+      #   Value to be associated with key.
+      def merge!(hash, key, value)
+        if hash.has_key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Converts the attributes array of an XML element into a hash.
+      # Returns an empty Hash if node has no attributes.
+      #
+      # element::
+      #   XML element to extract attributes from.
+      def get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n,v| attributes[n] = v }
+        attributes
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        element.texts.join.blank?
+      end
+  end
+end

data/lib/csd.rb

@@ -1,2 +1,82 @@
-Dir.glob(File.join(File.dirname(__FILE__), 'extensions', '**', '*.rb')) { |file| require file }
-require File.join(File.dirname(__FILE__), 'csd', 'init')
+# Loading all files in CSD
+require 'csd/error'
+require 'csd/options'
+
+# The CSD namespace is given to the entire gem.
+#
+module CSD
+  class << self
+    
+    # This String holds the name of the executable the user used to bootstrap this gem
+    attr_reader :executable
+    
+    # This method "runs" the whole CSD gem, so to speak.
+    #
+    def bootstrap(options={})
+      @executable = options[:executable]
+      Options.parse!
+      respond_to_incomplete_arguments
+      Applications.current.instance.send("#{Options.action}!".to_sym)
+    end
+    
+    # This method chooses and holds the user interface instance
+    #
+    def ui
+      @@ui ||= CLI.new
+    end
+    
+    private
+    
+    # This method check the arguments the user has provided and terminates the AI with
+    # some helpful message if the arguments are invalid.
+    #
+    def respond_to_incomplete_arguments
+      choose_application unless Applications.current
+      choose_action unless Options.valid_action?
+    end
+    
+    # This methods lists all available applications
+    #
+    def choose_application
+      UI.separator
+      UI.info '  Welcome to the Automated Installer.'.green.bold
+      UI.separator
+      UI.info '  The AI can assist you with the following applications: '
+      OptionParser.new do |opts|
+        opts.banner = ''
+        Applications.all { |app| opts.list_item(app.name, app.description) }
+        UI.info opts.help
+      end
+      UI.separator
+      UI.info '  For more information type:   '.green.bold + "#{executable} [APPLICATION NAME]".cyan.bold
+      UI.info '                For example:   '.green.bold + "#{executable} minisip".cyan.bold
+      UI.separator
+      UI.warn "You did not specify a valid application name."
+      raise Error::Argument::NoApplication
+    end
+
+    # This methods lists all available actions for a specific application
+    #
+    def choose_action
+      UI.separator
+      UI.info "  Automated Installer assistance for #{Applications.current.human}".green.bold
+      UI.separator
+      UI.info "  The AI can assist you with the following tasks regarding #{Applications.current.human}: "
+      OptionParser.new do |opts|
+        opts.banner = ''
+        actions = Applications.current.actions[:public]
+        actions << Applications.current.actions[:developer] if Options.developer
+        actions.flatten.each { |action| opts.list_item(action.keys.first, action.values.first) }
+        UI.info opts.help
+      end
+      UI.separator
+      UI.info '  To execute the task:   '.green.bold + "#{executable} [TASK] #{Applications.current.name}".cyan.bold
+      UI.info '     For more details:   '.green.bold + "#{executable} help [TASK] #{Applications.current.name}".cyan.bold
+      UI.info '              Example:   '.green.bold + "#{executable} help install #{Applications.current.name}".cyan.bold
+      UI.separator
+      UI.warn "You did not specify a valid task name."
+      raise Error::Argument::NoAction
+    end
+
+  end
+end

data/lib/csd/application.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), 'application', 'default')
+

data/lib/csd/application/default.rb

@@ -0,0 +1,51 @@
+module CSD
+  # This namespace holds all individual application Modules
+  #
+  module Application
+    
+    # This is the root class of all Applications
+    #
+    module Default
+        
+      def name
+        ActiveSupport::Inflector.underscore self.to_s.demodulize
+      end
+      
+      def description
+        about.description
+      end
+      
+      def human
+        about.human
+      end
+      
+      def actions
+        about.actions
+      end
+      
+      def scopes(action)
+        about.scopes[:action]
+      end
+      
+      def options(action='')
+        options_dir      = File.join(Path.applications, name, 'options')
+        common_file      = File.join(options_dir, "common.rb")
+        specific_file    = File.join(options_dir, "#{action}.rb")
+        common_options   = File.file?(common_file) ? File.read(common_file) : ''
+        specific_options = File.file?(specific_file) ? File.read(specific_file) : ''
+        specific_options + common_options
+      end
+      
+      protected
+      
+      def about
+        about_file = File.join(Path.applications, name, 'about.yml')
+        OpenStruct.new YAML.load_file(about_file)
+      end
+      
+    end
+  end
+end
+
+
+

data/lib/csd/application/default/base.rb

@@ -0,0 +1,15 @@
+module CSD
+  # This namespace holds all individual application Modules
+  #
+  module Application
+    
+    # This is the root class of all Applications
+    #
+    class Base
+      
+    end
+  end
+end
+
+
+