tr8n_core 4.0.1

data/lib/tr8n/language_case.rb

@@ -0,0 +1,116 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class Tr8n::LanguageCase < Tr8n::Base
+  belongs_to  :language
+  attributes  :id, :keyword, :latin_name, :native_name, :description, :application
+  has_many    :rules
+
+  TR8N_HTML_TAGS_REGEX = /<\/?[^>]*>/
+
+  def initialize(attrs = {})
+    super
+    self.attributes[:rules] = []
+    if hash_value(attrs, :rules)
+      self.attributes[:rules] = hash_value(attrs, :rules).collect{ |rule| Tr8n::LanguageCaseRule.new(rule.merge(:language_case => self)) }
+    end
+  end
+
+  def find_matching_rule(value, object = nil)
+    rules.each do |rule|
+      return rule if rule.evaluate(value, object)
+    end
+    nil
+  end
+
+  #######################################################################################################
+  ##  Evaluation Methods
+  #######################################################################################################
+
+  def apply(value, object = nil, options = {})
+    value = value.to_s
+    html_tokens = value.scan(TR8N_HTML_TAGS_REGEX).uniq
+    sanitized_value = value.gsub(TR8N_HTML_TAGS_REGEX, "")
+
+    if application.to_sym == :phrase
+      words = [sanitized_value]
+    else
+      words = sanitized_value.split(/[\s\/\\]/).uniq
+    end
+
+    # replace html tokens with temporary placeholders {$h1}
+    html_tokens.each_with_index do |html_token, index|
+      value = value.gsub(html_token, "{$h#{index}}")
+    end
+
+    # replace words with temporary placeholders {$w1}
+    words.each_with_index do |word, index|
+      value = value.gsub(word, "{$w#{index}}")
+    end
+
+    transformed_words = []
+    words.each do |word|
+      case_rule = find_matching_rule(word, object)
+      case_value = case_rule ? case_rule.apply(word) : word
+      transformed_words << decorate(word, case_value, case_rule, options)
+    end
+
+    # replace back the temporary placeholders with the html tokens
+    transformed_words.each_with_index do |word, index|
+      value = value.gsub("{$w#{index}}", word)
+    end
+
+    # replace back the temporary placeholders with the html tokens
+    html_tokens.each_with_index do |html_token, index|
+      value = value.gsub("{$h#{index}}", html_token)
+    end
+
+    value
+  end
+
+  #######################################################################################################
+  ##  Decoration Methods - TODO: move to decorators
+  #######################################################################################################
+
+  def decorate(word, case_value, case_rule, options = {})
+    return case_value if options[:skip_decorations]
+    return case_value if language.default?
+    return case_value unless Tr8n.config.current_translator and Tr8n.config.current_translator.inline?
+
+    "<span class='tr8n_language_case' data-case_id='#{id}' data-rule_id='#{case_rule ? case_rule.id : ''}' data-case_key='#{word.gsub("'", "\'")}'>#{case_value}</span>"
+  end
+
+  #######################################################################################################
+  ##  Cache Methods
+  #######################################################################################################
+
+  def to_cache_hash
+    hash = to_hash(:id, :keyword, :description, :latin_name, :native_name)
+    hash["rules"] = []
+    rules.each do |rule|
+      hash["rules"] << rule.to_cache_hash
+    end
+    hash
+  end
+
+end

data/lib/tr8n/language_case_rule.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class Tr8n::LanguageCaseRule < Tr8n::Base
+  belongs_to  :language_case
+  attributes  :id, :description, :examples, :conditions, :conditions_expression, :operations, :operations_expression
+
+  def conditions_expression
+    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(conditions).parse
+  end
+
+  def operations_expression
+    self.attributes[:operations_expression] ||= Tr8n::RulesEngine::Parser.new(operations).parse
+  end
+
+  def gender_variables(object)
+    return {} unless conditions.index('@gender')
+    return {"@gender" => "unknown"} unless object
+    context = language_case.language.context_by_keyword(:gender)
+    return {"@gender" => "unknown"} unless context
+    context.vars(object)
+  end
+
+  #######################################################################################################
+  ##  Evaluation Methods
+  #######################################################################################################
+
+  def evaluate(value, object = nil)
+    return false if conditions.nil?
+
+    re = Tr8n::RulesEngine::Evaluator.new
+    re.evaluate(["let", "@value", value])
+
+    gender_variables(object).each do |key, value|
+      re.evaluate(["let", key, value])
+    end
+
+    re.evaluate(conditions_expression)
+  rescue Exception => ex
+    Tr8n.logger.error("Failed to evaluate language case #{conditions}: #{ex.message}")
+    value
+  end
+
+  def apply(value)
+    value = value.to_s
+    return value if operations.nil?
+
+    re = Tr8n::RulesEngine::Evaluator.new
+    re.evaluate(["let", "@value", value])
+
+    re.evaluate(operations_expression)
+  rescue Exception => ex
+    Tr8n.logger.error("Failed to apply language case rule [case: #{language_case.id}] [rule: #{id}] [conds: #{conditions_expression}] [opers: #{operations_expression}]: #{ex.message}")
+    value
+  end
+
+  #######################################################################################################
+  ##  Cache Methods
+  #######################################################################################################
+
+  def to_cache_hash
+    to_hash(:id, :description, :examples, :conditions, :conditions_expression, :operations, :operations_expression)
+  end
+
+end

data/lib/tr8n/language_context.rb

@@ -0,0 +1,115 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+
+class Tr8n::LanguageContext < Tr8n::Base
+  belongs_to  :language
+  attributes  :keyword, :description, :default_key, :token_expression, :variables, :token_mapping
+  has_many    :keys, :rules
+
+  def initialize(attrs = {})
+    super
+
+    self.attributes[:rules] = {}
+    if hash_value(attrs, :rules)
+      hash_value(attrs, :rules).each do |key, rule|
+        self.attributes[:rules][key] = Tr8n::LanguageContextRule.new(rule.merge(:language_context => self))
+      end
+    end
+  end
+
+  def config
+    context_rules = Tr8n.config.context_rules
+    hash_value(context_rules, keyword) || {}
+  end
+
+  def token_expression
+    @token_expression ||= begin
+      exp = self.attributes[:token_expression]
+      exp = Regexp.new(exp[1..-2])
+      exp
+    end
+  end
+
+  def applies_to_token?(token)
+    token_expression.match(token) != nil
+  end
+
+  def fallback_rule
+    @fallback_rule ||= rules.values.detect{|rule| rule.fallback?}
+  end
+
+  # prepare variables for evaluation
+  def vars(obj)
+    vars = {}
+
+    variables.each do |key|
+      method = hash_value(config, "variables.#{key}")
+      unless method
+        vars[key] = obj
+        next
+      end
+
+      if method.is_a?(String)
+        if obj.is_a?(Hash)
+          object = hash_value(obj, 'object') || obj
+          if object.is_a?(Hash)
+            vars[key] = hash_value(object, method, :whole => true)
+          else
+            vars[key] = object.send(method)
+          end
+        else
+          vars[key] = obj.send(method)
+        end
+      elsif method.is_a?(Proc)
+        vars[key] = method.call(obj)
+      else
+        vars[key] = obj
+      end
+    end
+    vars
+  end
+
+  def find_matching_rule(obj)
+    token_vars = vars(obj)
+    rules.values.each do |rule|
+      next if rule.fallback?
+      return rule if rule.evaluate(token_vars)
+    end
+    fallback_rule
+  end
+
+  #######################################################################################################
+  ##  Cache Methods
+  #######################################################################################################
+
+  def to_cache_hash
+    hash = to_hash(:keyword, :description, :keys, :default_key, :token_expression, :variables, :token_mapping)
+    hash[:rules] = {}
+    rules.each do |key, rule|
+      hash[:rules][key] = rule.to_cache_hash
+    end
+    hash
+  end
+
+end

data/lib/tr8n/language_context_rule.rb

@@ -0,0 +1,62 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class Tr8n::LanguageContextRule < Tr8n::Base
+  belongs_to  :language_context
+  attributes  :keyword, :description, :examples, :conditions, :conditions_expression
+
+  def fallback?
+    keyword.to_s.to_sym == :other
+  end
+
+  def conditions_expression
+    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(conditions).parse
+  end
+
+  #######################################################################################################
+  ##  Evaluation Methods
+  #######################################################################################################
+
+  def evaluate(vars = {})
+    return true if fallback?
+
+    re = Tr8n::RulesEngine::Evaluator.new
+    vars.each do |key, value|
+      re.evaluate(["let", key, value])
+    end
+
+    re.evaluate(conditions_expression)
+  #rescue Exception => ex
+  #  Tr8n.logger.error("Failed to evaluate settings context rule #{conditions_expression}: #{ex.message}")
+  #  false
+  end
+
+  #######################################################################################################
+  ##  Cache Methods
+  #######################################################################################################
+
+  def to_cache_hash
+    to_hash(:keyword, :description, :examples, :conditions, :conditions_expression)
+  end
+
+end

data/lib/tr8n/logger.rb

@@ -0,0 +1,83 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'logger'
+
+module Tr8n
+
+  def self.logger
+    @logger ||= begin
+      logfile_path = File.expand_path(Tr8n.config.log_path)
+      logfile_dir = logfile_path.split("/")[0..-2].join("/")
+      FileUtils.mkdir_p(logfile_dir) unless File.exist?(logfile_dir)
+      logfile = File.open(logfile_path, 'a')
+      logfile.sync = true
+      Tr8n::Logger.new(logfile)
+    end
+  end
+
+  class Logger < ::Logger
+
+    def format_message(severity, timestamp, progname, msg)
+      "[#{timestamp.strftime("%D %T")}]: #{"  " * stack.size}#{msg}\n"
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return unless Tr8n.config.logger_enabled?
+      super
+    end
+
+    def stack
+      @stack ||= []
+    end
+
+    def trace_api_call(path, params)
+      debug("api: [/#{path}] #{params.inspect}")
+      stack.push(caller)
+      t0 = Time.now
+      if block_given?
+        ret = yield
+      end
+      t1 = Time.now
+      stack.pop
+      debug("call took #{t1 - t0} seconds")
+      ret
+    end
+
+    def trace(message)
+      debug(message)
+      stack.push(caller)
+      t0 = Time.now
+      if block_given?
+        ret = yield
+      end
+      t1 = Time.now
+      stack.pop
+      debug("execution took #{t1 - t0} seconds")
+      ret
+    end
+
+  end
+
+end
+

data/lib/tr8n/rules_engine/evaluator.rb

@@ -0,0 +1,156 @@
+#--
+# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module Tr8n
+  module RulesEngine
+
+    class Evaluator
+      attr_reader :env, :vars
+
+      def initialize
+        @vars = {}
+        @env = {
+            # McCarthy's Elementary S-functions and Predicates
+            'label'   => lambda { |l, r|      @env[l] = @vars[l] = r },
+            'quote'   => lambda { |expr|      expr },
+            'car'     => lambda { |list|      list[1] },
+            'cdr'     => lambda { |list|      list.drop(1) },
+            'cons'    => lambda { |e, cell|   [e] + cell },
+            'eq'      => lambda { |l, r|      l == r },
+            'atom'    => lambda { |expr|      [Symbol, String, Fixnum, Float].include?(expr.class) },
+            'cond'    => lambda { |c, t, f|   evaluate(c) ? evaluate(t) : evaluate(f) },
+
+            # Tr8n Extensions
+            '='       => lambda { |l, r|      l == r },                                             # ['=', 1, 2]
+            '!='      => lambda { |l, r|      l != r },                                             # ['!=', 1, 2]
+            '<'       => lambda { |l, r|      l < r },                                              # ['<', 1, 2]
+            '>'       => lambda { |l, r|      l > r },                                              # ['>', 1, 2]
+            '+'       => lambda { |l, r|      l + r },                                              # ['+', 1, 2]
+            '-'       => lambda { |l, r|      l - r },                                              # ['-', 1, 2]
+            '*'       => lambda { |l, r|      l * r },                                              # ['*', 1, 2]
+            '%'       => lambda { |l, r|      l % r },                                              # ['%', 14, 10]
+            'mod'     => lambda { |l, r|      l % r },                                              # ['mod', '@n', 10]
+            '/'       => lambda { |l, r|      (l * 1.0) / r },                                      # ['/', 1, 2]
+            '!'       => lambda { |expr|      not expr },                                           # ['!', ['true']]
+            'not'     => lambda { |val|       not val },                                            # ['not', ['true']]
+            '&&'      => lambda { |*expr|     expr.all?{|e| evaluate(e)} },                         # ['&&', [], [], ...]
+            'and'     => lambda { |*expr|     expr.all?{|e| evaluate(e)} },                         # ['and', [], [], ...]
+            '||'      => lambda { |*expr|     expr.any?{|e| evaluate(e)} },                         # ['||', [], [], ...]
+            'or'      => lambda { |*expr|     expr.any?{|e| evaluate(e)} },                         # ['or', [], [], ...]
+            'if'      => lambda { |c, t, f|   evaluate(c) ? evaluate(t) : evaluate(f) },            # ['if', 'cond', 'true', 'false']
+            'let'     => lambda { |l, r|      @env[l] = @vars[l] = r },                             # ['let', 'n', 5]
+            'true'    => lambda { true },                                                           # ['true']
+            'false'   => lambda { false },                                                          # ['false']
+
+            'date'    => lambda { |date|      Date.strptime(date, '%Y-%m-%d') },                    # ['date', '2010-01-01']
+            'today'   => lambda { Time.now.to_date },                                               # ['today']
+            'time'    => lambda { |expr|      Time.strptime(expr, '%Y-%m-%d %H:%M:%S') },           # ['time', '2010-01-01 10:10:05']
+            'now'     => lambda { Time.now },                                                       # ['now']
+
+            'append'  => lambda { |l, r|      r.to_s + l.to_s },                                    # ['append', 'world', 'hello ']
+            'prepend' => lambda { |l, r|      l.to_s + r.to_s },                                    # ['prepend', 'hello  ', 'world']
+            'match'   => lambda { |search, subject|                                                 # ['match', /a/, 'abc']
+              search = regexp_from_string(search)
+              not search.match(subject).nil?
+            },
+            'in'      => lambda { |values, search|                                                  # ['in', '1,2,3,5..10,20..24', '@n']
+              search = search.to_s.strip
+              values.split(',').each do |e|
+                if e.index('..')
+                  bounds = e.strip.split('..')
+                  return true if (bounds.first.strip..bounds.last.strip).include?(search)
+                end
+                return true if e.strip == search
+              end
+              false
+            },
+            'within'  => lambda { |values, search|                                                 # ['within', '0..3', '@n']
+              bounds = values.split('..').map{|d| Integer(d)}
+              (bounds.first..bounds.last).include?(search)
+            },
+            'replace' => lambda { |search, replace, subject|                                       # ['replace', '/^a/', 'v', 'abc']
+                                                                                                   # handle regular expression
+              if /\/i$/.match(search)
+                replace = replace.gsub(/\$(\d+)/, '\\\\\1') # for compatibility with Perl notation
+              end
+              search = regexp_from_string(search)
+              subject.gsub(search, replace)
+            },
+            'count'   => lambda { |list|                                                          # ['count', '@genders']
+              (list.is_a?(String) ? vars[list] : list).count
+            },
+            'all'     => lambda { |list, value|                                                   # ['all', '@genders', 'male']
+              list = (list.is_a?(String) ? vars[list] : list)
+              list.is_a?(Array) ? list.all?{|e| e == value} : false
+            },
+            'any'     => lambda { |list, value|                                                   # ['any', '@genders', 'female']
+              list = (list.is_a?(String) ? vars[list] : list)
+              list.is_a?(Array) ? list.any?{|e| e == value} : false
+            },
+        }
+      end
+
+      def regexp_from_string(str)
+        return Regexp.new(/#{str}/) unless /^\//.match(str)
+
+        str = str.gsub(/^\//, '')
+
+        if /\/i$/.match(str)
+          str = str.gsub(/\/i$/, '')
+          return Regexp.new(/#{str}/i)
+        end
+
+        str = str.gsub(/\/$/, '')
+        Regexp.new(/#{str}/)
+      end
+
+      def reset!
+        @vars.each do |var|
+          @env.delete(var)
+        end
+        @vars = {}
+      end
+
+      def apply(fn, args)
+        raise "undefined symbols #{fn}" unless @env.keys.include?(fn)
+        @env[fn].call(*args)
+      end
+
+      def evaluate(expr)
+        if @env['atom'].call(expr)
+          return @env[expr] if @env[expr]
+          return expr
+        end
+
+        fn = expr[0]
+        args = expr.drop(1)
+
+        unless ['quote', 'car', 'cdr', 'cond', 'if', '&&', '||', 'and', 'or', 'true', 'false', 'let', 'count', 'all', 'any'].member?(fn)
+          args = args.map { |a| self.evaluate(a) }
+        end
+        apply(fn, args)
+      end
+    end
+
+  end
+end