csd 0.1.5 → 0.1.6

data/lib/active_support/xml_mini/nokogiri.rb

@@ -1,78 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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/extensions/core/file.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-module CSD
-  module Extensions
-    module Core
-      module File
-        
-      end
-    end
-  end
-end
-
-class File #:nodoc:
-  extend CSD::Extensions::Core::File
-end

data/lib/csd/global_open_struct.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-module CSD
-  class GlobalOpenStruct
-    
-    def self.method_missing(meth, *args, &block)
-      if meth.to_s.ends_with?('=')
-        class_variable_set("@@#{meth.to_s.chop}".to_sym, *args)
-      else
-        begin
-          class_variable_get("@@#{meth}".to_sym)
-        rescue NameError => e
-          #UI.debug "The option `#{meth}´ was accessed but not available."   # FIXME: This line causes a recursion error :)
-          nil
-        end
-      end
-    end
-    
-  end
-end

data/lib/csd/path.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), 'global_open_struct')
-
-module CSD
-  class Path < GlobalOpenStruct
-    
-    def self.root
-      @@root ||= Dir.pwd
-    end
-    
-    def self.root=(path)
-      @@root = path
-    end
-    
-    def self.gem
-      @@gem ||= File.expand_path(File.join(File.dirname(__FILE__), '..' ,'..'))
-    end
-    
-    def self.vendor
-      @@vendor ||= File.join(gem, 'vendor')
-    end
-    
-    def self.applications
-      @@applications ||= File.expand_path(File.join(gem, 'lib', 'csd', 'application'))
-    end
-    
-    def self.applications=(path)
-      @@applications = File.expand_path(path)
-    end
-    
-  end
-end

data/lib/csd/ui.rb

@@ -1,2 +0,0 @@
-# encoding: utf-8
-Dir.glob(File.join(File.dirname(__FILE__), 'ui', '*.rb')) { |file| require file }

data/lib/csd/ui/cli.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), 'ui')
-
-module CSD
-  class CLI < UI
-    
-  end
-end

data/lib/csd/ui/ui.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-module CSD
-  class UI
-    
-    include Gem::UserInteraction
-    
-    # These are all possible user interactions provided by the UI
-    #
-    INTERACTIONS = %w{ separator debug info warn error ask ask_yes_no die }
-    
-    def separator
-      say
-    end
-    
-    def debug(message)
-      say "DEBUG: #{message}".magenta if Options.debug and !Options.silent
-    end
-    
-    def info(message)
-      say message if !Options.silent
-    end
-    
-    def warn(message)
-      say 'NOTE: '.red + message.red if !Options.silent
-    end
-
-    def error(message)
-      say('ERROR: '.red.blink + message.red) if !Options.silent
-    end
-    
-    def die(message)
-      say('ERROR: '.red.blink + message.red) if !Options.silent
-      abort
-    end
-    
-    protected
-    
-    # This is just a convenience wrapper so that +UI.myinteraction+ will map to +CSD.ui.myinteraction+
-    #
-    def self.method_missing(meth, *args, &block)
-      INTERACTIONS.include?(meth.to_s) ? CSD.ui.send(meth.to_sym, *args, &block) : super
-    end
-
-  end
-end

data/lib/term/ansicolor.rb

@@ -1,102 +0,0 @@
-require 'term/ansicolor/version'
-
-module Term
-  # The ANSIColor module can be used for namespacing and mixed into your own
-  # classes.
-  module ANSIColor
-    # :stopdoc:
-    ATTRIBUTES = [
-      [ :clear        ,   0 ], 
-      [ :reset        ,   0 ],     # synonym for :clear
-      [ :bold         ,   1 ], 
-      [ :dark         ,   2 ], 
-      [ :italic       ,   3 ],     # not widely implemented
-      [ :underline    ,   4 ], 
-      [ :underscore   ,   4 ],     # synonym for :underline
-      [ :blink        ,   5 ], 
-      [ :rapid_blink  ,   6 ],     # not widely implemented
-      [ :negative     ,   7 ],     # no reverse because of String#reverse
-      [ :concealed    ,   8 ], 
-      [ :strikethrough,   9 ],     # not widely implemented
-      [ :black        ,  30 ], 
-      [ :red          ,  31 ], 
-      [ :green        ,  32 ], 
-      [ :yellow       ,  33 ], 
-      [ :blue         ,  34 ], 
-      [ :magenta      ,  35 ], 
-      [ :cyan         ,  36 ], 
-      [ :white        ,  37 ], 
-      [ :on_black     ,  40 ], 
-      [ :on_red       ,  41 ], 
-      [ :on_green     ,  42 ], 
-      [ :on_yellow    ,  43 ], 
-      [ :on_blue      ,  44 ], 
-      [ :on_magenta   ,  45 ], 
-      [ :on_cyan      ,  46 ], 
-      [ :on_white     ,  47 ], 
-    ]
-
-    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
-    # :startdoc:
-
-    # Returns true, if the coloring function of this module
-    # is switched on, false otherwise.
-    def self.coloring?
-      @coloring
-    end
-
-    # Turns the coloring on or off globally, so you can easily do
-    # this for example:
-    #  Term::ANSIColor::coloring = STDOUT.isatty
-    def self.coloring=(val)
-      @coloring = val
-    end
-    self.coloring = true
-
-    ATTRIBUTES.each do |c, v|
-      eval %Q{
-          def #{c}(string = nil)
-            result = ''
-            result << "\e[#{v}m" if Term::ANSIColor.coloring?
-            if block_given?
-              result << yield
-            elsif string
-              result << string
-            elsif respond_to?(:to_str)
-              result << to_str
-            else
-              return result #only switch on
-            end
-            result << "\e[0m" if Term::ANSIColor.coloring?
-            result
-          end
-      }
-    end
-
-    # Regular expression that is used to scan for ANSI-sequences while
-    # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
-
-    # Returns an uncolored version of the string, that is all
-    # ANSI-sequences are stripped from the string.
-    def uncolored(string = nil) # :yields:
-      if block_given?
-        yield.gsub(COLORED_REGEXP, '')
-      elsif string
-        string.gsub(COLORED_REGEXP, '')
-      elsif respond_to?(:to_str)
-        to_str.gsub(COLORED_REGEXP, '')
-      else
-        ''
-      end
-    end
-
-    module_function
-
-    # Returns an array of all Term::ANSIColor attributes as symbols.
-    def attributes
-      ATTRIBUTE_NAMES
-    end
-    extend self
-  end
-end