bem-on-rails 0.0.2 → 0.0.3

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

@@ -0,0 +1,24 @@
+module Bemonrails
+  module ConsoleMessages
+    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
+end

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

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

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

@@ -5,36 +5,20 @@ module Bemonrails
     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 "config/initializer.tt.rb", File.join(Rails.root, "config", "initializers", "bem.rb")
+        template "config/initializer.tt.rb", File.join(Rails.root, "config", "initializers", "bem.rb")
       end
 
       def install_bem_tasks
-      	template "thor/bem.tt.rb", File.join(Rails.root, "lib", "tasks", "bem.thor")
+        template "thor/bem.tt.rb", 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 "techs/#{t}", File.join(Rails.root, "lib", "tasks", "templates", t)
-      	end
+        %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)
+        end
       end
 
     end
   end
-end
+end

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

@@ -2,60 +2,60 @@ 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"
+  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]
+  slim: BEM[:techs][:slim],
+  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]
+  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: ""
+  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: ""
+  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: ""
+  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,
@@ -75,16 +75,16 @@ BEM[:mods] = {
 # }
 
 BEM[:assets] = {
-    stylesheets:
-        {
-            ext: BEM[:techs][:sass],
-            import: '//= require'
-        },
-    javascripts:
-        {
-            ext: BEM[:techs][:js],
-            import: '//= require'
-        }
+  stylesheets:
+  {
+    ext: BEM[:techs][:sass],
+    import: '//= require'
+  },
+  javascripts:
+  {
+    ext: BEM[:techs][:js],
+    import: '//= require'
+  }
 }
 
 # You must use application files in
@@ -98,4 +98,4 @@ Rails.application.config.assets.paths << BEM[:blocks][:dir]
 # gem 'csso-rails'
 
 # And uncomment this
-# Rails.config.assets.css_compressor = :csso
+# Rails.config.assets.css_compressor = :csso

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

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

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

@@ -1,2 +1,2 @@
-%div{ bemattrs }
-	= bemcontent
+- haml_tag bemtag, bemattrs
+  = bemcontent

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

@@ -0,0 +1,2 @@
+* bemtag, bemattrs
+  = bemcontent

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

@@ -1,291 +1,187 @@
 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
+  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
-
-
-
-    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
+
+  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
 
-
-
-    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
+  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
-
-
-
-    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
+
+  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
 
-    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
+      FileUtils.mv(tmp.path, asset)
+    end
+  end
 
-            puts "#{color + message} \e[0m"
-        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
 
-        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
+end