jeanny 0.8

data/README

@@ -0,0 +1,8 @@
+Jeanny GEM
+---------------------
+
+Usage:
+
+    require 'jeanny'
+    
+    # blah blah blah

data/lib/jeanny/engine.rb

@@ -0,0 +1,341 @@
+
+module Jeanny
+
+    # Класс который выполнят всю основную работу. 
+    # Парсит и заменяет классы, сохраняет и сравнивает их.    
+    class Engine
+
+        attr_reader :classes
+
+        def initialize
+            @classes = Dictionary.new
+        end
+
+        # Метод ищет имена классов, в переданном ему тексте
+        def analyze file_meat
+            
+            fail TypeError, "передан неверный аргумент (Jeanny::Engine.analyze)" if file_meat.empty?
+
+            # Удаляем все экспрешены и удаляем все что в простых и фигурных скобках
+            file_meat = file_meat.remove_expressions.gsub(/\{.*?\}/m , '{}').gsub(/\(.*?\)/, '()')
+
+            short_words = generate_short_words
+
+            # Находим имена классов
+            file_meat.gsub(/\.([^\.,\{\} :#\[\]\*\n\s\/]+)/) do |match|
+                # Если найденная строка соответствует маске и класс еще не был добавлен — добавляем его
+                @classes[$1] = short_words.shift if match =~ /^\.([a-z]-.+)$/ and not(@classes.include? $1 ) 
+            end
+
+            fail JeannyClassesNotFound, "похоже, что в анализируемом файле нет классов подходящих по условию" if @classes.empty?
+            
+            # @classes.sort!
+            @classes
+
+        end
+        
+        # Метод сравниваеи найденные классы с переданными в аргументе saved_classes
+        # и возвращает имена элементво которых нет в saved_classes
+        def compare_with saved_classes
+
+            return if saved_classes.nil? or saved_classes.empty?
+            
+            saved_classes = Dictionary.new saved_classes
+            
+            # находим новые классы
+            new_classes = ((saved_classes.keys | @classes.keys) - saved_classes.keys)
+
+            @classes = saved_classes
+
+            # генерируем короткие имена и удаляем из них уже используемые
+            short_words = generate_short_words - saved_classes.values
+            new_classes.each do |class_name|
+                @classes[class_name] = short_words.shift
+            end
+            
+            # @classes.sort!
+
+            new_classes
+
+        end
+        
+        # Метод для замены классов
+        def replace data, type
+            
+            fail "Тип блока не понятный" unless [:js, :css, :html, :plain].include? type
+            fail "nil Ololo" if data.nil?
+            
+            code = case type
+                when :js then JSCode
+                when :css then CSSCode
+                when :html then HTMLCode
+                when :plain then PlainCode
+            end
+            
+            @classes.sort!
+            
+            code.new(data).replace @classes
+            
+        end
+
+        private
+
+        # Метод генерирует и возращает массив коротких имен.
+        # По умолчанию генерируется 38471 имя. Если надо больше, добавить — легко        
+        def generate_short_words again = false
+
+            short_words = []
+
+            %w(a aa a0 a_ a- aaa a00 a0a aa0 aa_ a_a aa- a-a a0_ a0- a_0 a-0).each do |name|
+                max = name.length + 1
+                while name.length < max
+                    short_words << name
+                    name = name.next
+                end
+            end
+
+            short_words
+
+        end
+
+    end
+
+    # Класс-попытка реализовать что нибудь похожее на упорядоченный хэш
+    class Dictionary
+
+        include Enumerable
+
+        attr_reader :keys, :values
+
+        def initialize hash = {  }
+            
+            @keys = [ ]
+            @values = [ ]
+
+            hash.each_pair { |key, val| append key, val } if hash.kind_of? Hash
+            hash.each { |item| append item[0], item[1]  } if hash.kind_of? Array
+
+        end
+
+        def [](key)
+            if include? key
+                @values[@keys.index(key)]
+            else
+                nil
+            end
+        end
+
+        def []=(key, value)
+            if include? key
+                @values[@keys.index(key)] = value
+            else
+                append key, value
+            end
+        end
+
+        def append key, value
+            @keys << key
+            @values << value
+        end
+
+        def include? class_name
+            @keys.include? class_name
+        end
+
+        alias :has_key? include?
+
+        def empty?
+            @keys.empty?
+        end
+
+        def each
+            @keys.length.times do |i|
+                yield @keys[i], @values[i]
+            end
+        end
+        
+        def sort!
+            @keys.map { |x| [x, @values[@keys.index(x)]] }.sort_by { |x| x[0].length }.reverse.each_with_index do |x, i|
+                @keys[i] = x[0]
+                @values[i] = x[1]
+            end
+        end
+
+        def select_keys_if &block
+            array = []
+            @keys.length.times do |i|
+                need_append = yield @keys[i], @values[i]
+                array << @keys[i] if need_append
+            end
+            array
+        end
+
+        def length
+            @keys.length
+        end
+
+        def last
+            unless @keys.empty?
+                [@keys.last, @values.last]
+            end
+        end
+
+        def to_s
+            each do |key, val|
+                puts key.ljust(40) + val
+            end
+        end
+        
+        def to_a
+            @keys.map { |x| [x, @values[@keys.index(x)]] }
+        end
+
+    end
+    
+    class Code
+        
+        attr_reader :code
+        
+        def initialize code
+            @code = code
+        end
+        
+        def replace classes
+            
+        end
+        
+    end
+    
+    class JSCode < Code
+        
+        def replace classes
+            
+            # Находим все строки и регулярные выражения
+            @code.gsub(/(("|'|\/)((\\\2|.)*?)\2)/m) do |string|
+
+                string_before, string_after = $3, $3
+
+                # Проходимся по всем классам
+                classes.each do |full_name, short_name|
+
+                    # И заменяем старый класс, на новый
+                    string_after = string_after.gsub(full_name, short_name)
+                end
+
+                string.gsub(string_before, string_after.gsub(/(\\+)("|')/, "\\1\\1\\2"))
+
+            end
+            
+        end
+        
+    end
+    
+    class CSSCode < Code
+        
+        def replace classes
+            
+            # Вырезаем экспрешены
+            expression_list = []
+            @code.replace_expressions! do |expression|
+                # и заменяем в них классы как в js
+                expression_list << JSCode.new(expression).replace(classes)
+                "_ololo_#{expression_list.length}_ololo_"
+            end
+            
+            # Вставляем экспрешены с замененными классами обратно
+            expression_list.each_with_index do |expression, index|
+                @code.gsub! /_ololo_#{index + 1}_ololo_/, expression
+            end
+            
+            @code.gsub!(/\[class\^=(.*?)\]/) do |class_name|
+                if classes.include? $1
+                    class_name.gsub $1, classes[$1]
+                else
+                    class_name
+                end
+            end
+            
+            # Случайная строка
+            unique_string = Time.now.object_id.to_s
+
+            # Проходимся по классам
+            classes.each do |full_name, short_name|
+                
+                # Заменяем старое имя класса на новое, плюс случайное число,
+                # чтобы знать что этот класс мы уже изменяли
+                #   TODO: Может это нахрен не надо?
+                @code = @code.gsub(/\.#{full_name}(?=[^-\w])/, ".#{unique_string}#{short_name}")
+            end
+
+            # После замены имен классов, случайное число уже не нужно,
+            # так что удаляем его, и возвращаем css с замененными значениями
+            @code.gsub(unique_string, '')
+            
+        end
+        
+    end
+    
+    class HTMLCode < Code
+        
+        def replace classes
+            
+            # Заменяем классы во встроенных стилях
+            @code.gsub!(/<style[^>]*?>(.*?)<\s*\/\s*style\s*>/mi) do |style|
+                style.gsub($1, CSSCode.new($1).replace(classes))
+            end
+
+            # Заменяем классы во встроенных скриптах
+            @code.gsub!(/<script[^>]*?>(.*?)<\s*\/\s*script\s*>/mi) do |script|
+                script.gsub($1, JSCode.new($1).replace(classes))
+            end
+            
+            # Находим аттрибуты с именем "class"
+            #   TODO: Надо находить не просто "class=blablabl", а искать
+            #         именно теги с аттрибутом "class"
+            @code.gsub!(/class\s*=\s*('|")(.*?)\1/) do |match|
+            
+                # берем то что в кавычках и разбиваем по пробелам
+                match = $2.split(' ')
+                
+                # проходимся по получившемуся массиву
+                match.map! do |class_name|
+                    
+                    # удаляем проблелы по бокам
+                    class_name = class_name.strip
+                    
+                    # и если в нашем списке замены есть такой класс заменяем на новое значение
+                    if classes.has_key? class_name
+                        classes[class_name]
+                    else
+                        class_name
+                    end
+                    # elsif class_name.eql? 'g-js'
+                    #     class_name
+                    # end
+                    
+                end.delete_if { |class_name| class_name.nil? or class_name.empty? }
+                
+                unless match.empty?
+                    "class=\"#{match.join(' ')}\""
+                else
+                    ''
+                    # puts match
+                    # match
+                end
+                
+            end
+            
+            # Находим тэги с аттрибутами в которых может быть js
+            @code.gsub(/<[^>]*?(onload|onunload|onclick|ondblclick|onmousedown|onmouseup|onmouseover|onmousemove|onmouseout|onfocus|onblur|onkeypress|onkeydown|onkeyup|onsubmit|onreset|onselect|onchange)\s*=\s*("|')((\\\2|.)*?)\2[^>]*?>/mi) do |tag|
+                tag.gsub($3, JSCode.new($3.gsub(/\\-/ , '-')).replace(classes))
+            end
+            
+        end
+        
+    end
+    
+    class PlainCode < Code
+        
+    end
+
+end

data/lib/jeanny/extend.rb

@@ -0,0 +1,179 @@
+class Module
+    
+    # Проверка наличия метода
+    def jeanny_extension(method)
+        if method_defined?(method)
+            $stderr.puts "WARNING: Possible conflict with jeanny extension: #{self}##{method} already exists"
+        else
+            yield
+        end
+    end
+
+end
+
+class File
+
+    jeanny_extension('open_file') do
+        # Метод для чтения файла
+        def self.open_file file
+            # Если файл существует
+            if exists?(expand_path(file))
+                # Открываем, читаем, объединяем, возвращаем содержимое
+                # open(expand_path(file), 'r').readlines.join
+                open(expand_path(file), 'r').read
+            else
+                # Возвращаем пустую строку
+                raise Jeanny::JeannyFileNotFound, "Файл не найден: #{expand_path(file)}"
+            end
+        end
+    end
+
+    jeanny_extension('open_file') do
+        # Метод для сохранения файла
+        def self.save_file file, data, prefix = ''
+            # Если префикс не пустой, добавляем его к имени файла
+            file = "#{dirname(expand_path(file))}/#{prefix}#{basename(file)}" unless prefix.empty?
+            # Открываем файл
+            open(file, 'w') do |file|
+                # Помещаем данные
+                file.puts data
+            end
+        end
+    end
+    
+    jeanny_extension('list') do
+        def self.list path
+            
+            file_list = []
+            file_path = [path].flatten.map do |item|
+                expand_path item
+            end
+
+            file_path.each do |file|
+                
+                list_item = Dir[file]
+                file_list << list_item
+                
+                if block_given?
+                    unless list_item.empty?
+                        list_item.each { |x| yield x, 0 }
+                    else
+                        yield file, 1
+                    end
+                end
+                
+            end
+
+            file_list.flatten
+            
+        end
+    end
+
+end
+
+class String
+
+    jeanny_extension('colorize') do
+        # Функция для подсвечивания строки с помошью ANSI кодов...
+        def colorize(color_code)
+            unless PLATFORM =~ /win32/
+                "#{color_code}#{self}\e[0m"
+            else
+                self
+            end
+        end
+    end
+
+    jeanny_extension('red') do
+        # ... красным
+        def red; colorize("\e[31m"); end
+    end
+
+    jeanny_extension('green') do
+        # ... зеленым цветом
+        def green; colorize("\e[32m"); end
+    end
+
+    jeanny_extension('yellow') do
+        # ... и желтым
+        def yellow; colorize("\e[33m"); end
+    end
+    
+    jeanny_extension('each_expression') do
+        def each_expression &block
+            
+            expression_list = []
+            code, index, length = self.dup, 0, self.length
+            
+            while code[index, length].include? 'expression(' do
+                brake = 0
+                start = code[index, length].index 'expression('
+                block = code[index + start, length]
+                
+                block.length.times do |i|
+                    char = block[i, 1]
+                    if char =~ /\(|\)/
+                        brake = brake + 1 if char.eql? '('
+                        brake = brake - 1 if char.eql? ')'
+                        
+                        if brake.zero?
+                            brake = block[0, i + 1]
+                            break
+                        end
+                    end
+                end
+                
+                index = index + start + brake.length
+                expression_list << brake
+                
+                yield brake if block_given?
+                
+            end
+            
+            expression_list
+
+        end
+    end
+    
+    jeanny_extension 'replace_expressions' do
+        def replace_expressions replace_string = '', &block
+            code = self.dup
+            self.each_expression do |expression|
+                if block_given?
+                    edoc = yield expression
+                    code.gsub!(expression, edoc)
+                else
+                    code.gsub!(expression, replace_string)
+                end
+            end
+
+            code
+        end
+    end
+    
+    jeanny_extension 'replace_expressions!' do
+        def replace_expressions! replace_string = '', &block
+            replace replace_expressions(replace_string, &block)
+        end
+    end
+    
+    jeanny_extension 'remove_expressions' do
+        def remove_expressions
+            replace_expressions ''
+        end
+    end
+    
+    jeanny_extension 'remove_expressions!' do
+        def remove_expressions!
+            replace replace_expressions ''
+        end
+    end
+
+end
+
+module Jeanny
+    
+    %w(FileNotFound CompareFileFormatError ClassesNotFound).each { |error| eval "class Jeanny#{error} < RuntimeError; end" }
+    # %w(CompareFileNotFound SaveError).each { |error| eval "class Jeanny#{error} < SystemCallError; end" }
+    
+end

data/lib/jeanny/sugar.rb

@@ -0,0 +1,234 @@
+require 'singleton'
+
+module Jeanny
+
+    module Sugar
+
+        # Singleton класс который взаимодействует c Jeanny
+        class BridgeToJeanny
+
+            include Singleton
+
+            def initialize
+                # refresh
+            end
+
+            def analyze(path, args = {})
+
+                refresh
+
+                begin
+                    
+                    file_list = File.list path
+                    
+                    fail JeannyFileNotFound, "файлы для анализа не найдены (Jeanny::Engine.analyze)" if file_list.empty?
+                    
+                    file_meat = ''
+                    file_list.each do |file|
+                        file_meat = file_meat + File.open_file(file)
+                    end
+                    
+                    if @engine.analyze file_meat
+                        @canbe[:save], @canbe[:process] = true, true
+                        @canbe[:analyze] = false
+                    end
+                    
+                rescue StandardError => e
+                    $stderr.puts "Ошибка: ".red + e.message
+                    exit 1
+                end
+                
+                @compare_file = (args[:compare_with] or '')
+                
+                # Завершаем метод если сравнивать ни с чем не надо
+                return true if @compare_file.empty?
+                
+                # Если файл не найден, спрашиваем у юзернейма, как быть дальше,
+                # продолжать без сравнения или прекратить работу.
+                unless File.exists? @compare_file
+                    puts "Файл с сохраненными классами не найден. Продолжаем без сравнения.".yellow
+                    return true
+                end
+                
+                saved_classes = []
+                
+                begin
+                    # Открываем файл
+                    raw_file = File.open_file @compare_file
+                    raw_data = raw_file.split "\n"
+        
+                    # ... и читаем структиуру
+                    raw_data.map do |line|
+                        line.split(':').map do |hash|
+                            hash.strip
+                        end
+                    end.each_with_index do |item, index|
+                        if item.length != 2 or item[1].empty?
+                            fail JeannyCompareFileFormatError, "Какая то ерунда с одим (а может больше) классом. Можно пропустить, но хрен его знает что дальше будет…\n" + "файл: #{file}, строка: #{index}\n#{raw_data[index]}".red 
+                        else
+                            saved_classes << [item[0], item[1]]
+                        end
+                    end
+                rescue Exception => e
+                    $stderr.puts e.message
+                    exit 1
+                end
+                
+                # Сравниваем
+                new_classes = @engine.compare_with saved_classes
+                
+                unless new_classes.nil? or new_classes.empty?
+                    puts 'Новые классы: '
+                    new_classes.each do |class_name|
+                        puts "  #{class_name.ljust(40, '.')}#{@engine.classes[class_name].green}"
+                    end
+                end
+
+                true
+                
+            end
+
+            def save file = ''
+                
+                fail RuntimeError, 'на данном этапе нельзя вызывать сохранение классов' unless canbe[:save]
+
+                file = file.empty? ? @compare_file : file
+                
+                File.open(File.expand_path(file), 'w') do |f|
+                    @engine.classes.each do |key, val|
+                        f.puts "#{key}: #{val.rjust(40 - key.length)}"
+                    end                
+                end unless @compare_file.empty? and file.empty?
+
+            end
+
+            def save_to file
+                save file
+            end
+            
+            def group type, args = {}, &block
+   
+                begin
+                    
+                    fail "We can`t process here..." unless @canbe[:process]
+                    fail "Блоки process не должны быть рекурсивными" if @process_block_start
+                    fail "Не передан блок" unless block_given?
+                    
+                    @canbe[:process] = false
+                    @canbe[:replace] = true
+
+                    @process_block_start = true
+                    @process_block = []
+
+                    yield block
+                    
+                    @process_block_start = false
+
+                    @canbe[:replace] = false
+                    @canbe[:process] = true
+                    
+                rescue Exception => e
+                    $stderr.puts "Ошибка: ".red + e.message
+                    exit 1
+                end
+
+                @process_block.each do |replace|
+                    File.list replace[:in] do |file, status|
+                        
+                        # next unless status.zero?
+                        unless status.zero?
+                            puts file.red
+                            next
+                        end
+                        
+                        exclude = false
+                        replace[:ex].each do |exclude_rule|
+                            if exclude_rule.kind_of? Regexp
+                                exclude = file =~ exclude_rule
+                            else
+                                exclude = file.include? exclude_rule
+                            end
+                            break if exclude
+                        end
+                        
+                        # next if exclude
+                        if exclude
+                            puts file.yellow
+                            next
+                        end
+                        
+                        begin
+                            data = File.open_file file
+                            data = @engine.replace data, type
+                                                    
+                            File.save_file file, data
+                            
+                            puts file.green
+                        rescue Exception => e
+                            puts e.message + "\n#{$@}"
+                            exit 1
+                        end
+                        
+                    end
+                end
+                
+            end
+            
+            def replace args = { }
+                
+                fail "We can`t replace here..." unless @canbe[:replace]
+                
+                struct = { :in => [], :ex => [], :prefix => '' }
+
+                struct[:in] = ([args[:in]] | [args[:include]]).flatten.delete_if { |item| item.nil? or item.empty? }
+                struct[:ex] = ([args[:ex]] | [args[:exclude]]).flatten.delete_if { |item| item.nil? or item.empty? }
+
+                struct[:prefix] = args[:prefix] unless args[:prefix].nil?
+
+                @process_block << struct if struct[:in].length > 0
+                
+            end
+
+            private
+
+            attr_reader :analyze_file, :compare_file
+            attr_reader :engine
+            attr_reader :canbe
+
+            attr_reader :process_block_start
+            attr_reader :process_block
+
+            def refresh
+
+                @engine = Engine.new
+                @file_list, @compare_file = '', ''
+                @canbe = { :analyze => true, :save => false, :process => false, :replace => false, :stat => false, :make => false }
+
+                @process_block_start = false
+                @process_block = []
+                
+            end
+
+            def answer question, yes, no
+                
+                action, answers = '', [yes, no].flatten
+                until answers.include? action
+                    print "#{question} "
+                    action = gets.chomp!
+                end
+                    
+                [yes].flatten.include? action
+                
+            end
+
+        end
+
+        # Тут перехватываем все несуществующие методы. 
+        # И те которые используются в DSL отправляем куда надо.
+        def method_missing(method, *args, &block)
+            BridgeToJeanny.instance.send(method, *args, &block) if BridgeToJeanny.instance.respond_to?(method)
+        end
+
+    end
+
+end

data/lib/jeanny.rb

@@ -0,0 +1,20 @@
+
+# 
+#  jeanny.rb
+#  jeanny
+#  
+#  Created by seriously drunken on 2009-09-16.
+#  Copyright 2009 Yandex. All rights reserved.
+# 
+
+$:.unshift File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
+ 
+module Jeanny
+
+    JEANNY_VERSION = '0.8'
+
+end
+
+require 'jeanny/extend'
+require 'jeanny/engine'
+require 'jeanny/sugar'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: jeanny
+version: !ruby/object:Gem::Version 
+  version: "0.8"
+platform: ruby
+authors: 
+- gfranco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-28 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: hello@gfranco.ru
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/jeanny.rb
+- lib/jeanny/engine.rb
+- lib/jeanny/sugar.rb
+- lib/jeanny/extend.rb
+has_rdoc: true
+homepage: http://github.com/gfranco/jeanny
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Lib for obfuscation css class names
+test_files: []
+