bem-on-rails 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6995691b232fdf4379ed487cfd5e617e160a3eb3
-  data.tar.gz: b4c0d05d26cd0985fc2cc99d4e586a5e68a8f2aa
+  metadata.gz: 0f66d7fdd5df85cb015296b66ec95448402ff0f1
+  data.tar.gz: 1f2395fd3b5d51a031e66a4c0c7c2cbaf7462b91
 SHA512:
-  metadata.gz: b29fdc8916e7cf7ef078084ff5d399a3633842c3df8978285a5d6e1253ec25dad707fcf3cc53823f64e7fdbc65a1595a2855cd9f7ce5c4960f4291d3e63a6129
-  data.tar.gz: ee7691bd4bcbc1709c361896e74d6355e32ad9e1d540819c9d78ce73c6c65c28fc91776731a0a56ca982c213c05dcd88afe337e9c2636511bbf0cd03593ac3f3
+  metadata.gz: 69bafa47042962c169f8f2ac8c53bb4652736ff6bb7c113a2921575931a37bad1dfc331a3129954f6f924194a42d42cc07ecee3fe3ee0c8c218d344002d80df0
+  data.tar.gz: 08f97d4c7e17769d5a5423356b63c80ac6f8833c7f40f0c5c96bb0bef7885faf705bc62b7a373ea7abadef452622d87adafc897535a371b0680c8863ecaac022

data/.rvmrc

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 2.0.0" > .rvmrc
+environment_id="ruby-2.0.0-p247@bem-on-rails"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.22.3 (stable)" # 1.10.1 seems like a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | __rvm_awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  for __hook in "${rvm_path:-$HOME/.rvm}/hooks/after_use"*
+  do
+    if [[ -f "${__hook}" && -x "${__hook}" && -s "${__hook}" ]]
+    then \. "${__hook}" || true
+    fi
+  done
+  unset __hook
+  if (( ${rvm_use_flag:=1} >= 1 )) # display automatically
+  then
+    if [[ $- == *i* ]] # check for interactive shells
+    then printf "%b" "Using: \E[32m$GEM_HOME\E[0m
+" # show the user the ruby and gemset they are using in green
+    else printf "%b" "Using: $GEM_HOME
+" # don't use colors in non-interactive shells
+    fi
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS="" \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS="" \grep -vE '^Using|Your bundle is complete'
+# fi

data/CHANGELOG.md

@@ -14,3 +14,9 @@
 * extract helpers includes to railtie
 * extract views folder includes to railtie
 * update install generator
+
+## v0.0.4
+
+* more refactoring
+* add mix functionality
+* walking to clean code

data/README.md

@@ -27,13 +27,12 @@ This generator creates Thor task with templates. You should run to watch your ne
     
     $ thor -T 
     
-Also generator creates initializer bem.rb with BEM constant. You should restart server after install. 
-You can customize everythink!
+You should restart server after install. 
+You can customize everythink in initializers/bem.rb!
 
 ## 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.
+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**
@@ -136,15 +135,16 @@ Syntax is look like [bemhtml](http://ru.bem.info/articles/bemhtml-reference/).
 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
-- haml_tag bemtag, bemattrs
-	= bemcontent
+- haml_tag this[:tag], this[:attrs]
+	= content
 ```
 Or Slim template:
 ```slim
-* bemtag, bemattrs
-	= bemcontent
+* this[:tag], this[:attrs]
+	= content
 ```
-Bemclass and bemcontent is BEM helpers for rendering. 
+This and content is BEM helpers for rendering. For access to default essence propeties use 'this' method.
+For access to custom essence properties use 'ctx' method.
 
 ### You want more BEM?
 
@@ -158,10 +158,11 @@ If you want it, please watch [here](https://github.com/Vasfed/csso-rails).
 ## Tomorrow
 
 0. Incapsulate helpers methods and isolate them from project helpers.
-1. Flags bem and js.
-2. Mix blocks and elements.
-3. Mods with restructure. Now you can't use mods with templates(haml, slim and etc.), but they generates.
-4. Bem exutable. Work with Thor is not convenient.
+1. Flag bem.
+2. i-bem.js for html.
+3. deps.js
+4. Mods with restructure. Now you can't use mods with templates(haml, slim and etc.), but they generates.
+5. Bem exutable. Work with Thor is not convenient.
 
 ## Contributing
 

data/app/helpers/bemonrails/bem_render_helper.rb

@@ -2,106 +2,102 @@ module Bemonrails
   module BemRenderHelper
     include Bemonrails::BemNames
 
-    def bemtag
-      @custom_tag ||= "div"
-    end
-
-    def render_block(name, builder={})
+    def b(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]
-        @custom_attrs = builder[:attrs]
-        @custom_class = builder[:cls]
-        @custom_tag = builder[:tag]
-        @content = builder[:content]
-        # Render block in view  
-        template_exists?(target) ? render(file: target) : bemempty
+        get_bemattributes_from builder
+        set_names :block, name
+        update_bemattributes
+        template_exists?(target) ? render(file: target) : empty
       end
     end
-    alias :b :render_block
 
-    def render_element(name, builder={})
+    def e(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]
-        @custom_attrs = builder[:attrs]
-        @custom_class = builder[:cls]
-        @custom_tag = builder[:tag]
-        puts @element_mods
-        @content = builder[:content]
-        # Render element in block
-        template_exists?(target) ? render(file: target) : bemempty
+        get_bemattributes_from builder
+        set_names :element, name
+        update_bemattributes
+        template_exists?(target) ? render(file: target) : empty
       end
     end
-    alias :e :render_element
 
-    def render_bemattributes
-      if @block_name && !@element_name 
-        classes_array = [ block(@block_name) ]
-        # Install mods
-        if @block_mods
-          @block_mods.each do |mod|
-            # Generate mods classes
-            if mod.kind_of? Hash
-              mod.each do |mod_name, mod_value|
-                classes_array.push block(@block_name) + mod(mod_name.to_s) + mod(mod_name.to_s, mod_value)
-              end
-            else
-              classes_array.push block(@block_name) + mod(mod.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 
+    def get_bemattributes_from(builder={})
+      @this = {}
+      BEM[:attrs].each do |mod|
+        if builder[mod]
+          @this[mod] = builder[mod] 
+          builder = builder.except(mod)
         end
       end
+      @this[:ctx] = builder
+      # Set defult attrs, if user not set them.
+      @this[:tag] ||= :div
+      @this[:attrs] ||= {}
+    end
 
-      bemclass = classes_array.join(" ")
+    def set_names(essence, name)
+      case essence
+      when :block
+        @this[:block] = @block_buffer = name
+      when :element
+        @this[:block] = @block_buffer
+        @this[:elem] = name
+      end
+    end
 
-      # If custom class exist
-      if @custom_class
-        bemclass = [bemclass, @custom_class].join(" ")
+    def update_bemattributes
+      classes_array = []
+      generate_class(@this, classes_array)
+      install_mix(@this[:mix], classes_array)
+      @this[:attrs].merge!({class: [classes_array, @this[:cls]].join(" ").strip!})
+    end
+
+    def install_mods(mods, classes_array, bl, el=false)
+      if mods
+        el = el ? element(el) : ""
+        mods.each do |mod|
+          if mod.kind_of? Hash
+            mod.each do |mod_name, mod_value|
+              classes_array.push(block(bl) + el + mod(mod_name.to_s) + mod(mod_name.to_s, mod_value))
+            end
+          else
+            classes_array.push(block(bl) + el + mod(mod.to_s))
+          end  
+        end 
       end
+    end
 
-      # String for tag attributes
-      bemattributes = { class: bemclass }
+    def install_mix(mixs, classes_array)
+      if mixs
+        mixs.each do |mix|
+          generate_class(mix, classes_array) 
+        end   
+      end
+    end
 
-      # If custom attributes exist
-      if @custom_attrs
-        bemattributes.merge! @custom_attrs
+    def generate_class(essence, classes_array)
+      if essence[:block] && !essence[:elem]
+        classes_array.push(block(essence[:block]))
+        install_mods(essence[:mods], classes_array, essence[:block])
+      elsif essence[:elem] 
+        classes_array.push(block(essence[:block]) + element(essence[:elem]))
+        install_mods(essence[:elemMods], classes_array, essence[:block], essence[:elem])
       end
+    end
 
-      bemattributes
+    def empty
+      "<div class=#{ @this[:attrs][:class] }></div>".html_safe
     end
-    alias :bemattrs :render_bemattributes
 
-    def render_empty
-      "<div class=#{ bemclass }></div>".html_safe
+    def this
+      @this
     end
-    alias :bemempty :render_empty
 
-    def render_content
+    def content
       render "bemonrails/essences/content"
     end
-    alias :bemcontent :render_content
   end
 end

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

@@ -1,20 +1,12 @@
-- if @content.kind_of?(Array)
-  - @content.each do |essence|
+- if @this[:content].kind_of?(Array)
+  - @this[:content].each do |essence|
     - if essence.kind_of?(Hash) && essence[:elem]
-      = e essence[:elem], { content: essence[:content],
-                            mods: essence[:elemMods],
-                            attrs: essence[:attrs],
-                            cls: essence[:cls],
-                            tag: essence[:tag] }
+      = e essence[:elem], essence
 
     - elsif essence.kind_of?(Hash) && essence[:block]
-      = b essence[:block], { content: essence[:content],
-                             mods: essence[:mods],
-                             attrs: essence[:attrs],
-                             cls: essence[:cls],
-                             tag: essence[:tag] }
+      = b essence[:block], essence
 
     - else
       = essence
 - else
-  = @content
+  = @this[:content]

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

@@ -86,7 +86,7 @@ module Bemonrails
     end
 
     def element_directory
-      block_name = @block_name ? @block_name : options[:block]
+      block_name = @this[:block] ? @this[:block] : options[:block]
       File.join(block(block_name), BEM[:elements][:dir])
     end
 

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

@@ -14,8 +14,8 @@ module Bemonrails
       end
 
       def add_blocks_templates
-        %w(slim.tt haml.tt coffee.tt md.tt sass.tt).each do |t|
-          template "techs/#{t}", File.join(Rails.root, "lib", "tasks", "templates", t)
+        %w(haml.tt coffee.tt md.tt sass.tt).each do |t|
+          copy_file "techs/#{t}", File.join(Rails.root, "lib", "tasks", "templates", t)
         end
       end
 

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

@@ -1,101 +1,44 @@
-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"
-}
+# Update list of known techs.
+# BEM[:techs][:my_tech] = ".ext"
 
 # List of default techs, generating if -T is empty.
-BEM[:default] = {
-  slim: BEM[:techs][:slim],
-  sass: BEM[:techs][:sass],
-  coffee: BEM[:techs][:coffee],
-  md: BEM[:techs][:md]
-}
+# BEM[:default] << :my_tech
 
-# Usage files variants.
-BEM[:usage] = {
-  md: BEM[:techs][:md],
-  wiki: BEM[:techs][:wiki]
-}
+# Usage files variants. File for Readme about essences.
+# BEM[:usage] << :my_tech
 
 # 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.
+# BEM[:blocks] = {
+#   dir: "blocks",
+#   path: Rails.root.join("blocks"),
+#   prefix: "",
+#   postfix: ""
+# }
+# Elements and mods directory in every block. Configure it's like blocks.
 # 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: ""
-}
+# BEM[:elements] = {
+#   ...
+# }
+# BEM[:mods] = {
+#   ...
+# }
 
 # [!] 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
+# blocks, elements or mods creates, 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][:scss],
+#      import: '//= require',
+#      posfix: ';'
+#   },
+#   javascripts: {
+#      ...  
+#   }
 # }
 
-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
+# [!] Use CSSO instead of YUI.
+# Watch here https://github.com/Vasfed/csso-rails

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

@@ -1,2 +1,2 @@
-- haml_tag bemtag, bemattrs
-  = bemcontent
+- haml_tag this[:tag], this[:attrs] do
+    = content

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

@@ -1,2 +1,2 @@
-* bemtag, bemattrs
-  = bemcontent
+* this[:tag], this[:attrs]
+  = content

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

@@ -1,187 +1,187 @@
 require File.expand_path('config/environment.rb')
 
 class Bem < Thor
-  include Thor::Actions
-  include Bemonrails::BemNames
-  include Bemonrails::ConsoleMessages
-
-  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
-    path = build_path_for(essence)
-    manipulate_essence(:create, essence, path)
-  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
-    path = build_path_for(essence)
-    manipulate_essence(:remove, essence, path)
-  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
-    path = build_path_for(essence)
-    manipulate_essence(:usage, essence, path)
-  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
-    path = essence ? build_path_for(essence) : build_path_for(:block)
-    case essence
-    when :block
-      print_elements_list(block, path)
-      print_mods_list(block, path)
-    when :element
-      print_mods_list(element, path)
-    when :mod
-      print_values_list(element, path)
-    else
-      print_blocks_list(path)
-    end
-  end
-
-  protected
-
-  def essence_exist?(essence_dir)
-    File.directory?(File.join(BEM[:blocks][:path], essence_dir))
-  end
-
-  def create_essence(essence_options, path)
-    names = generate_names
-    @css_class = '.' + names[:klass]
-    # 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
-      create_defaults(essence_options, path, names)
-    end
-  end
-
-  def create_defaults(essence_options, path, names)
-    BEM[:default].each do |tech, extension|
-      template "#{tech}.tt", File.join(essence_options[:path], path, names[:name], names[:name] + extension)
-    end
-  end
-
-  def remove_essence(essence_options, path)
-    names = generate_names
-    destination = File.join(essence_options[:path], path, names[:name])
-    destination = File.join(destination, names[:name] + BEM[:techs][options[:tech].to_sym]) if options[:tech]
-    FileUtils.rm_rf(destination)
-
-    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") { |f| f.write("\n" + line) }
-    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]}"
-
-      tmp = Tempfile.new("temp")
-      open(asset, 'r').each do |l|
-        tmp << l unless l.chomp == line || l.empty?
-      end
-      tmp.close
-
-      FileUtils.mv(tmp.path, asset)
-    end
-  end
-
-  def search_usage_information(essence, path)
-    BEM[:usage].each do |tech, extension|
-      file_destination = File.join(path_to_block(path), essence, essence + extension)
-      read_usage(file_destination) if File.exist?(file_destination)
-    end
-  end
-
-  def read_usage(target)
-    puts "#{ tech }: #{ target }"
-    puts "BEM[:usage]:\t"
-    File.readlines(target) { |line| puts line }
-  end
-
-  def print_blocks_list(essence="", path)
-    directory_destination = File.join(path_to_block(path), essence)
-    parse_directory(:blocks, 'green', directory_destination)
-  end
-
-  def print_elements_list(ess_name="", path)
-    directory_destination = File.join(path_to_block(path), ess_name, BEM[:elements][:dir])
-    parse_directory(:elements, 'purple', directory_destination)
-  end
-
-  def print_mods_list(ess_name="", path)
-    directory_destination = File.join(path_to_block(path), ess_name, BEM[:mods][:dir])
-    parse_directory(:mods, 'cyan', directory_destination)
-  end
-
-  def print_values_list(ess_name="", path)
-    directory_destination = File.join(path_to_block(path), ess_name)
-    parse_directory(:mods, 'yellow', directory_destination)
-  end
-
-  def parse_directory(directory, essence, color)
-    print_message("BEM[#{ essence }]:\t", color)
-    Dir[directory + "/*"].each do |name|
-      name = name.split('/')[-1]
-      puts " - " + name.split(BEM[essence][:prefix])[1]
-    end
-  end
-
-  def manipulate_essence(action, ess, path)
-    ess_name = send(ess)
-    ess_name = mod(options[:value] ? options[:value] : options[:mod]) if ess == :mod
-    destination = File.join(path, ess_name)
-
-    case action
-      when :create
-        create_essence(BEM[ess.to_s.pluralize.to_sym], path)
-        update_assets(ess_name, path)
-      when :remove
-        remove_essence(BEM[ess.to_s.pluralize.to_sym], path)
-        cut_assets(ess_name, path)
-      when :usage
-        search_usage_information(ess_name, path) if essence_exist?(destination)
-      else raise print_message("You should set params. Try 'thor help bem:#{action}' for more information", 'red')
-    end
-  end
-
-end
+    include Thor::Actions
+    include Bemonrails::BemNames
+    include Bemonrails::ConsoleMessages
+
+    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: "-l", desc: "Create essence in group. Work for blocks only!"
+    method_option :force, type: :boolean, desc: "Force existing block, element or mod files."
+    def create
+        path = build_path_for(essence)
+        manipulate_essence(:create, essence, path)
+    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: "-l", desc: "Remove essence in group. Work for blocks only!"
+    def remove
+        path = build_path_for(essence)
+        manipulate_essence(:remove, essence, path)
+    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: "-l", desc: "Search essence in group."
+    def usage
+        path = build_path_for(essence)
+        manipulate_essence(:usage, essence, path)
+    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: "-l", desc: "All blocks in group."
+    def list
+        path = essence ? build_path_for(essence) : build_path_for(:block)
+        case essence
+            when :block
+                print_elements_list(block, path)
+                print_mods_list(block, path)
+            when :element
+                print_mods_list(element, path)
+            when :mod
+                print_values_list(element, path)
+            else
+                print_blocks_list(path)
+        end
+    end
+
+    protected
+
+    def essence_exist?(essence_dir)
+        File.directory?(File.join(BEM[:blocks][:path], essence_dir))
+    end
+
+    def create_essence(essence_options, path)
+        names = generate_names
+        @css_class = '.' + names[:klass]
+        # 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
+            create_defaults(essence_options, path, names)
+        end
+    end
+
+    def create_defaults(essence_options, path, names)
+        BEM[:default].each do |tech|
+            template "#{tech}.tt", File.join(essence_options[:path], path, names[:name], names[:name] + BEM[:techs][tech])
+        end
+    end
+
+    def remove_essence(essence_options, path)
+        names = generate_names
+        destination = File.join(essence_options[:path], path, names[:name])
+        destination = File.join(destination, names[:name] + BEM[:techs][options[:tech].to_sym]) if options[:tech]
+        FileUtils.rm_rf(destination)
+
+        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") { |f| f.write("\n" + line) }
+        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]}"
+
+            tmp = Tempfile.new("temp")
+            open(asset, 'r').each do |l|
+                tmp << l unless l.chomp == line || l.empty?
+            end
+            tmp.close
+
+            FileUtils.mv(tmp.path, asset)
+        end
+    end
+
+    def search_usage_information(essence, path)
+        BEM[:usage].each do |tech|
+            file_destination = File.join(path_to_block(path), essence, essence + BEM[:techs][tech])
+            read_usage(file_destination) if File.exist?(file_destination)
+        end
+    end
+
+    def read_usage(target)
+        puts "#{ tech }: #{ target }"
+        puts "BEM[:usage]:\t"
+        File.readlines(target) { |line| puts line }
+    end
+
+    def print_blocks_list(essence="", path)
+        directory_destination = File.join(path_to_block(path), essence)
+        parse_directory(:blocks, 'green', directory_destination)
+    end
+
+    def print_elements_list(ess_name="", path)
+        directory_destination = File.join(path_to_block(path), ess_name, BEM[:elements][:dir])
+        parse_directory(:elements, 'purple', directory_destination)
+    end
+
+    def print_mods_list(ess_name="", path)
+        directory_destination = File.join(path_to_block(path), ess_name, BEM[:mods][:dir])
+        parse_directory(:mods, 'cyan', directory_destination)
+    end
+
+    def print_values_list(ess_name="", path)
+        directory_destination = File.join(path_to_block(path), ess_name)
+        parse_directory(:mods, 'yellow', directory_destination)
+    end
+
+    def parse_directory(directory, essence, color)
+        print_message("BEM[#{ essence }]:\t", color)
+        Dir[directory + "/*"].each do |name|
+            name = name.split('/')[-1]
+            puts " - " + name.split(BEM[essence][:prefix])[1]
+        end
+    end
+
+    def manipulate_essence(action, ess, path)
+        ess_name = send(ess)
+        ess_name = mod(options[:value] ? options[:value] : options[:mod]) if ess == :mod
+        destination = File.join(path, ess_name)
+
+        case action
+            when :create
+                create_essence(BEM[ess.to_s.pluralize.to_sym], path)
+                update_assets(ess_name, path)
+            when :remove
+                remove_essence(BEM[ess.to_s.pluralize.to_sym], path)
+                cut_assets(ess_name, path)
+            when :usage
+                search_usage_information(ess_name, path) if essence_exist?(destination)
+            else raise print_message("You should set params. Try 'thor help bem:#{action}' for more information", 'red')
+        end
+    end
+
+end

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

@@ -0,0 +1,79 @@
+BEM = {}
+
+BEM[:attrs] = [:block, :elem, :mods, :elemMods, :bem, :js, :jsAttr, :cls, :tag, :mix, :content]
+
+# 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, :sass, :coffee, :md]
+# Usage files variants.
+BEM[:usage] = [:md, :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]

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

@@ -1,6 +1,9 @@
 module Bemonrails
-
     class Railtie < Rails::Railtie
+        initializer "railtie.configure_rails_initialization" do
+            require 'bem-on-rails/initializers/bem'
+        end
+
         ActiveSupport.on_load :action_view do
             include Bemonrails::BemRenderHelper
         end

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

@@ -1,3 +1,3 @@
 module Bemonrails
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bem-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Anton Winogradov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rvmrc
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -94,6 +95,7 @@ files:
 - lib/bem-on-rails/generators/templates/techs/sass.tt
 - lib/bem-on-rails/generators/templates/techs/slim.tt
 - lib/bem-on-rails/generators/templates/thor/bem.tt.rb
+- lib/bem-on-rails/initializers/bem.rb
 - lib/bem-on-rails/railtie.rb
 - lib/bem-on-rails/version.rb
 homepage: https://github.com/verybigman/bem-on-rails
@@ -116,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.7
 signing_key: 
 specification_version: 4
 summary: BEM Tools for Rails applications