sugar-high 0.4.0 → 0.4.3

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.3

data/lib/sugar-high/array.rb

@@ -1,26 +1,56 @@
 require 'sugar-high/kind_of'
+require 'sugar-high/enumerable'
 require 'sugar-high/path'
 
 class Array    
-  def to_symbols option=nil
-    res = self.flatten
-    res.map!{|a| a.kind_of?(Fixnum) ? "_#{a}" : a} if option == :num
-    res.select_labels.map(&:to_s).map(&:to_sym)
+  def to_symbols
+    self.flatten.select_labels.map{|a| a.to_s.to_sym }
   end  
 
+  def to_symbols!
+    self.flatten!.select_labels!.map!{|a| a.to_s.to_sym }
+  end
+
+  def to_symbols_num
+    self.flatten.map{|a| a.kind_of?(Fixnum) ? "_#{a}" : a}.map{|a| a.to_s.to_sym }
+  end
+
+  def to_symbols_num!
+    self.flatten!.map!{|a| a.kind_of?(Fixnum) ? "_#{a}" : a}..map!{|a| a.to_s.to_sym }
+  end
+
+  def to_symbols_uniq
+    to_symbols.uniq
+  end
+
+  def to_symbols_uniq!
+    to_symbols!.uniq!
+  end
+
   def to_strings
-    self.flatten.select_labels.map(&:to_s)
+    self.flatten!.select_labels!.map!(&:to_s)
+  end  
+
+  def to_strings!
+    self.flatten.select_labels!.map!(&:to_s)
   end  
 
   def to_filenames
     self.to_strings.map(&:underscore)
   end  
 
+  def to_filenames!
+    self.to_strings!.map!(&:underscore)
+  end  
 
   def to_paths
     self.map(&:path)
   end
 
+  def to_paths!
+    self.map!(&:path)
+  end
+
   def file_join
     File.join(*self.flatten)
   end    
@@ -29,14 +59,35 @@ class Array
     self.map{|fp| fp.path.to_file }
     self.extend FilesArray    
   end
+
+  def to_files!
+    self.map!{|fp| fp.path.to_file }
+    self.extend FilesArray    
+  end
   
   def none?
     self.flatten.compact.empty?
   end 
   
- def flat_uniq
+  def flat_uniq
    self.flatten.compact.uniq
- end 
+  end 
+
+  def flat_uniq!
+   self.flatten!.compact!.uniq!
+  end 
+
+  def extract(sym)
+   map { |e| e.send(sym) }
+  end
+
+  def sum
+   inject( 0 ) { |sum,x| sum + x }
+  end
+
+  def mean
+   (size > 0) ? sum.to_f / size : 0
+  end 
 end
 
 module FilesArray

data/lib/sugar-high/class_ext.rb

@@ -0,0 +1,11 @@
+class Class
+  def include_and_extend(the_module, options={})
+    options[:instance_methods] ||= :InstanceMethods
+    options[:class_methods] ||= :ClassMethods
+    # Mainly include but be flexible
+    main_module = const_get(the_module)
+    include main_module # for an extend_and_include method, change this to extend main_module
+    include main_module.const_get(options[:instance_methods]) if main_module.const_defined?(options[:instance_methods])
+    extend main_module.const_get(options[:class_methods]) if main_module.const_defined?(options[:class_methods])
+  end
+end

data/lib/sugar-high/enumerable.rb

@@ -0,0 +1,67 @@
+module Enumerable
+  def only_kinds_of? *kinds    
+    all?{|a| a.any_kind_of? *kinds }    
+  end
+
+  def only_labels?
+    all?{|a| a.kind_of_label? }    
+  end
+  
+  def select_kinds_of *kinds
+    select{|a| a.any_kind_of? *kinds }
+  end
+
+  def select_kinds_of! *kinds
+    select!{|a| a.any_kind_of? *kinds }
+  end
+
+  def select_labels
+    select{|a| a.kind_of_label? }
+  end
+
+  def select_labels!
+    select! {|a| a.kind_of_label? }
+  end
+
+
+  def select_symbols
+    select_only :symbol
+  end
+
+  def select_symbols!
+    select_only! :symbol
+  end
+
+  def select_uniq_symbols!
+    select_only!(:symbol).uniq!
+  end
+
+  def select_strings
+    select_only :string
+  end
+
+  def select_strings
+    select_only :string
+  end
+
+  def select_only type    
+    const = type.kind_of_label? ? "#{type.to_s.camelize}".constantize : type
+    select{|a| a.kind_of? const}
+  end
+
+  def select_only! type    
+    const = type.kind_of_label? ? "#{type.to_s.camelize}".constantize : type
+    select!{|a| a.kind_of? const}
+  end
+  
+  def all_kinds
+    map do |a| 
+      case a
+      when Kinds
+        a.kinds
+      else
+        a if a.kind_of?(Module)
+      end
+    end.compact.uniq.flatten
+  end
+end

data/lib/sugar-high/file.rb

@@ -4,67 +4,36 @@ require 'sugar-high/path'
 require 'sugar-high/regexp'
 require 'sugar-high/string'
 require 'sugar-high/file_mutate'
+require 'sugar-high/file_ext'
 
 class File   
-  def self.blank? file_name
-    raise ArgumentError, "Filename argument must not be blank" if file_name.blank?
-    raise ArgumentError, "There is no file at: #{file_name}" if !File.file?(file_name)
-    File.zero?(file_name)
-  end
-  
-  def blank?
-    File.zero?(self.path)
-  end   
+  include SugarHigh::FileExt
+  extend  SugarHigh::FileExt::ClassMethods    
+end
 
-  def self.has_content? file_name, content_matcher, &block
-    File.new(file_name).has_content? content_matcher, &block  
+class Symbol
+  def as_filename
+    self.to_s.underscore
   end
-
-  def has_content? content_matcher = nil, &block  
-    content_matcher ||= yield
-    begin
-      content_matcher = content_matcher.to_regexp
-    rescue
-      raise ArgumentError, "Content match must be specified as either a String or Regexp"
-    end
-    !(self.read =~ content_matcher).nil?
+  
+  def valid_file_command?
+    [:read, :remove, :delete].include? self
   end
+  
+  def file
+    as_filename.file
+  end  
+end                 
 
-  def read_content options = {}, &block
-    File.read_from self.path, options, &block
+class NilClass
+  def valid_file_command?
+    false
   end
-  alias_method :with_content, :read_content
-
-  class << self
-
-    def read_from file_name, options = {}, &block
-      raise ArgumentError, "File to read from not found or not a file: #{file_name}" if !File.file? file_name
-      content = File.read file_name
-    
-      if options[:before] 
-        begin
-          regexp = options[:before].to_regexp
-          index = content.match(regexp).offset_before
-          content = content[0..index]
-        rescue
-          raise ArgumentError, ":before option must be a string or regular expression, was : #{options[:before]}"
-        end
-      end 
+end  
 
-      if options[:after]   
-        begin
-          regexp = options[:after].to_regexp
-          index = content.match(regexp).offset_after
-          content = content[index..-1]      
-        rescue
-          raise ArgumentError, ":after option must be a string or regular expression, was : #{options[:after]}"
-        end      
-      end
-      yield content if block
-      content
-    end
-    alias_method :read_content_from, :read_from
-    alias_method :with_content_from, :read_from
+class Array
+  def file_names ext = '*'
+    self.map{|a| a.gsub( /(.*)\//, '').gsub(/\.#{Regexp.escape(ext.to_s)}/, '')}
   end
 end
 
@@ -72,7 +41,7 @@ class String
   def as_filename
     self.underscore  
   end
-  
+
   def valid_file_command?
     self.to_sym.valid_file_command?
   end
@@ -86,7 +55,7 @@ class String
     return ::Dir.new(self) if ::File.directory?(self)
     raise "No file found at #{self}"
   end
-  
+
   def new_file
     begin 
       file
@@ -96,24 +65,3 @@ class String
   end
 end
 
-class Symbol
-  def as_filename
-    self.to_s.underscore  
-  end
-  
-  def valid_file_command?
-    [:read, :remove, :delete].include? self
-  end
-end                 
-
-class NilClass
-  def valid_file_command?
-    false
-  end
-end  
-
-class Array
-  def file_names ext = '*'
-    self.map{|a| a.gsub( /(.*)\//, '').gsub(/\.#{Regexp.escape(ext.to_s)}/, '')}
-  end
-end

data/lib/sugar-high/file_ext.rb

@@ -0,0 +1,65 @@
+module SugarHigh
+  module FileExt
+    module ClassMethods
+      def blank? file_name
+        raise ArgumentError, "Filename argument must not be blank" if file_name.blank?
+        raise ArgumentError, "There is no file at: #{file_name}" if !File.file?(file_name)
+        File.zero?(file_name)
+      end
+      
+      def has_content? file_name, content_matcher, &block
+        file = get_file file_name
+        file.has_content? content_matcher, &block  
+      end 
+      
+      def read_from file_name, options = {}, &block
+        raise ArgumentError, "File to read from not found or not a file: #{file_name}" if !File.file? file_name
+        content = File.read file_name
+
+        if options[:before] 
+          begin
+            regexp = options[:before].to_regexp
+            index = content.match(regexp).offset_before
+            content = content[0..index]
+          rescue
+            raise ArgumentError, ":before option must be a string or regular expression, was : #{options[:before]}"
+          end
+        end 
+
+        if options[:after]   
+          begin
+            regexp = options[:after].to_regexp
+            index = content.match(regexp).offset_after
+            content = content[index..-1]      
+          rescue
+            raise ArgumentError, ":after option must be a string or regular expression, was : #{options[:after]}"
+          end      
+        end
+        yield content if block
+        content
+      end
+      alias_method :read_content_from, :read_from
+      alias_method :with_content_from, :read_from           
+    end
+
+    def blank?
+      File.zero?(self.path)
+    end   
+
+    def has_content? content_matcher = nil, &block  
+      content_matcher ||= yield
+      begin
+        content_matcher = content_matcher.to_regexp
+      rescue
+        raise ArgumentError, "Content match must be specified as either a String or Regexp"
+      end
+      matched = self.read_content =~ content_matcher
+      !(matched).nil?
+    end
+
+    def read_content options = {}, &block
+      File.read_from self.path, options, &block
+    end
+    alias_method :with_content, :read_content
+  end
+end

data/lib/sugar-high/file_mutate.rb

@@ -4,203 +4,56 @@ require 'sugar-high/path'
 require 'sugar-high/regexp'
 require 'sugar-high/string'
 require 'sugar-high/file'
-
-class File
-  class << self
-    def delete! name
-      return nil if !File.exist?(name)
-      File.delete name
+require 'sugar-high/array'
+                         
+require 'sugar-high/file_mutate/delete'
+require 'sugar-high/file_mutate/overwrite_content'
+require 'sugar-high/file_mutate/append_content'
+require 'sugar-high/file_mutate/remove_content'
+require 'sugar-high/file_mutate/replace_content'
+require 'sugar-high/file_mutate/insert_content'
+require 'sugar-high/file_mutate/extras'
+
+require 'sugar-high/class_ext'
+require 'active_support/inflector'
+
+module SugarHigh
+  module FileMutate
+    autoload :Mutate,             'sugar-high/file_mutate/mutate'    
+    autoload :Delete,             'sugar-high/file_mutate/delete'    
+    autoload :AppendContent,      'sugar-high/file_mutate/append_content'
+    autoload :InsertContent,      'sugar-high/file_mutate/insert_content'    
+    autoload :OverwriteContent,   'sugar-high/file_mutate/overwrite_content'
+    autoload :RemoveContent,      'sugar-high/file_mutate/remove_content'
+    autoload :ReplaceContent,     'sugar-high/file_mutate/replace_content'    
+  end
+end
+            
+
+class File  
+  def self.mutate_ext name
+    if name == :all
+      add_mutate_exts mutate_apis
+      return
     end
-    alias_method :delete_file!, :delete!
-  end
-
-  def delete!
-    File.delete(self.path)
+    raise ArgumentError, "Unknown FileMutate API: #{name}, must be one of: #{mutate_apis}" if !mutate_apis.include? name
+    add_mutate_exts [:mutate, name]
   end
-  alias_method :delete_file!, :delete!
   
+  protected
   
-  def overwrite content=nil, &block           
-    File.overwrite self.path, content, &block
-  end
-
-  def self.overwrite file, content=nil, &block
-    filepath = case file
-    when PathString, String
-      file
-    when File
-      file.path
-    else
-      raise ArgumentError, "Expected first argument to be a File instance or a path indicating file to overwrite"
-    end
-    File.open(filepath, 'w') do |f|
-      f.puts content ||= yield
-    end
-  end
-
-  def append content=nil, &block
-    File.append self.path, content, &block
-  end
-
-  def self.append path, content=nil, &block
-    File.open(path, 'a') do |f|
-      f.puts content ||= yield
-    end
-  end 
-
-  def remove_content options=nil, &block
-    opt_str = case options
-    when String
-      options
-    when Hash
-      content = options[:content] || options[:where]
-      raise ArgumentError, "Bad :content value in Hash" if !content || content.strip.empty?
-      content.strip
-    else
-      raise ArgumentError, "non-block argument must be either String or Hash with a :content option" if !block
-    end    
-    content = block ? yield : opt_str
-    File.remove_content_from self.path, :content => content, :with => '', &block
-  end
-  alias_method :remove, :remove_content
-
-  def self.remove_from file_name, content=nil, &block
-    content ||= yield
-    replace_content_from file_name, :content => content, :with => '', &block
-  end
-   
-  def self.remove_content_from file_name, options = {}, &block
-    replace_content_from file_name, options.merge(:with => ''), &block
-  end
-
-  def replace_content options = {}, &block
-    File.replace_content_from self.path, options, &block
-  end
-
-  # replaces content found at replacement_expr with content resulting from yielding block
-  # File.replace_content_from 'myfile.txt', where => /HelloWorld/, with => 'GoodBye'
-  def self.replace_content_from file_name, options = {}, &block
-    replacement_expr = options[:where] || options[:content]
-    new_content = options[:with]
-
-    begin
-      replacement_expr = replacement_expr.to_regexp
-    rescue
-      raise ArgumentError, "Content to be replaced must be specified as either a String or Regexp in a :where or :content option"
-    end
-
-    # get existing file content
-    content = File.read file_name 
-
-    # return nil if no mathing replacement found
-    return nil if !(content =~ replacement_expr)
-
-    new_content ||= yield if block
-
-    raise ArgumentError, "Content to be replaced with must be specified as a :with option or as a block" if !new_content
-  
-    # remove content that matches expr, by replacing with empty
-    mutated_content = content.gsub replacement_expr, new_content
-
-    # write mutated content as new file
-    File.overwrite file_name, mutated_content
-
-    true # signal success!
-  end
-
-  def insert *args, &block
-    File.insert_into self.path, *args, &block
-  end
+  def self.mutate_apis  
+    [:delete, :mutate, :append_content, :insert_content, :overwrite_content, :remove_content, :replace_content]
+  end  
   
-  # insert_into 'my_file.txt', :after => 'Blip', :content => 'Hello
-  # insert_into 'my_file.txt', 'Hello', :after => 'Blip' 
-  # insert_into 'my_file.txt', :after => 'Blip' do 
-  #  'Hello'
-  # end  
-  def self.insert_into file_name, *args, &block
-    options = last_option args
-    content = Insert.content options, *args, &block
-
-    file = File.new(file_name)
-    return nil if !File.exist?(file)
-
-    # already inserted?
-    return nil if content.blank? 
-    return nil if !options[:repeat] && (file.read =~ /#{Regexp.escape(content.to_s)}/)
-
-    place, marker = if options[:before] 
-        [ :before, options[:before] ]
-      elsif options[:before_last]
-        [ :before_last, options[:before_last] ]
-      else
-        [ :after, options[:after] ]
-    end 
-
-    marker = Insert.get_marker marker
-    marker_found = (File.new(file.path).read =~ /#{marker}/)
-    return nil if !marker_found
-    
-    res = Mutate.mutate_file file.path, marker, place do
-       content
+  def self.add_mutate_exts *names
+    names.flat_uniq.each do |api| 
+      ns = "SugarHigh::FileMutate::#{api.to_s.camelize}"
+      begin
+        self.send :include, ns.constantize
+        self.extend "#{ns}::ClassMethods".constantize
+      end
     end
-    res
-  end   
-
-  module EscapedString
-    def escaped?
-      true
-    end
-  end
-
-  module Insert
-   def self.get_marker marker
-     return marker if marker.respond_to?(:escaped?) && marker.escaped?
-     marker = case marker
-     when Regexp
-       marker
-     when String
-       Regexp.escape(marker).extend(EscapedString)
-     end       
-   end
-
-   def self.content options = {}, *args, &block
-     case args.first
-     when String
-       args.first
-     when Hash
-       options[:content] || (yield if block)      
-     else
-       return yield if block
-       raise ArgumentError, "You must supply content to insert, either as a String before the options hash, a :content option or a block" 
-     end     
-   end
-  end
-
-  module Mutate     
-   def self.mutate_file file, marker, place, &block
-     raise ArgumentError, "You must define a replacement marker for a :before, :before_last or :after key" if !marker 
-   
-     if place == :before_last
-       content = File.read(file)
-       content = content.insert_before_last yield, marker
-       File.open(file, 'wb') { |file| file.write(content) }         
-       return
-     end
-
-     marker = Insert.get_marker marker
-
-     marker_found = (File.new(file.path).read =~ /#{marker}/)
-     return nil if !marker_found
-     
-     replace_in_file file, /(#{marker})/mi do |match|
-       place == :after ? "#{match}\n  #{yield}" : "#{yield}\n  #{match}"         
-     end
-     true
-   end  
-
-   def self.replace_in_file(path, regexp, *args, &block)
-     content = File.read(path).gsub(regexp, *args, &block)
-     File.open(path, 'wb') { |file| file.write(content) }
-   end    
   end
+  
 end