bem-on-rails 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db5b4a9a59a618f6262eccc08032c9d2ef7d9778
-  data.tar.gz: 3f1f5738a05779c041f1debcad85651616af34f5
+  metadata.gz: 6995691b232fdf4379ed487cfd5e617e160a3eb3
+  data.tar.gz: b4c0d05d26cd0985fc2cc99d4e586a5e68a8f2aa
 SHA512:
-  metadata.gz: f5bc8f7d40d5c28a7e7dc8f83a313526e1ee15705e91bdff65458972bdc164253aaa578451b784789caa03a8c034a3597e7b61da2242c7958c36e78b0f7b9d26
-  data.tar.gz: 1e4e04663d0d743042146ff533d1b7890cb6d82d3cf14e74a749b6762e123c0c462c583628dbff95c5660f2bbf2bf9eda05d771a77c93d667fe345b2a6faa641
+  metadata.gz: b29fdc8916e7cf7ef078084ff5d399a3633842c3df8978285a5d6e1253ec25dad707fcf3cc53823f64e7fdbc65a1595a2855cd9f7ce5c4960f4291d3e63a6129
+  data.tar.gz: ee7691bd4bcbc1709c361896e74d6355e32ad9e1d540819c9d78ce73c6c65c28fc91776731a0a56ca982c213c05dcd88afe337e9c2636511bbf0cd03593ac3f3

data/CHANGELOG.md

@@ -8,3 +8,9 @@
 * fix trubles with mods without value
 * add custom attributes for tags
 * add custom classes for tags
+
+## v0.0.3
+
+* extract helpers includes to railtie
+* extract views folder includes to railtie
+* update install generator

data/README.md

@@ -1,6 +1,6 @@
 [![Bem on Rails](http://habrastorage.org/storage3/551/97d/0c5/55197d0c503e312952195b2ae0e4c337.png)](https://github.com/verybigman/bem-on-rails)
 
-# BEM on Rails
+# BEM on Rails [![Code Climate](https://codeclimate.com/github/verybigman/bem-on-rails.png)](https://codeclimate.com/github/verybigman/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/).
@@ -23,8 +23,7 @@ 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:
+This generator creates Thor task with templates. You should run to watch your new instruments:
     
     $ thor -T 
     
@@ -125,6 +124,11 @@ Block with custom class for tag:
 = b "test", cls: "custom", content: []
 ```
 
+Block with custom tag for block( 'div' is default ):
+```ruby
+= b "test", tag: "article", content: []
+```
+
 Syntax is look like [bemhtml](http://ru.bem.info/articles/bemhtml-reference/).
 
 ### Templates
@@ -132,7 +136,12 @@ 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
-%div{ bemattrs }
+- haml_tag bemtag, bemattrs
+	= bemcontent
+```
+Or Slim template:
+```slim
+* bemtag, bemattrs
 	= bemcontent
 ```
 Bemclass and bemcontent is BEM helpers for rendering. 
@@ -144,15 +153,15 @@ Read [here](http://habrahabr.ru/post/181880/) about it.
 
 If you want it, please watch [here](https://github.com/Vasfed/csso-rails).
 
+*__Stay BEMed!__*
+
 ## Tomorrow
 
 0. Incapsulate helpers methods and isolate them from project helpers.
-1. Custom tag for block or element.
-2. Add custom classes for blocks and elements.
-3. Flags bem and js.
-4. Mix blocks and elements.
-5. Mods with restructure. Now you can't use mods with templates(haml, slim and etc.), but they generates.
-6. Bem exutable. Work with Thor is not convenient.
+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.
 
 ## Contributing
 

data/app/helpers/bemonrails/bem_render_helper.rb

@@ -1,102 +1,107 @@
 module Bemonrails
-	module BemRenderHelper
-		
-		include Bemonrails::BemNames
+  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]
-                @custom_attrs = builder[:attrs]
-                @custom_class = builder[:cls]
-	            @content = builder[:content]
-	            # Render block in view  
-	            template_exists?(target) ? render(file: target) : bemempty
-	        end
-	    end
-	    alias :b :render_block
+    def bemtag
+      @custom_tag ||= "div"
+    end
 
-	    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]
-                @custom_attrs = builder[:attrs]
-                @custom_class = builder[:cls]
-	            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_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]
+        @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
+      end
+    end
+    alias :b :render_block
 
-	    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 
-	            end
-	        end
+    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]
+        @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
+      end
+    end
+    alias :e :render_element
 
-            bemclass = classes_array.join(" ")
-
-            # If custom class exist
-            if @custom_class
-                bemclass = [bemclass, @custom_class].join(" ")
+    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 
+        end
+      end
 
-            # String for tag attributes
-	        bemattributes = { class: bemclass }
+      bemclass = classes_array.join(" ")
 
-            # If custom attributes exist
-            if @custom_attrs
-                bemattributes.merge! @custom_attrs
-            end
+      # If custom class exist
+      if @custom_class
+        bemclass = [bemclass, @custom_class].join(" ")
+      end
+
+      # String for tag attributes
+      bemattributes = { class: bemclass }
+
+      # If custom attributes exist
+      if @custom_attrs
+        bemattributes.merge! @custom_attrs
+      end
 
-            bemattributes
-	    end
-	    alias :bemattrs :render_bemattributes
+      bemattributes
+    end
+    alias :bemattrs :render_bemattributes
 
-	    def render_empty
-	        "<div class=#{ bemclass }></div>".html_safe
-	    end
-	    alias :bemempty :render_empty
+    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
+    def render_content
+      render "bemonrails/essences/content"
+    end
+    alias :bemcontent :render_content
+  end
+end

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

@@ -1,18 +1,20 @@
 - 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],
-			                      attrs: essence[:attrs],
-			                      cls: essence[:cls] }
+  - @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] }
 
-		- elsif essence.kind_of?(Hash) && essence[:block]
-			= b essence[:block], { content: essence[:content],
-			                       mods: essence[:mods],
-			                       attrs: essence[:attrs],
-			                       cls: essence[:cls] }
+    - 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] }
 
-		- else
-			= essence
+    - else
+      = essence
 - else
-	= @content
+  = @content

data/lib/bem-on-rails.rb

@@ -1,8 +1,9 @@
 require "bem-on-rails/version"
 require "bem-on-rails/engine"
 require "bem-on-rails/build/bem_names"
+require "bem-on-rails/build/console_messages"
 require "bem-on-rails/generators/install_generator"
+require 'bem-on-rails/railtie' if defined?(Rails)
 
 module Bemonrails
-	
 end

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

@@ -1,110 +1,124 @@
 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)
+  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]
+    def path_to_block(path)
+      BEM[:blocks][:path] + path
+    end
 
-                names[:klass] = names[:name] = block
+    def generate_names(builder=options)
+      names = {}
+      # Generate names for block, his mods and they values
+      if builder[:block]
 
-                if builder[:mod]
-                    names[:name] = mod
-                    names[:klass] = block + names[:name]
-                end
+        names[:klass] = names[:name] = block
 
-                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]
+        if builder[:mod]
+          names[:name] = mod
+          names[:klass] = block + names[:name]
+        end
 
-                names[:name] = element
-                names[:klass] += names[:name]
+        if builder[:value]
+          names[:name] =  mod(builder[:value])
+          names[:klass] = block + mod + names[:name]
+        end
+      end
 
-                if builder[:mod]
-                    names[:name] = mod
-                    names[:klass] = block + element + names[:name]
-                end
+      # Generate names for elements, his mods and they values
+      if builder[:element]
 
-                if builder[:value]
-                    names[:name] =  mod(builder[:value])
-                    names[:klass] = block + element + mod + names[:name]
-                end
-            end
+        names[:name] = element
+        names[:klass] += names[:name]
 
-            names
+        if builder[:mod]
+          names[:name] = mod
+          names[:klass] = block + element + names[:name]
         end
 
-        def block(name=options[:block])
-            BEM[:blocks][:prefix] + name
+        if builder[:value]
+          names[:name] =  mod(builder[:value])
+          names[:klass] = block + element + mod + names[:name]
         end
+      end
 
-        def element_directory
-            block_name = @block_name ? @block_name : options[:block]
-            File.join(block(block_name), BEM[:elements][:dir])
-        end
+      names
+    end
 
-        def element(name=options[:element])
-            BEM[:elements][:prefix] + name
-        end
+    def essence
+      if options[:block] && !options[:element] && !options[:mod]
+        :block
+      elsif options[:element] && !options[:mod]
+        :element
+      elsif options[:mod]
+        :mod
+      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 block(name=options[:block])
+      BEM[:blocks][:prefix] + name
+    end
 
-        def mod(name= options[:mod], value=false)
-            if value
-                BEM[:mods][:prefix] + value
-            else
-                BEM[:mods][:prefix] + name
-            end
-        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
+    def template_exists?(file)
+      BEM[:techs].each do |tech, extension|
+        if File.exists? file + extension
+          return true 
         end
-	end
+      end
+    end
+  end
 end