moka 0.1.1

data/lib/commands/lib/lipsum_helpers.rb

@@ -0,0 +1,56 @@
+module Moka
+  module LipsumHelpers
+    require File.expand_path('lipsum_constants.rb', File.dirname(__FILE__))
+  
+    class Lipsum
+
+      # If called without a block, returns a number of paragraphs of dummy text equal to count (with each paragraph enclosed in <p>...</p>). If a block is given, iteratively calls the block passing each paragraph as argument.
+      #
+      def self.paragraphs(count, &block)
+        if block_given?
+          count.to_i.times do |i|
+            yield LipsumConstants::PARAGRAPHS[i]
+          end
+        else
+          return LipsumConstants::PARAGRAPHS[0, count].collect{|p| "<p>#{p}</p>\n"}.join
+        end
+      end
+
+      # If called without a block, returns a string of dummy text with a number of sentences equal to count (without any markup). If a block is given, iteratively calls the block passing each sentence as argument.
+      #
+      def self.sentences(count, &block)
+        sentences = LipsumConstants::PARAGRAPHS.join.split(/\.\s*/)
+        if block_given?
+          count.to_i.times do |i|
+            yield sentences[i]
+          end
+        else
+          return sentences[0, count].join(". ")
+        end
+      end
+
+      # If called without a block, returns a string of dummy text with a number of words equal to count (space-separated and without any markup). If a block is given, iteratively calls the block passing each word as argument.
+      #
+      # ==== Gotcha:
+      #
+      # If a block is given, the block is iteratively called passing as arguments only words more than 3 characters long. This way, nice dummy lists and menus can be generated without having to remove very short words.
+      #
+      def self.words(count, &block)
+        words = LipsumConstants::PARAGRAPHS.join.split(/[\W+]/)
+        if block_given?
+          shifter = 0
+          count.to_i.times do |i|
+            if words[i].size > 3
+              yield words[i].downcase
+            else
+              shifter += 1
+            end
+          end
+        else
+          return words[0, count].join(" ")
+        end
+      end
+
+    end
+  end
+end

data/lib/commands/lib/page_scope.rb

@@ -0,0 +1,29 @@
+module Moka
+  class PageScope
+    require File.expand_path('string_inflectors', File.dirname(__FILE__))
+    require File.expand_path('helpers', File.dirname(__FILE__))
+    require File.expand_path('partials_inclusion', File.dirname(__FILE__))
+    require File.expand_path('lipsum_helpers', File.dirname(__FILE__))
+    require File.expand_path('site_tree', File.dirname(__FILE__))
+
+    include Moka::SiteTree
+    include Moka::Helpers
+    include Moka::LipsumHelpers
+    include Moka::PartialsInclusion
+
+    $:.unshift(File.expand_path('project/lib', MOKA_ROOT))
+    require 'helpers'
+
+    def initialize(manifest, current_group_name, current_page_name)
+      @site = SiteNode.new("site", manifest["site"])
+      @current_group = @site.find_group(current_group_name)
+      @current_page = @current_group.find_page(current_page_name)
+    end
+
+    # returns a binding to the object
+    def get_binding
+      binding
+    end
+
+  end
+end

data/lib/commands/lib/partials_inclusion.rb

@@ -0,0 +1,42 @@
+module Moka
+  module PartialsInclusion
+  
+    require File.expand_path('utilities', File.dirname(__FILE__))
+
+    # Include a partial. The method looks for a partial named as the argument and with extension .erb or .haml searching for it first in the current page directory, then in the current group directory and, finally, in the site directory. In other words, the partial which gets included is always the most specific one. If no partial with that name is found, an empty string is returned.
+    def partial(partial_name)
+      partial_name = partial_name.to_s
+      ext = nil
+      partial_dir = File.join [@current_group.name, @current_page.name]
+    
+      partial_string = ""
+      partial_file = nil
+    
+      while ext.nil? do
+        if File.exist?(File.expand_path("project/site/#{partial_dir}/#{partial_name}.erb", MOKA_ROOT))
+          partial_file = File.new(File.expand_path("project/site/#{partial_dir}/#{partial_name}.erb", MOKA_ROOT), "r")
+          ext = "erb"
+        elsif File.exist?(File.expand_path("project/site/#{partial_dir}/#{partial_name}.haml", MOKA_ROOT))
+          partial_file = File.new(File.expand_path("project/site/#{partial_dir}/#{partial_name}.haml", MOKA_ROOT), "r")
+          ext = "haml"
+        end
+        if partial_dir == "" and ext.nil?
+          puts "WARNING: cannot find partial file #{partial_name}.erb or #{partial_name}.haml"
+          break
+        end
+        partial_dir = File.dirname partial_dir
+        if partial_dir == "."
+          partial_dir = ""
+        end
+      end
+    
+      unless partial_file.nil?
+        partial_string = partial_file.read
+        partial_file.close
+      end
+    
+      return Moka::Utilities.eval_erb_haml(partial_string, ext, self.get_binding)
+    end
+
+  end
+end

data/lib/commands/lib/site_tree.rb

@@ -0,0 +1,274 @@
+module Moka
+  module SiteTree
+    RESERVED_NAMES = %w(path order layout name children parent site group groups pages variables vars find_child find_group find_page initialize)
+
+    class TreeNode
+      attr_accessor :name
+      attr_accessor :parent
+
+      def initialize(name, params = {}, parent = nil)
+        @name = name
+        @parent = parent
+        @children = NodeArray.new
+        @params = {"name" => @name}
+        @variables = {}
+      end
+
+      # Returns a NodeArray object containing all the children nodes of the current node
+      def children
+        return @children.sort do |a, b|
+          if a.respond_to?(:order) and b.respond_to?(:order)
+            a.send(:order) <=> b.send(:order)
+          else
+            if b.respond_to?(:order)
+              -1
+            else
+              1
+            end
+          end
+        end
+      end
+
+      # Returns the child node having the name equal to the string passed as argument or nil if such child does not exist
+      def find_child(child_name)
+        children.find(child_name)
+      end
+
+      # Returns a Hash with the node's defined variable names (as keys) and their respective value (as values).
+      def variables(include_defined_in_parent = true)
+        unless self.parent.nil? or include_defined_in_parent == false
+          v = self.parent.variables
+        else
+          v = {}
+        end
+        v.merge!(@variables)
+      end
+
+      # Returns a Hash containing the node's parameters (as keys) and their respective value (as values).
+      def params
+        @params
+      end
+
+      # Alias for variables
+      def vars(include_defined_in_parent = true)
+        variables(include_defined_in_parent)
+      end
+
+      protected
+
+      # Creates an INSTANCE method dynamically
+      def create_method(name, &block)
+        self.metaclass.send(:define_method, name, &block)
+      end
+    end
+
+
+
+    class SiteNode < TreeNode
+      def initialize(name, params = {}, parent = nil)
+        super(name, params, parent)
+        if File.exist? File.expand_path("project/site/variables.yml", MOKA_ROOT)
+          site_vars = YAML.load_file(File.expand_path("project/site/variables.yml", MOKA_ROOT)) || {}
+          site_vars.each do |key, value|
+            unless RESERVED_NAMES.include? key
+              self.instance_variable_set "@#{key}", value
+              @variables[key.to_s] = value
+              self.create_method(key) do self.instance_variable_get("@#{key}") end
+              self.create_method("#{key}=") do |v| self.instance_variable_set("@#{key}", v); @variables[key.to_s] = v end
+            end
+          end
+        end
+
+        params.each do |key, value|
+          key.gsub!(/\s/, "_")
+          if value.is_a?(Hash)
+            self.instance_variable_set "@#{key}", GroupNode.new(key, value, self)
+            @children << instance_eval("@#{key}")
+          else
+            self.instance_variable_set "@#{key}", value
+            @params[key.to_s] = value
+          end
+          self.create_method(key) do self.instance_variable_get("@#{key}") end
+        end
+      end
+
+      # Returns a NodeArray object containing all the site's groups (the children of the site node)
+      def groups
+        self.children
+      end
+
+      # Returns the group having the name equal to the string passed as argument or nil if such group does not exist
+      def find_group(group_name)
+        children.find(group_name)
+      end
+
+      # Save site variables in the variables.yml file
+      def save
+        f = File.open( File.expand_path("project/site/variables.yml", MOKA_ROOT), 'w' ) do |out|
+          YAML.dump( variables(false), out )
+        end
+      end
+    end
+
+
+
+    class GroupNode < TreeNode
+      attr_accessor :site
+
+      def initialize(name, params = {}, parent = nil)
+        super(name, params, parent)
+        @site = parent
+
+        if File.exist? File.expand_path("project/site/#{name}/variables.yml", MOKA_ROOT)
+          group_vars = YAML.load_file(File.expand_path("project/site/#{name}/variables.yml", MOKA_ROOT)) || {}
+        else
+          group_vars = {}
+        end
+        @site.variables.merge(group_vars).each do |key, value|
+          unless RESERVED_NAMES.include? key
+            self.instance_variable_set "@#{key}", value
+            @variables[key.to_s] = value if group_vars.keys.include? key.to_s
+            self.create_method(key) do self.instance_variable_get("@#{key}") end
+            self.create_method("#{key}=") do |v| self.instance_variable_set("@#{key}", v); @variables[key.to_s] = v end
+          end
+        end
+
+        params.each do |key, value|
+          key.gsub!(/\s/, "_")
+          if value.is_a?(Hash)
+            self.instance_variable_set "@#{key}", PageNode.new(key, value, self)
+            @children << instance_eval("@#{key}")
+          else
+            self.instance_variable_set "@#{key}", value
+            @params[key.to_s] = value
+          end
+          self.create_method(key) do self.instance_variable_get("@#{key}") end
+        end
+      end
+
+      # Returns a NodeArray object containing all the pages in the group (its children nodes)
+      def pages
+        self.children
+      end
+
+      # Looks for a page in the group having the name equal to the string passed as argument. Returns the page or nil if no such page was found.
+      def find_page(page_name)
+        children.find(page_name)
+      end
+
+      # Save group variables in the variables.yml file
+      def save
+        f = File.open( File.expand_path("project/site/#{self.name}/variables.yml", MOKA_ROOT), 'w' ) do |out|
+          YAML.dump( variables(false), out )
+        end
+      end
+    end
+
+
+
+    class PageNode < TreeNode
+      attr_accessor :group
+  
+      def initialize(name, params = {}, parent = nil)
+        super(name, params, parent)
+        @group = parent
+
+        if File.exist? File.expand_path("project/site/#{@group.name}/#{name}/variables.yml", MOKA_ROOT)
+          page_vars = YAML.load_file(File.expand_path("project/site/#{@group.name}/#{name}/variables.yml", MOKA_ROOT)) || {}
+        else
+          page_vars = {}
+        end
+        @group.variables.merge(page_vars).each do |key, value|
+          unless RESERVED_NAMES.include? key
+            self.instance_variable_set("@#{key}", value)
+            @variables[key.to_s] = value if page_vars.keys.include? key.to_s
+            self.create_method(key) do self.instance_variable_get("@#{key}") end
+            self.create_method("#{key}=") do |v| self.instance_variable_set("@#{key}", v); @variables[key.to_s] = v end
+          end
+        end
+
+        params.each do |key, value|
+          key.gsub!(/\s/, "_")
+          self.instance_variable_set "@#{key}", value
+          @params[key.to_s] = value
+          self.create_method(key) do self.instance_variable_get("@#{key}") end
+        end
+      end
+
+      # Save page variables in the variables.yml file
+      def save
+        f = File.open( File.expand_path("project/site/#{@group.name}/#{self.name}/variables.yml", MOKA_ROOT), 'w' ) do |out|
+          YAML.dump( variables(false), out )
+        end
+      end
+    end
+
+    class NodeArray < Array
+    # Like an Array, but with some other helpful methods to filter, order and select elements. The methods are intended to work with elements being instances of classes extending TreeNode (like SiteNode, GroupNode or PageNode).
+
+      # Returns the element having the value of the variable name equal to the argument, or nil if such an element does not exist.
+      def find(name)
+        self.each do |c|
+          if c.respond_to?(:name) and c.name == name.to_s
+            return c
+          end
+        end
+        return nil
+      end
+
+      # Orders the elements by a variable. The elements that do not have that variable are placed last.
+      def order_by(ordering_var)
+        return self.sort do |a, b|
+          if a.respond_to?(ordering_var.to_sym) and b.respond_to?(ordering_var.to_sym)
+            a.send(ordering_var.to_sym) <=> b.send(ordering_var.to_sym)
+          else
+            if b.respond_to?(ordering_var.to_sym)
+              -1
+            else
+              1
+            end
+          end
+        end
+      end
+
+      # Returns another NodeArray containing only the elements satisfying the conditions. conditions can be a Hash containing pairs variable_name => variable_value or a string to be evalued as ruby code.
+      #
+      # ==== Examples:
+      #
+      # @site.groups.where({:somevar => somevalue, :another_var => another_value})
+      #
+      # @site.groups.where("order < 5")
+      #
+      def where(conditions)
+        found = NodeArray.new
+        self.each do |c|
+          if conditions.is_a? Hash
+            satisfied = true
+            conditions.each do |var_name, var_value|
+              unless c.respond_to?(var_name.to_sym) and c.send(var_name.to_sym) == var_value
+                satisfied = false
+                break
+              end
+            end
+            if satisfied
+              found << c
+            end
+          else # conditions should be a string (or something that acts like one)
+            if c.instance_eval(conditions)
+              found << c
+            end
+          end
+        end
+        return found
+      end
+
+    end
+  end
+end
+
+class Object
+  # Needed for define_method to add INSTANCE methods dynamically
+  def metaclass
+    class << self; self; end
+  end
+end

data/lib/commands/lib/string_inflectors.rb

@@ -0,0 +1,13 @@
+class String
+
+  # Returns the string with the first character of each word capitalized, and with underscores substituted by spaces.
+  def titleize
+    self.humanize.gsub(/\b('?[a-z])/) { $1.capitalize }
+  end
+
+  # Returns the string with the very first character capitalized, and with underscores substituted by spaces.
+  def humanize
+    self.gsub(/_/, " ").capitalize
+  end
+
+end

data/lib/commands/lib/utilities.rb

@@ -0,0 +1,45 @@
+module Moka
+  class Utilities
+
+    def self.parse_grouppage(grouppage)
+      # parse group:page syntax and return [page, group]
+      semicolon = grouppage.index ":"
+      unless semicolon.nil?
+        return [grouppage[(semicolon + 1)..-1], grouppage[0..(semicolon-1)]]
+      else
+        return [grouppage, "root"]
+      end
+    end
+
+    def self.parse_argvalue(argvalue)
+      # parse argument=value syntax and return [argument, value]
+      equal = argvalue.index "="
+      unless equal.nil?
+        arg_name = argvalue[0..(equal-1)]
+        arg_value = argvalue[(equal + 1)..-1]
+      else
+        arg_name = argvalue
+        arg_value = nil
+      end
+      return [arg_name, arg_value]
+    end
+  
+    def self.eval_erb_haml(code, ext, scope)
+      require "rubygems"
+      # evaluates erb or haml code
+      if ext == "erb"
+        require 'erb'
+        eval_string = ERB.new(code).result(scope)
+      elsif ext == "haml"
+        require 'haml'
+        eval_string = Haml::Engine.new(code).render(scope)
+      end
+      return eval_string
+    end
+  
+    def self.deepcopy(obj)
+      Marshal::load(Marshal::dump(obj))
+    end
+
+  end
+end