bem-on-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fff2737501c065e32082282035389196d6c04ff6
+  data.tar.gz: 21b73fe7f203438ec35752ac6b39e47b51c25b6b
+SHA512:
+  metadata.gz: 6bb146bef1547d553da012d8ae3c1376902e503bd034d4ae6e8071745b0b5ac2fa65125d2ef18fcd0af310e1e195959b58522e9e67ede62e095e58f6baa4b8d3
+  data.tar.gz: b5fcfb9413c4cff5d583f25cccfa7f48e490d55c2f8c99fc7f9cafe1a10b3fc9b6e4ce4572e3791bde0ae3d906e58f6bab4a23bd2331a3bf8aeaca89b9a40991

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* first release with small functionality

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bem-on-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Anton Winogradov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# BEM On Rails
+
+Work with BEM methodology in Rails applications. BEM On Rails is ruby copy from bem-tools. 
+You can read about bem-tools [here](http://bem.info/tools/bem/) and BEM methodology [here](http://bem.info/method/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bem-on-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bem-on-rails
+    
+Then you should run install generator:
+
+    $ rails g bemonrails:install
+
+This generator adds lines to application_controller.rb, application_helper.rb and creates Thor task with templates.
+You should run to watch your new instruments:
+    
+    $ thor -T 
+    
+Also generator creates initializer bem.rb with BEM constant. You can customize everythink!
+
+## Usage
+
+You can create blocks, elements, modificators and groups for blocks. It's awesome! Also you can remove them and watch lists of blocks, block elements, blocks mods and etc. Try thor help for more info.
+
+Default blocks folder structure:
+ - **blocks**
+   - **block_name**
+     - **elements**
+       - **__element_name**
+         - __element_name.html.haml
+         - __element_name.css.sass
+         - __element_name.coffee
+         - __element_name.md
+     - **mods**
+       - **_mod_name**
+         - **_mod_value**
+         - _mod_name.css.sass
+         - _mod_name.coffee
+         - _mod_name.md
+     - block_name.html.haml
+     - block_name.css.sass
+     - block_name.coffee
+     - block_name.md
+   - **group_name**
+     - **block_name**
+
+You can specify all prefixes for blocks, elements and mods in bem.rb initializer.
+
+### Creating
+
+Easy block creating look like:
+
+    $ thor bem:create -b test
+    
+Block with modificator:
+
+    $ thor bem:create -b test -m large
+
+Block with pretty mod with value:
+    
+    $ thor bem:create -b test -m color -v red
+
+Create element:
+
+    $ thor bem:create -b test -e icon
+    
+Element with mod:
+
+    $ thor bem:create -b test -e icon -m large
+    
+Element with pretty mod:
+
+    $ thor bem:create -b test -e icon -m size -v small
+
+Block in special technolody:
+    $ thor bem:create -b test -T sass
+
+Element in special tehcnology creates like block. List of know technologies you can see in bem.rb
+initializer. You can customize it. After block, element or mod creating generator 
+adds to assets main file (application) require string. Ex:
+```sass
+//= require test/elements/__field/__field.css.sass
+```
+You should remember! You are not in any case should not be writing styles and scripts in assets application files.
+Use them like configs, for require only. This involves using Sprockets.
+
+### Rendering
+
+In your view you should write this:
+```ruby
+= b "test", mods: {color: "red"}, content: [{ elem: "icon", elemMods: {size: "small"} }]        
+```
+
+If block in group:
+```ruby
+= b "test", group: "name", mods: {color: "red"}, content: []        
+```
+
+Syntax is look like [bemhtml](http://ru.bem.info/articles/bemhtml-reference/).
+
+### Templates
+
+Now templates exists for haml, sass, coffee and md technologies, but you will create your templates in
+lib/tasks/templates. For example, you can watch haml template:
+```haml
+%div{ bemclass }
+	= bemcontent
+```
+Bemclass and bemcontent is BEM helpers for rendering. 
+
+### You want more BEM?
+
+You can use CSSO instead of YUI compressor for precompile assets. 
+Read [here](http://habrahabr.ru/post/181880/) about it.
+
+If you want it, please watch [here](https://github.com/Vasfed/csso-rails).
+
+## Tomorrow
+
+1. Rendering blocks in block.
+2. Custom tag for block or element.
+3. Add attrs for blocks and elements.
+4. Add custom classes for blocks and elements.
+5. Flags bem and js.
+6. Mix blocks and elements.
+7. Mods with restructure. Now you can't use mods with templates(haml, slim and etc.), but they generates.
+8. Bem exutable. Work with Thor is not convenient.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/helpers/bemonrails/bem_render_helper.rb

@@ -0,0 +1,82 @@
+module Bemonrails
+	module BemRenderHelper
+		
+		include Bemonrails::BemNames
+
+		def render_block(name, builder={})
+	        unless name.blank?
+	            # Generate block paths
+	            path = File.join BEM[:blocks][:dir], build_path_for(:block, builder)
+	            target = File.join path, block(name), block(name)
+	            # Block details
+	            @block_name = name
+	            @block_mods = builder[:mods]
+	            @content = builder[:content]
+	            # Render block in view  
+	            template_exists?(target) ? render(file: target) : bemempty
+	        end
+	    end
+	    alias :b :render_block
+
+	    def render_element(name, builder={})
+	        unless name.blank?
+	            # Generate element paths
+	            path = File.join build_path_for(:element, builder)
+	            target = File.join path, element(name), element(name)
+	            # Element details
+	            @element_name = name
+	            @element_mods = builder[:elemMods]
+	            puts @element_mods
+	            @content = builder[:content]
+	            # Render element in block
+	            template_exists?(target) ? render(file: target) : bemempty
+	        end
+	    end
+	    alias :e :render_element
+
+	    def render_class 
+	        if @block_name && !@element_name 
+	            classes_array = [ block(@block_name) ]
+	            # Install mods
+	            if @block_mods
+	                @block_mods.each do |mod_name, mod_value|
+	                    # Generate mods classes
+	                    if mod_value
+	                        classes_array.push block(@block_name) + mod(mod_name.to_s) + mod(mod_name.to_s, mod_value)
+	                    else
+	                        classes_array.push block(@block_name) + mod(mod_name.to_s)
+	                    end
+
+	                    # TODO: Find mod with restructure .haml, .erb or etc.
+	                end 
+	            end
+	        elsif @element_name 
+	            classes_array = [ block(@block_name) + element(@element_name) ]
+	            # Install mods
+	            if @element_mods
+	                @element_mods.each do |mod_name, mod_value|
+	                    # Generate mods classes
+	                    if mod_value
+	                        classes_array.push block(@block_name) + element(@element_name) + mod(mod_name.to_s) + mod(mod_name.to_s, mod_value)
+	                    else
+	                        classes_array.push block(@block_name) + element(@element_name) + mod(mod_name.to_s)
+	                    end
+	                end 
+	            end
+	        end
+
+	        { class: classes_array.join(" ") }    
+	    end
+	    alias :bemclass :render_class
+
+	    def render_empty
+	        "<div class=#{ bemclass }></div>".html_safe
+	    end
+	    alias :bemempty :render_empty
+
+	    def render_content
+	        render "bemonrails/essences/content"
+	    end
+	    alias :bemcontent :render_content
+	end
+end

data/app/views/bemonrails/essences/_content.html.haml

@@ -0,0 +1,8 @@
+- if @content.kind_of?(Array)
+	- @content.each do |essence|
+		- if essence.kind_of?(Hash) && essence[:elem]
+			= e essence[:elem], { content: essence[:content], mods: essence[:elemMods] }
+		- else
+			= essence
+- else
+	= @content

data/bem-on-rails.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bem-on-rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bem-on-rails"
+  spec.version       = Bemonrails::VERSION
+  spec.authors       = ["Anton Winogradov"]
+  spec.email         = ["winogradovaa@gmail.com"]
+  spec.description   = %q{Gem for work with BEM methodology in Rails applications}
+  spec.summary       = %q{BEM Tools for Rails applications}
+  spec.homepage      = "https://github.com/verybigman/bem-on-rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "thor", "~> 0.16"
+  spec.add_dependency "activesupport"
+end

data/lib/bem-on-rails.rb

@@ -0,0 +1,8 @@
+require "bem-on-rails/version"
+require "bem-on-rails/engine"
+require "bem-on-rails/build/bem_names"
+require "bem-on-rails/generators/install_generator"
+
+module Bemonrails
+	
+end

data/lib/bem-on-rails/build/bem_names.rb

@@ -0,0 +1,110 @@
+module Bemonrails
+	module BemNames
+        # Directories paths.
+        def build_path_for(essence, builder=options)
+            # I think all block can be in groups
+            path = [builder[:group]]
+            case essence
+                when :mod
+                    # This is for mods with value
+                    if builder[:block] && builder[:element] && builder[:value]
+                        path.push(mod_directory(:element), mod)
+                    elsif builder[:block] && builder[:value]
+                        path.push(mod_directory(:block), mod)
+                        # This is for mods without value
+                    elsif builder[:block] && builder[:element]
+                        path.push(mod_directory(:element))
+                    elsif builder[:block]
+                        path.push(mod_directory(:block))
+                    else
+                        raise print_message("Mods must be for block or element.", 'red')
+                    end
+                when :element
+                    path.push(element_directory)
+                when :block
+                    # Yea! Do nothing!
+                else
+                    raise print_message("Unknown params. Try 'thor help bem:create'", 'red')
+            end
+            File.join(path.compact)
+        end
+
+        def generate_names(builder=options)
+            names = {}
+            # Generate names for block, his mods and they values
+            if builder[:block]
+
+                names[:klass] = names[:name] = block
+
+                if builder[:mod]
+                    names[:name] = mod
+                    names[:klass] = block + names[:name]
+                end
+
+                if builder[:value]
+                    names[:name] =  mod(builder[:value])
+                    names[:klass] = block + mod + names[:name]
+                end
+            end
+
+            # Generate names for elements, his mods and they values
+            if builder[:element]
+
+                names[:name] = element
+                names[:klass] += names[:name]
+
+                if builder[:mod]
+                    names[:name] = mod
+                    names[:klass] = block + element + names[:name]
+                end
+
+                if builder[:value]
+                    names[:name] =  mod(builder[:value])
+                    names[:klass] = block + element + mod + names[:name]
+                end
+            end
+
+            names
+        end
+
+        def block(name=options[:block])
+            BEM[:blocks][:prefix] + name
+        end
+
+        def element_directory
+            block_name = @block_name ? @block_name : options[:block]
+            File.join(block(block_name), BEM[:elements][:dir])
+        end
+
+        def element(name=options[:element])
+            BEM[:elements][:prefix] + name
+        end
+
+        def mod_directory(essence)
+            case essence
+                when :block
+                    File.join(block, BEM[:mods][:dir])
+                when :element
+                    File.join(element_directory, element, BEM[:mods][:dir])
+                else
+                    File.join(block, BEM[:mods][:dir])
+            end
+        end
+
+        def mod(name= options[:mod], value=false)
+            if value
+                BEM[:mods][:prefix] + value
+            else
+                BEM[:mods][:prefix] + name
+            end
+        end
+
+        def template_exists?(file)
+            BEM[:techs].each do |tech, extension|
+                if File.exists? file + extension
+                    return true 
+                end
+            end
+        end
+	end
+end

data/lib/bem-on-rails/engine.rb

@@ -0,0 +1,5 @@
+module Bemonrails
+	class Engine < Rails::Engine
+    	isolate_namespace Bemonrails
+  	end
+end

data/lib/bem-on-rails/generators/install_generator.rb

@@ -0,0 +1,40 @@
+require 'rails/generators'
+
+module Bemonrails
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("../templates/", __FILE__)
+
+      def add_render_helpers
+      	app_helper = 'app/helpers/application_helper.rb'
+      	first_string = "module ApplicationHelper"
+      	bem_render_helpers = "\n\t# Add BEM blocks rendering helpers\n\tinclude Bemonrails::BemRenderHelper\n"
+
+      	insert_into_file app_helper, bem_render_helpers, :after => first_string
+      end
+
+      def add_blocks_folder
+      	app_controller = 'app/controllers/application_controller.rb'
+      	protection_str = "protect_from_forgery\n"
+      	bem_block_folder = "\n\t# Add BEM blocks folder to default views scope\n\tbefore_filter { prepend_view_path(BEM[:blocks][:dir]) }\n"
+
+      	insert_into_file app_controller, bem_block_folder, :after => protection_str
+      end
+
+      def add_initializer
+      	template "initializer.tt", File.join(Rails.root, "config", "initializers", "bem.rb")
+      end
+
+      def install_bem_tasks
+      	template "bem.tt", File.join(Rails.root, "lib", "tasks", "bem.thor") 
+      end
+
+      def add_blocks_templates
+      	%w(haml.tt coffee.tt md.tt sass.tt).each do |t|
+      		template t, File.join(Rails.root, "lib", "tasks", "templates", t) 
+      	end
+      end
+
+    end
+  end
+end

data/lib/bem-on-rails/generators/templates/bem.tt

@@ -0,0 +1,291 @@
+require File.expand_path('config/environment.rb')
+
+class Bem < Thor
+    include Thor::Actions
+    include Bemonrails::BemNames
+
+    # Templates for techs
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc 'create', 'Create block, element or mod'
+    method_option :block, type: :string, aliases: "-b", desc: "Create block in default techs."
+    method_option :element, type: :string, aliases: "-e", desc: "Create element in default techs. Use with block param."
+    method_option :mod, type: :string, aliases: "-m", desc: "Create modificator for block or element."
+    method_option :value, type: :string, aliases: "-v", desc: "Value for modificator."
+    method_option :tech, type: :string, aliases: "-T", desc: "Create essence in spec tech."
+    method_option :group, type: :string, aliases: "-G", desc: "Create essence in group. Work for blocks only!"
+    method_option :force, type: :boolean, desc: "Force existing block, element or mod files."
+    def create
+        # Minimum one param is required for creating
+        if options[:block] && !options[:element] && !options[:mod]
+            path = build_path_for(:block)
+            destination = File.join(path, block)
+            unless essence_exist?(destination)
+                create_essence(BEM[:blocks], path)
+                update_assets(block, path)
+            end
+        elsif options[:element] && !options[:mod]
+            path = build_path_for(:element)
+            destination = File.join(path, element)
+            unless essence_exist?(destination)
+                create_essence(BEM[:elements], path)
+                update_assets(element, path)
+            end
+        elsif options[:mod]
+            path = build_path_for(:mod)
+            essence = options[:value] ? options[:value] : options[:mod]
+            destination = File.join(path, mod(essence))
+            unless essence_exist?(destination)
+                create_essence(BEM[:mods], path)
+                update_assets(mod(essence), path)
+            end
+        else
+            raise print_message("You should set params. Try 'thor help bem:create' for more information", 'red')
+        end
+    end
+
+
+
+    desc 'remove', 'Remove block, element or mod'
+    method_option :block, type: :string, aliases: "-b", desc: "Remove block in default techs."
+    method_option :element, type: :string, aliases: "-e", desc: "Remove element in default techs. Use with block param."
+    method_option :mod, type: :string, aliases: "-m", desc: "Remove modificator for block or element."
+    method_option :value, type: :string, aliases: "-v", desc: "Value for modificator."
+    method_option :tech, type: :string, aliases: "-T", desc: "Remove essence in spec tech."
+    method_option :group, type: :string, aliases: "-G", desc: "Remove essence in group. Work for blocks only!"
+    def remove
+        # Minimum one param is required for deleting
+        if options[:block] && !options[:element] && !options[:mod]
+            path = build_path_for(:block)
+            destination = File.join(path, block)
+            if essence_exist?(destination, false)
+                remove_essence(BEM[:blocks], path)
+                cut_assets(block, path)
+            end
+        elsif options[:element] && !options[:mod]
+            path = build_path_for(:element)
+            destination = File.join(path, element)
+            if essence_exist?(destination, false)
+                remove_essence(BEM[:elements], path)
+                cut_assets(element, path)
+            end
+        elsif options[:mod]
+            path = build_path_for(:mod)
+            essence = options[:value] ? options[:value] : options[:mod]
+            destination = File.join(path, mod(essence))
+            if essence_exist?(destination, false)
+                remove_essence(BEM[:mods], path)
+                cut_assets(mod(essence), path)
+            end
+        else
+            raise print_message("You should set params. Try 'thor help bem:remove' for more information", 'red')
+        end
+    end
+
+
+
+    desc 'usage', 'Essence usage information'
+    method_option :block, type: :string, aliases: "-b", desc: "Block usage."
+    method_option :element, type: :string, aliases: "-e", desc: "Element usage"
+    method_option :mod, type: :string, aliases: "-m", desc: "Mod usage."
+    method_option :value, type: :string, aliases: "-v", desc: "Mod value usage."
+    method_option :group, type: :string, aliases: "-G", desc: "Search essence in group."
+    def usage
+        if options[:block] && !options[:element] && !options[:mod]
+            path = build_path_for(:block)
+            search_usage_information(block, path)
+        elsif options[:element] && !options[:mod]
+            path = build_path_for(:element)
+            search_usage_information(element, path)
+        elsif options[:mod]
+            path = build_path_for(:mod)
+            essence = options[:value] ? options[:value] : options[:mod]
+            search_usage_information(mod(essence), path)
+        else
+            raise print_message("You should set params. Try 'thor help bem:usage' for more information", 'red')
+        end
+    end
+
+
+
+    desc 'list', 'See list of group, block elements, mods and etc.'
+    method_option :block, type: :string, aliases: "-b", desc: "All block elements, mods and mods values"
+    method_option :element, type: :string, aliases: "-e", desc: "All element mods and mods values"
+    method_option :mod, type: :string, aliases: "-m", desc: "All mod values."
+    method_option :group, type: :string, aliases: "-G", desc: "All blocks in group."
+    def list
+        if options[:block] && !options[:element] && !options[:mod]
+            # Print all block elements and mods
+            path = build_path_for(:block)
+            print_elements_list(block, path)
+            print_mods_list(block, path)
+        elsif options[:element] && !options[:mod]
+            # Print all element mods
+            path = build_path_for(:element)
+            print_mods_list(element, path)
+        elsif options[:mod]
+            # Print all mod values
+            path = build_path_for(:mod)
+            print_values_list(element, path)
+        else
+            # Print all blocks
+            path = build_path_for(:block)
+            print_blocks_list(path)
+        end
+    end
+
+
+
+    protected
+
+        def essence_exist?(essence_dir, creating=true)
+            if File.directory?(File.join(BEM[:blocks][:path], essence_dir))
+                puts print_message("Essence with this name is already exists. Try 'thor help bem:list' or 'thor help bem:usage ", 'red') if creating
+                true
+            end
+        end
+
+        def create_essence(essence_options, path)
+
+            names = generate_names
+
+            @css_class = '.' + names[:klass]
+
+            # [!] Templates exist only for wiki, haml, sass and coffee.
+            # If you need more templates. Please create them into templates
+            # directory. Watch existing templates for example.
+            # What is .tt? It is custom extension for finding templates in other files.
+            if options[:tech] # Maybe recive from command line
+                template "#{options[:tech]}.tt", File.join(essence_options[:path], path, names[:name], names[:name] + BEM[:techs][options[:tech].to_sym])
+            else
+                # You can customize this list of defaults. See on top of file.
+                BEM[:default].each do |tech, extension|
+                    template "#{tech}.tt", File.join(essence_options[:path], path, names[:name], names[:name] + extension)
+                end
+            end
+        end
+
+        def remove_essence(essence_options, path)
+
+            names = generate_names
+
+            if options[:tech]
+                destination = File.join(essence_options[:path], path, names[:name], names[:name] + BEM[:techs][options[:tech].to_sym])
+                FileUtils.rm(destination)
+            else
+                destination = File.join(essence_options[:path], path, names[:name])
+                FileUtils.rm_rf(destination)
+            end
+
+            puts "\e[0;31m      remove\e[0m  " + destination.to_s.gsub(Rails.root.to_s + "/", "")
+        end
+
+        def update_assets(name, path)
+            BEM[:assets].each do |type, tech|
+                asset = File.join(Rails.root, "app", "assets", type.to_s, "application" + tech[:ext])
+                destination = [path, name, name + tech[:ext]].reject(&:empty?)
+                line = "#{tech[:import]} #{File.join(destination)}#{tech[:postfix]}"
+                File.open(asset, "a") do |f|
+                    f.write("\n" + line)
+                end
+            end
+        end
+
+        def cut_assets(name, path)
+            BEM[:assets].each do |type, tech|
+                asset = File.join(Rails.root, "app", "assets", type.to_s, "application" + tech[:ext])
+                destination = [path, name, name + tech[:ext]].reject(&:empty?)
+                line = "#{tech[:import]} #{File.join(destination)}#{tech[:postfix]}"
+
+                # Open temporary file
+                tmp = Tempfile.new("temp")
+                # Write good lines to temporary file.
+                open(asset, 'r').each do |l|
+                    tmp << l unless l.chomp == line || l.empty?
+                end
+                # Close tmp, or troubles ahead.
+                tmp.close
+                # Temp to original.
+                FileUtils.mv(tmp.path, asset)
+            end
+        end
+
+        def search_usage_information(essence, path)
+            BEM[:usage].each do |tech, extension|
+                file_destination = File.join(BEM[:blocks][:path] + path, essence, essence + extension)
+                if File.exist?(file_destination)
+                    puts tech.to_s + ": " + file_destination
+                    puts "BEM[:usage]:\t"
+                    File.readlines(file_destination).each do |line|
+                        puts line
+                    end
+                end
+            end
+        end
+
+        def print_blocks_list(essence="", path)
+            directory_destination = File.join(BEM[:blocks][:path] + path, essence)
+            puts directory_destination
+            print_message("BEM[:blocks]:\t", 'green')
+            Dir[directory_destination + "/*"].each do |name|
+                # Show only essences. No files. No groups.
+                # Essences have't ext.
+                # Get dir name.
+                name = name.split('/')[-1]
+                if name.split('.').size == 1
+                    puts " - " + name
+                end
+            end
+        end
+
+        def print_elements_list(essence="", path)
+            directory_destination = File.join(BEM[:blocks][:path] + path, essence, BEM[:elements][:dir])
+            print_message("BEM[:elements]:\t", 'purple')
+            Dir[directory_destination + "/*"].each do |name|
+                # Get dir name.
+                name = name.split('/')[-1]
+                puts " - " + name.split(BEM[:elements][:prefix])[1]
+            end
+        end
+
+        def print_mods_list(essence="", path)
+            directory_destination = File.join(BEM[:blocks][:path] + path, essence, BEM[:mods][:dir])
+            print_message("BEM[:mods]:\t", 'cyan')
+            Dir[directory_destination + "/*"].each do |name|
+                # Get dir name.
+                name = name.split('/')[-1]
+                puts " - " + name.split(BEM[:mods][:prefix])[1]
+            end
+        end
+
+        def print_values_list(essence="", path)
+            directory_destination = File.join(BEM[:blocks][:path] + path, essence)
+            print_message("VALUES:\t", 'yellow')
+            Dir[directory_destination +  "/*"].each do |name|
+                # Get dir name.
+                name = name.split('/')[-1]
+                puts " - " + name.split(BEM[:mods][:prefix])[1]
+            end
+        end
+
+        def print_message(message, color)
+            check_argument_data_type(message, String)
+            check_argument_data_type(color, String)
+
+            color = case color
+                        when 'green' then "\e[0;32m"
+                        when 'red' then "\e[0;31m"
+                        when 'blue' then "\e[0;34m"
+                        when 'cyan' then "\e[0;36m"
+                        when 'purple' then "\e[0;35m"
+                        when 'yellow' then "\e[1;33m"
+                        else ''
+                    end
+
+            puts "#{color + message} \e[0m"
+        end
+
+        def check_argument_data_type(argument, type)
+            raise print_message("#{argument} must be a #{type.to_s}", 'red') unless argument.kind_of? type
+        end
+end

data/lib/bem-on-rails/generators/templates/coffee.tt

@@ -0,0 +1,4 @@
+# CoffeeScript
+# Example:
+# $('<%= @css_class %>').click ->
+#   $('body').hide()

data/lib/bem-on-rails/generators/templates/haml.tt

@@ -0,0 +1,2 @@
+%div{ bemclass }
+	= bemcontent

data/lib/bem-on-rails/generators/templates/initializer.tt

@@ -0,0 +1,101 @@
+BEM = {}
+
+# List of known techs.
+BEM[:techs] = {
+    haml: ".html.haml",
+    slim: ".html.slim",
+    erb: "html.erb",
+    jade: ".jade",
+    sass: ".css.sass",
+    scss: ".css.scss",
+    less: ".css.less",
+    styl: ".css.styl",
+    css: ".css",
+    coffee: ".coffee",
+    js: ".js",
+    md: ".md",
+    wiki: ".wiki"
+}
+
+# List of default techs, generating if -T is empty.
+BEM[:default] = {
+    haml: BEM[:techs][:haml],
+    sass: BEM[:techs][:sass],
+    coffee: BEM[:techs][:coffee],
+    md: BEM[:techs][:md]
+}
+
+# Usage files variants.
+BEM[:usage] = {
+    md: BEM[:techs][:md],
+    wiki: BEM[:techs][:wiki]
+}
+
+# Default directories, try to customize.
+# Blocks directory in root of rails app.
+BEM[:blocks] = {
+    dir: "blocks",
+    path: Rails.root.join("blocks"),
+    prefix: "",
+    postfix: ""
+}
+
+# Elements directory in every block directory.
+# Write 'dir: ""' for creating elements in root of block.
+BEM[:elements] = {
+    dir: "elements",
+    path: BEM[:blocks][:path], # This is individualy for every block
+    prefix: "__",
+    postfix: ""
+}
+
+# Mods directory in every block directory.
+# Write 'dir: ""' for creating mods in root of block.
+BEM[:mods] = {
+    dir: "mods",
+    path: BEM[:blocks][:path], # This is individualy for every block or element
+    prefix: "_",
+    postfix: ""
+}
+
+# [!] If you work with sass and you want to create blocks, elements and mods in sass,
+# you should convert 'application.css' to 'application.css.sass'. Because, when
+# blocks, elements or mods is created, technology files will be included to application
+# files. This also applies to scss, styl, less and coffee. Customize this for use your
+# favorite techs. Asset type may have postfix and it's optional.
+# Example:
+#
+# assets = {
+#   stylesheets:
+#       {
+#           ext: BEM[:techs][:scss],
+#           import: '//= require',
+#           posfix: ';'
+#       }
+# }
+
+BEM[:assets] = {
+    stylesheets:
+        {
+            ext: BEM[:techs][:sass],
+            import: '//= require'
+        },
+    javascripts:
+        {
+            ext: BEM[:techs][:js],
+            import: '//= require'
+        }
+}
+
+# You must use application files in
+# assets as a configs, don't write code in them.
+# This is need to sprokets includes.
+Rails.application.config.assets.paths << BEM[:blocks][:dir]
+
+# Use CSSO instead of YUI.
+# Watch here https://github.com/Vasfed/csso-rails
+# Add to gem file:
+# gem 'csso-rails'
+
+# And uncomment this
+# Rails.config.assets.css_compressor = :csso

data/lib/bem-on-rails/generators/templates/sass.tt

@@ -0,0 +1 @@
+<%= @css_class %>

data/lib/bem-on-rails/version.rb

@@ -0,0 +1,3 @@
+module Bemonrails
+	VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: bem-on-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anton Winogradov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem for work with BEM methodology in Rails applications
+email:
+- winogradovaa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- app/helpers/bemonrails/bem_render_helper.rb
+- app/views/bemonrails/essences/_content.html.haml
+- bem-on-rails.gemspec
+- lib/bem-on-rails.rb
+- lib/bem-on-rails/build/bem_names.rb
+- lib/bem-on-rails/engine.rb
+- lib/bem-on-rails/generators/install_generator.rb
+- lib/bem-on-rails/generators/templates/bem.tt
+- lib/bem-on-rails/generators/templates/coffee.tt
+- lib/bem-on-rails/generators/templates/haml.tt
+- lib/bem-on-rails/generators/templates/initializer.tt
+- lib/bem-on-rails/generators/templates/md.tt
+- lib/bem-on-rails/generators/templates/sass.tt
+- lib/bem-on-rails/version.rb
+homepage: https://github.com/verybigman/bem-on-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: BEM Tools for Rails applications
+test_files: []