bem-on-rails 0.0.5 → 1.0.0

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

@@ -1,124 +1,124 @@
 module Bemonrails
-  module BemNames
-    # Directories paths.
-    def build_path_for(essence, builder=options, include_level=true)
-      current_level = builder[:level] ? builder[:level] : BEM[:level]
-      path = include_level ? [current_level] : []
-      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')
+    module BemNames
+
+        # Resolve directories
+        def path_resolve(essence, builder=options, include_level=true)
+            current_level = builder[:level] ? builder[:level] : BEM[:level]
+            path = include_level ? [current_level] : []
+
+            case essence
+            when :mod
+                # This is for mods with value
+                if builder[:block] && builder[:element]
+                    path.push path_m(:element)
+                elsif builder[:block]
+                    path.push path_m(:block)
+                else
+                    raise print_message("Mods must be for block or element.", 'red')
+                end
+            when :element
+                path.push path_e(builder[:block], builder[:element])
+            when :block
+                path.push build_b(builder[:block])
+            else
+                raise print_message("Unknown params. Try 'thor help bem:create'", 'red')
+            end
+
+            File.join path.compact
         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 path_to_block(path, level="")
-      File.join Rails.root.join(BEM[:root], level + path)
-    end
+        def generate_klass(builder=options)
+            names = {}
 
-    def generate_names(builder=options)
-      names = {}
-      # Generate names for block, his mods and they values
-      if builder[:block]
+            # Generate names for block, his mods and they values
+            if builder[:block]
+                names[:klass] = build_b(builder[:block])
 
-        names[:klass] = names[:name] = block
+                # If block have mods
+                names[:klass] = build_m(builder[:block], nil, builder[:mod], builder[:value]) if builder[:mod]
+            end
 
-        if builder[:mod]
-          names[:name] = mod
-          names[:klass] = block + names[:name]
-        end
+            # Generate names for elements, they mods and they values
+            if builder[:element]
+                names[:klass] = build_e(builder[:block], builder[:element])
 
-        if builder[:value]
-          names[:name] =  mod(builder[:value])
-          names[:klass] = block + mod + names[:name]
+                # If element have mods
+                names[:klass] = build_m(builder[:block], builder[:element], builder[:mod], builder[:value]) if builder[:mod]
+            end
+
+            names
         end
-      end
 
-      # Generate names for elements, they mods and they values
-      if builder[:element]
+        def resolve_essence
+            essence = :block
 
-        names[:name] = element
-        names[:klass] += names[:name]
+            if options[:element]
+                essence = :element
+                if options[:mod]
+                    essence = :mod
+                end
+            end
 
-        if builder[:mod]
-          names[:name] = mod
-          names[:klass] = block + element + names[:name]
+            essence
         end
 
-        if builder[:value]
-          names[:name] =  mod(builder[:value])
-          names[:klass] = block + element + mod + names[:name]
+        def build_def(ess)
+            case ess
+            when :block
+                build_b
+            when :element
+                build_e
+            when :mod
+                build_m(options[:block], options[:element], options[:mod], options[:value])
+            end
         end
-      end
-
-      names
-    end
 
-    def essence
-      if options[:block] && !options[:element] && !options[:mod]
-        :block
-      elsif options[:element] && !options[:mod]
-        :element
-      elsif options[:mod]
-        :mod
-      end
-    end
+        def path_l(path, level=options[:level])
+            File.join Rails.root.join(BEM[:root], level, path)
+        end
 
-    def block(name=options[:block])
-      BEM[:blocks][:prefix] + name
-    end
+        # Build block name
+        def build_b(b=options[:block])
+            BEM[:blocks][:prefix] + b
+        end
 
-    def element_directory
-      block_name = @this ? @this[:block] : options[:block]
-      File.join(block(block_name), BEM[:elements][:dir])
-    end
+        # Build block path
+        def path_e(b=options[:block], e=options[:element])
+            File.join build_b(b), BEM[:elements][:dir], BEM[:elements][:prefix] + e
+        end
 
-    def element(name=options[:element])
-      BEM[:elements][:prefix] + name
-    end
+        # Build element name
+        def build_e(b=options[:block], e=options[:element])
+            if b
+                b + BEM[:elements][:prefix] + e
+            else
+                BEM[:elements][:prefix] + e
+            end
+        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 path_m(essence, m=options[:mod])
+            case essence
+            when :element
+                File.join path_e, build_e, BEM[:mods][:dir], BEM[:mods][:prefix] + m
+            else
+                File.join build_b, BEM[:mods][:dir], BEM[:mods][:prefix] + m
+            end
+        end
 
-    def mod(name= options[:mod], value=false)
-      if value
-        BEM[:mods][:prefix] + value
-      else
-        BEM[:mods][:prefix] + name
-      end
-    end
+        def build_m(b=options[:block], e=options[:element], m=options[:mod], v=options[:value])
+            name = build_b(b)
+            name = build_e(b, e) if e
+            name = name + BEM[:mods][:prefix] + m
+            name = name + BEM[:mods][:postfix] + v if v
+            name
+        end
 
-    def template_exists?(file)
-      BEM[:techs].each do |tech, extension|
-        if File.exists? file + extension
-          return true 
+        def template_exists?(file)
+            BEM[:techs].each do |tech, ext|
+                return true if File.exists? file + ext
+            end
         end
-      end
+
     end
-  end
+
 end

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

@@ -1,24 +1,27 @@
 module Bemonrails
-  module ConsoleMessages
-    def print_message(message, color)
-      check_argument_data_type(message, String)
-      check_argument_data_type(color, String)
+    module ConsoleMessages
 
-      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
+        def print_message(message, color)
+            check_argument_data_type(message, String)
+            check_argument_data_type(color, String)
 
-      puts "#{color + message} \e[0m"
-    end
+            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
 
-    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/build/levels.rb

@@ -1,10 +1,14 @@
 module Bemonrails
-    module Levels        
+    module Levels
+
         def parse_bem_levels
             BEM[:levels].each do |level|
                 prepend_view_path File.join(BEM[:root] , level[:name])
             end
-            prepend_view_path BEM[:root] 
+
+            prepend_view_path BEM[:root]
         end
+
     end
-end
+    
+end

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

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

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

@@ -1,24 +1,27 @@
 require 'rails/generators'
 
 module Bemonrails
-  module Generators
-    class InstallGenerator < ::Rails::Generators::Base
-      source_root File.expand_path("../templates/", __FILE__)
+    module Generators
+        class InstallGenerator < ::Rails::Generators::Base
 
-      def add_initializer
-        template "config/initializer.tt.rb", File.join(Rails.root, "config", "initializers", "bem.rb")
-      end
+            source_root File.expand_path("../templates/", __FILE__)
 
-      def install_bem_tasks
-        template "thor/bem.tt.rb", File.join(Rails.root, "lib", "tasks", "bem.thor")
-      end
+            def initializers
+                template "config/initializer.tt.rb", File.join(Rails.root, "config", "initializers", "bem.rb")
+            end
+
+            def tasks
+                template "thor/bem.tt.rb", File.join(Rails.root, "lib", "tasks", "bem.thor")
+            end
+
+            def templates
+                %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
 
-      def add_blocks_templates
-        %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
 
     end
-  end
+
 end

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

@@ -10,29 +10,15 @@
 # Default directories, try to customize.
 # Blocks directory in root of rails app.
 # BEM[:blocks] = {
-#  dir: BEM[:root],
-#  prefix: "",
-#  postfix: ""
+#    dir: BEM[:root],
+#    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] = {
-#   ...
-# }
-# BEM[:mods] = {
-#   ...
-# }
-
-# Work with levels
-# Add new level with 'thor bem:levels'
-# Require it: 
-# bem_controls = { name: "bem-controls", 
-#                  git:  "git@github.com:verybigman/bem-controls.git" }
-# Push to levels stack:
-# BEM[:levels].push(bem_controls)
-# Set it default if you want:
-# BEM[:level] = bem_controls[:name]
-# After install default level is your app name. Take it by BEM[:app].
+# 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
@@ -40,15 +26,12 @@
 # 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.
 # BEM[:assets] = {
-#   stylesheets: {
-#      ext: BEM[:techs][:scss],
-#      import: '//= require',
-#      posfix: ';'
-#   },
-#   javascripts: {
-#      ...  
-#   }
+#     stylesheets: {
+#        ext: BEM[:techs][:scss],
+#        import: '//= require',
+#        posfix: ';'
+#     },
+#     javascripts: {
+#        ...
+#     }
 # }
-
-# [!] Use CSSO instead of YUI.
-# Watch here https://github.com/Vasfed/csso-rails

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

@@ -7,259 +7,81 @@ class Bem < Thor
 
     source_root File.expand_path('../templates', __FILE__)
 
+    LEVEL_ASSETS = File.join ".bem", "assets"
+
     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 :element, type: :string, aliases: "-e", desc: "Create element in default techs."
     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 :level, type: :string, aliases: "-l", desc: "Create essence in level. Work for blocks only!"
-    method_option :force, type: :boolean, desc: "Force existing block, element or mod files."
+    method_option :level, type: :string, aliases: "-l", desc: "Create essence in level."
     def create
-        path = build_path_for(essence)
-        manipulate_essence(:create, essence, path)
-    end
+        create_level unless level_exist?
 
+        ess = resolve_essence
+        path = path_resolve(ess)
+        name = build_def(ess)
+        dest = File.join path, name
 
-    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 :level, type: :string, aliases: "-l", desc: "Remove essence in level. Work for blocks only!"
-    def remove
-        path = build_path_for(essence)
-        manipulate_essence(:remove, essence, path)
-    end
+        create_essence(BEM[ess.to_s.pluralize.to_sym], path)
 
-
-    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 :level, type: :string, aliases: "-l", desc: "Search essence in level."
-    def usage
-        path = build_path_for(essence)
-        manipulate_essence(:usage, essence, path)
-    end
-
-
-    desc 'list', 'See list of level, 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 :level, type: :string, aliases: "-l", desc: "All blocks in level."
-    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
-
-    desc 'levels', 'Manipulating with levels'
-    method_option :add, type: :boolean, aliases: "-a", desc: "Add new level"
-    method_option :git, type: :string, aliases: "-g", desc: "From git repository"
-    method_option :dir, type: :string, aliases: "-d", desc: "From local directory"
-    method_option :new, type: :string, aliases: "-n", desc: "Create new level"
-    method_option :default, type: :string, desc: "Create default level tree"
-    def levels
-        if options[:add]
-            level_name = ""
-            level = ""
-            if options[:git]
-                level_name = options[:git].split("/").last.gsub(".git", "")
-                level = Rails.root.join BEM[:root], level_name
-                print_message("Cloning blocks into new level: #{ level_name }...", "green")
-                `git clone #{ options[:git] } #{ level }`
-                test_level(level) ? level_added : level_error
-                level_has_assets?(level) ? update_assets_with_level(level_name) : make_level_assets_path(level)
-            elsif options[:dir]
-                level_name = options[:git].split("/").last
-                level = Rails.root.join BEM[:root], level_name
-                print_message("Copying blocks into new level: #{ level_name }...", "green")
-                `cp -R #{ options[:dir] } #{ level }`
-                test_level(level) ? level_added : level_error
-                level_has_assets?(level) ? update_assets_with_level(level_name) : make_level_assets_path(level)
-            elsif options[:new]
-                level_name = options[:new]
-                level = Rails.root.join BEM[:root], level_name
-                make_level_assets_path level
-                update_assets_with_level level_name
-                test_level(level) ? level_added : level_error
-            elsif options[:default]
-                level_name = BEM[:app]
-                level = Rails.root.join BEM[:root], level_name
-                make_level_assets_path level
-                update_assets_with_level level_name
-                test_level(level) ? level_added : level_error 
-            end       
-        end    
+        update_assets(name, path)
     end
 
     protected
 
-    def test_level(level)
-        File.directory? level
-    end
-
-    def level_added
-        print_message("New level added successfully! Change BEM[:levels] in bem.rb for available levels.", "green")            
+    def level_exist?(l=options[:level])
+        File.directory? Rails.root.join BEM[:root], l
     end
 
-    def level_error
-        print_message("Error! We have a trouble with connection to repository. Please, try again.", "red")
-    end
-
-    def level_assets_path
-        File.join(".bem", "assets")
-    end
+    def create_level(l=options[:level])
+        target = Rails.root.join BEM[:root], l
 
-    def level_has_assets?(level)
-        File.directory? File.join level, level_assets_path
-    end
+        # Make files for level assets
+        BEM[:assets].each do |type, tech|
+            create_file File.join target, LEVEL_ASSETS, type.to_s, "level" + tech[:ext]
+        end
 
-    def update_assets_with_level(level)
+        # Update app assets with levels assets
         BEM[:assets].each do |type, tech|
             asset = File.join(Rails.root, "app", "assets", type.to_s, "application" + tech[:ext])
-            destination = [level, level_assets_path, type.to_s, "level" + tech[:ext]]  
-            create_file asset unless File.exist?(asset)       
+            destination = [l, LEVEL_ASSETS, type.to_s, "level" + tech[:ext]]
+            create_file asset unless File.exist?(asset)
             append_file asset, "\n#{ tech[:import] } #{ File.join(destination) }#{ tech[:postfix] }"
         end
     end
 
-    def make_level_assets_path(level)
-       BEM[:assets].each do |type, tech|
-            create_file File.join level, level_assets_path, type.to_s, "level" + tech[:ext]
-        end 
-    end
-
-    def essence_exist?(essence_dir)
-        File.directory? File.join BEM[:blocks][:path], essence_dir
-    end
-
     def create_essence(essence_options, path)
-        names = generate_names
+        names = generate_klass
         @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[:dir], path, names[:name], names[:name] + BEM[:techs][options[:tech].to_sym])
+            template "#{ options[:tech] }.tt", File.join(BEM[:root], path, names[:klass] + BEM[:techs][options[:tech].to_sym])
         else
-            create_defaults(essence_options, path, names)
+            defaults(essence_options, path, names)
         end
     end
 
-    def create_defaults(essence_options, path, names)
+    def defaults(essence_options, path, names)
         BEM[:default].each do |tech|
-            template "#{ tech }.tt", File.join(essence_options[:dir], path, names[:name], names[:name] + BEM[:techs][tech])
+            template "#{ tech }.tt", File.join(BEM[:root], path, names[:klass] + BEM[:techs][tech])
         end
     end
 
-    def remove_essence(essence_options, path)
-        names = generate_names
-        destination = File.join(essence_options[:dir], path, names[:name])
-        destination = File.join(destination, names[:name] + BEM[:techs][options[:tech].to_sym]) if options[:tech]
-        remove_dir destination
-    end
-
     def update_assets(name, path)
-        level = BEM[:level]
-        level ||= options[:level]  
+        level = BEM[:level] || options[:level]
+
         BEM[:assets].each do |type, tech|
-            asset = File.join(Rails.root, BEM[:root], level, level_assets_path, type.to_s, "level" + tech[:ext])
+            asset = File.join(Rails.root, BEM[:root], level, LEVEL_ASSETS, type.to_s, "level" + tech[:ext])
             # BEM[:root] > level > .bem > assets
             # 4 ../
-            destination = ["../../../../", path, name, name + tech[:ext]].reject(&:empty?)
-            create_file asset unless File.exist?(asset)              
+            destination = ["../../../../", path, name + tech[:ext]].reject(&:empty?)
+            create_file asset unless File.exist?(asset)
             append_file asset, "\n#{ tech[:import] } #{ File.join(destination) }#{ tech[:postfix] }"
         end
     end
 
-    def cut_assets(name, path)
-        level = BEM[:level]
-        level ||= options[:level]  
-        BEM[:assets].each do |type, tech|
-            asset = File.join(Rails.root, BEM[:root], level, level_assets_path, type.to_s, "level" + 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
+end