crystal 0.0.10 → 0.0.12

data/lib/crystal/spec/environment.rb

@@ -0,0 +1,41 @@
+require 'rspec_ext'
+
+RSpec::Core::ExampleGroup.class_eval do
+  def self.swap_metadata    
+    old_metadata = nil
+    
+    before :all do
+      old_metadata = Micon.metadata
+      Micon.swap_metadata old_metadata.deep_clone
+    end
+    
+    after :all do
+      Micon.swap_metadata old_metadata
+    end
+  end
+  
+  def self.with_environment environment = :test
+    swap_metadata
+    
+    before :each do    
+      crystal.clear
+      crystal[:config].environment = environment
+    end
+
+    after :each do
+      crystal.clear      
+    end    
+  end
+  
+  inject(
+    :config => :config, 
+    :logger => :logger
+  )
+  
+  def silence_logger!
+    self.logger = Logger.new nil
+  end  
+end
+
+# Spec::Runner.configure do |config|  
+# end

data/lib/crystal/spec/http.rb

@@ -0,0 +1,67 @@
+module Crystal
+  module RSpecHelper
+    attr_accessor :response, :workspace
+  end
+end
+
+Crystal::Response.class_eval do
+  inject :workspace => :workspace
+  attr_accessor :rson
+end
+
+RSpec::Core::ExampleGroup.class_eval do
+  def self.with_http
+    RSpec::Core::ExampleGroup.include Crystal::RSpecHelper
+    
+    before :each do
+      self.response = nil
+    end        
+    
+    before :all do
+      crystal.before_scope :cycle do  
+        if defined?(Crystal::Processors) and defined?(Crystal::Processors::PrepareParams)
+          crystal.conveyors.web do |web|
+            web.definitions.delete_if{|pdef, args| pdef == Crystal::Processors::PrepareParams}
+            web.build!
+          end
+        end
+      end
+    end
+  end
+  
+  def wcall *args, &block
+    # parsing arguments
+    params = args.extract_options!
+    
+    workspace_variables = {}            
+    if args.size == 1 and args.first.is_a?(String)
+      workspace_variables[:path] = args.first
+    elsif args.first.is_a?(Class) and args.size >= 2       
+      workspace_variables[:path] = '/'
+      workspace_variables[:class] = args[0]
+      workspace_variables[:method_name] = args[1].to_s    
+      if args.size > 2
+        workspace_variables.merge! args[2].symbolize_keys
+      end
+    else
+      raise "Invalid input!"
+    end
+    
+    # calling
+    self.response = Crystal::Response.new
+    workspace_variables.merge!({
+      :request => Crystal::Request.new(workspace_variables[:env] || {}),
+      :params => Crystal::Params.new(params),
+      :response => response,
+    })
+    
+    workspace = crystal.conveyors.web.call(workspace_variables, &block)    
+    
+    workspace.response.must_be.defined
+    self.response = workspace.response
+    self.response.rson = workspace.remote_result
+    self.workspace = workspace
+  
+    response
+  end
+end

data/lib/crystal/spec/mail.rb

@@ -0,0 +1,20 @@
+raise 'not finished'
+
+# 
+# Mail
+# 
+RSpec::Core::ExampleGroup.class_eval do
+  def self.with_mail
+    raise 'not implemented'
+  end
+  
+  def clear_mail      
+    # ActionMailer::Base.delivery_method = :test
+    # ActionMailer::Base.perform_deliveries = true
+    # ActionMailer::Base.deliveries = []
+  end
+
+  def sent_letters
+    # ActionMailer::Base.deliveries
+  end
+end

data/lib/crystal/spec/remote.rb

@@ -0,0 +1,9 @@
+require 'crystal/spec/environment'
+
+RSpec::Core::ExampleGroup.class_eval do
+  def rcall klass, method, params = {}      
+    crystal.conveyors.services.call(
+      :class => klass, :method_name => method.to_s, :params => Crystal::Params.new(params)
+    )
+  end
+end

data/lib/crystal/spec/view.rb

@@ -0,0 +1,10 @@
+raise 'not finished'
+
+# 
+# Routes
+# 
+RSpec::Core::ExampleGroup.class_eval do
+  def default_path
+    crystal.config.default_path!
+  end
+end

data/lib/crystal/spec/xhtml.rb

@@ -0,0 +1,33 @@
+class String
+  def to_xhtml css = nil    
+    node = Nokogiri::HTML(self)
+    unless css
+      node
+    else
+      nodes = node.css(css)
+      raise "Elements for '#{css}' CSS query not found!" if nodes.size < 1
+      raise "Found more than one elment for '#{css}' CSS query!" if nodes.size > 1
+      nodes.first
+    end
+  end
+end
+
+::Nokogiri::XML::Node.class_eval do
+  def should_be_equal_to attributes
+    attributes.stringify_keys!    
+    node_attributes = {}
+    
+    attributes.each do |k, v|
+      nv = if k == 'content'
+        self.content
+      else
+        self[k]
+      end
+      node_attributes[k] = nv
+    end
+    
+    node_attributes.should == attributes
+  end
+  
+  
+end

data/lib/crystal/spec.rb

@@ -0,0 +1,8 @@
+require 'rspec_ext'
+
+%w(
+  controller
+  environment
+  http
+  remote
+).each{|f| require "crystal/spec/#{f}"}

data/lib/crystal/support/active_support/micelaneous.rb

@@ -0,0 +1,2 @@
+# default time
+Time::DATE_FORMATS[:default] = "%Y-%m-%d %H:%M:%S"

data/lib/crystal/support/active_support.rb

@@ -1,30 +1,39 @@
-gem 'activesupport' #, '= 2.3.5'
+require 'active_support/all'
 
-# autoload :BacktraceCleaner, 'active_support/backtrace_cleaner'
-autoload :Base64, 'active_support/base64'
-autoload :BasicObject, 'active_support/basic_object'
-# autoload :BufferedLogger, 'active_support/buffered_logger'
-# autoload :Cache, 'active_support/cache'
-# autoload :Callbacks, 'active_support/callbacks'
-# autoload :Deprecation, 'active_support/deprecation'
-# autoload :Duration, 'active_support/duration'
-# autoload :Gzip, 'active_support/gzip'
-autoload :Inflector, 'active_support/inflector'
-# autoload :Memoizable, 'active_support/memoizable'
-# autoload :MessageEncryptor, 'active_support/message_encryptor'
-# autoload :MessageVerifier, 'active_support/message_verifier'
-# autoload :Multibyte, 'active_support/multibyte'
-# autoload :OptionMerger, 'active_support/option_merger'
-# autoload :OrderedHash, 'active_support/ordered_hash'
-# autoload :OrderedOptions, 'active_support/ordered_options'
-# autoload :Rescuable, 'active_support/rescuable'
-# autoload :SecureRandom, 'active_support/secure_random'
-# autoload :StringInquirer, 'active_support/string_inquirer'
-autoload :TimeWithZone, 'active_support/time_with_zone'
-autoload :TimeZone, 'active_support/values/time_zone'
-# autoload :XmlMini, 'active_support/xml_mini'
+# gem 'activesupport' #, '= 2.3.5'
+# 
+# # autoload :BacktraceCleaner, 'active_support/backtrace_cleaner'
+# autoload :Base64, 'active_support/base64'
+# # autoload :BasicObject, 'active_support/basic_object' we use our own implementation
+# 
+# # autoload :BufferedLogger, 'active_support/buffered_logger'
+# # autoload :Cache, 'active_support/cache'
+# # autoload :Callbacks, 'active_support/callbacks'
+# # autoload :Deprecation, 'active_support/deprecation'
+# # autoload :Duration, 'active_support/duration'
+# # autoload :Gzip, 'active_support/gzip'
+# autoload :Inflector, 'active_support/inflector'
+# # autoload :Memoizable, 'active_support/memoizable'
+# # autoload :MessageEncryptor, 'active_support/message_encryptor'
+# # autoload :MessageVerifier, 'active_support/message_verifier'
+# # autoload :Multibyte, 'active_support/multibyte'
+# # autoload :OptionMerger, 'active_support/option_merger'
+# # autoload :OrderedHash, 'active_support/ordered_hash'
+# # autoload :OrderedOptions, 'active_support/ordered_options'
+# # autoload :Rescuable, 'active_support/rescuable'
+# # autoload :SecureRandom, 'active_support/secure_random'
+# # autoload :StringInquirer, 'active_support/string_inquirer'
+# autoload :TimeWithZone, 'active_support/time_with_zone'
+# autoload :TimeZone, 'active_support/values/time_zone'
+# # autoload :XmlMini, 'active_support/xml_mini'
+# 
+# # require 'active_support/vendor'
+# require 'active_support/core_ext'
+# # require 'active_support/dependencies'
+# # require 'active_support/json'
 
-# require 'active_support/vendor'
-require 'active_support/core_ext'
-# require 'active_support/dependencies'
-require 'active_support/json'
+
+# 
+# Hacks
+# 
+require 'crystal/support/active_support/micelaneous'

data/lib/crystal/support/addressable.rb

@@ -0,0 +1,45 @@
+Addressable::URI.class_eval do
+  def request_uri
+    return nil if self.absolute? && self.scheme !~ /^https?$/
+    return (
+      (self.path != "" ? self.path : "/") +
+      (self.query ? "?#{self.query}" : "")
+    )
+  end
+  
+  def self.normalize_host host
+    host.gsub(/^www\./, "")
+  end
+  
+  def normalized_host
+    host ? host : host.gsub(/^www\./, '')
+  end
+
+  # Delete 'nil' keys
+  def query_values_with_skip_nil= options
+    to_delete = []
+    options.each{|k, v| to_delete << k if v.nil?}
+    to_delete.each{|k| options.delete k}    
+    
+    self.query_values_without_skip_nil = options
+  end
+  alias_method_chain :query_values=, :skip_nil
+    
+    
+  # Override original to fix:
+  # - extra '?' sign (/some_path?) if there's empty but not-nil query
+  def to_s
+    @uri_string ||= (begin
+      uri_string = ""
+      uri_string << "#{self.scheme}:" if self.scheme != nil
+      uri_string << "//#{self.authority}" if self.authority != nil
+      uri_string << self.path.to_s
+      uri_string << "?#{self.query}" unless self.query.blank?
+      uri_string << "##{self.fragment}" if self.fragment != nil
+      if uri_string.respond_to?(:force_encoding)
+        uri_string.force_encoding(Encoding::UTF_8)
+      end
+      uri_string
+    end)
+  end
+end

data/lib/crystal/support/buffered_logger.rb

@@ -0,0 +1,38 @@
+# 
+# In development mode log also to STDOUT
+# 
+ActiveSupport::BufferedLogger.class_eval do
+  def flush_with_stdout    
+    STDOUT.write(buffer.join) if crystal.include?(:config) and crystal[:config].development? and !buffer.empty?
+    flush_without_stdout
+  end
+  alias_method_chain :flush, :stdout
+  
+  def info_with_format obj
+    info_without_format(obj_to_string(obj))
+  end
+  alias_method_chain :info, :format
+  
+  def warn_with_format obj
+    warn_without_format("WARN: " + obj_to_string(obj))
+  end
+  alias_method_chain :warn, :format
+  
+  def error_with_format obj
+    error_without_format("ERROR: " + obj_to_string(obj))
+  end
+  alias_method_chain :error, :format
+  
+  protected
+    def obj_to_string obj
+      if obj.is_a? Exception
+        backtrace = (obj.backtrace && obj.backtrace.sfilter(Exception.common_filters)) || []
+        %{\
+#{obj.message}
+  #{backtrace.join("\n  ")}
+} 
+      else
+        obj.to_s
+      end
+    end
+end

data/lib/crystal/support/callbacks.rb

@@ -0,0 +1,155 @@
+module Crystal
+  module Callbacks
+    class AbstractCallback
+      attr_accessor :executor, :conditions, :terminator
+    
+      def terminate? target, result
+        unless terminator.nil?
+          if terminator.is_a? Proc
+            terminator.call target, result
+          else
+            result == terminator
+          end
+        else
+          false
+        end
+      end
+    
+      def run? target, inf
+        if cond = conditions[:if]
+          evaluate_if(cond, target, inf)
+        elsif cond = conditions[:unless]
+          !evaluate_if(cond, target, inf)
+        elsif cond = conditions[:only]
+          evaluate_only(cond, inf)
+        elsif cond = conditions[:except]
+          !evaluate_only(cond, inf)
+        else
+          true
+        end
+      end
+    
+      def add_to_chain target, inf, &the_next
+        if run? target, inf
+          build_block target, &the_next
+        else
+          the_next
+        end         
+      end
+    
+      alias_method :deep_clone, :clone
+      
+      protected
+        def evaluate_if cond, target, inf
+          if cond.string_or_symbol?
+            target.send cond
+          elsif cond.is_a? Proc
+            cond.call target, inf
+          else
+            must_be.never_called
+          end
+        end
+      
+        def evaluate_only cond, inf
+          method = inf[:method].to_s
+          if cond.string_or_symbol?
+            cond.to_s == method.to_s
+          elsif cond.is_a? Array
+            cond.include? method.to_s
+          end
+        end
+    end
+  
+    class BeforeCallback < AbstractCallback    
+      def build_block target, &the_next
+        lambda do        
+          result = if executor.string_or_symbol?
+            target.send executor
+          elsif executor.is_a? Proc
+            executor.call target
+          else
+            must_be.never_called
+          end
+
+          the_next.call unless terminate? target, result
+        end
+      end
+    end
+  
+    class AroundCallback < AbstractCallback
+      def build_block target, &the_next
+        lambda do
+          if executor.string_or_symbol?
+            target.send executor, &the_next
+          elsif executor.is_a? Proc
+            executor.call target, the_next
+          else
+            must_be.never_called
+          end
+        end      
+      end
+    end
+  
+    class AfterCallback < AbstractCallback
+      def build_block target, &the_next
+        lambda do
+          result = if executor.string_or_symbol?
+            target.send executor
+          elsif executor.is_a? Proc
+            executor.call target
+          else
+            must_be.never_called
+          end
+        
+          the_next.call unless terminate? target, result
+        end      
+      end
+    end
+  
+    def run_callbacks callback_name, additional_information = {}, &block
+      callback_name = callback_name.to_s
+      block.must_be.defined
+    
+      callbacks = self.class.callbacks[callback_name]
+      chain_head = block
+      if callbacks and !callbacks.empty?
+        callbacks.reverse_each do |callback|
+          block = callback.add_to_chain self, additional_information, &chain_head
+          chain_head = block if block
+        end
+      end
+      chain_head.call
+    end
+  
+    module ClassMethods
+      inheritable_accessor :callbacks, {}
+    
+      def set_callback callback_name, type, *executor_or_options, &block   
+        # parsing arguments
+        type, callback_name = type.to_s, callback_name.to_s
+        opt = executor_or_options.extract_options!        
+        opt = opt.symbolize_keys
+        "You can't provide both method name and block for filter!" if block and !executor_or_options.empty?
+        executor = block || executor_or_options.first
+      
+        type.must_be.in %w{before around after}
+        executor.must_be.defined
+        
+        # creating callback
+        callback = case type
+        when 'before' then BeforeCallback.new
+        when 'around' then AroundCallback.new
+        when 'after' then AfterCallback.new
+        end            
+
+        callback.executor = executor
+        callback.terminator = opt.delete :terminator
+        callback.conditions = opt
+      
+        callbacks[callback_name] ||= []
+        callbacks[callback_name] << callback
+      end
+        
+    end
+  end
+end

data/lib/crystal/support/exception.rb

@@ -0,0 +1,21 @@
+class Exception
+  class << self
+    attr_accessor :common_filters
+  end
+end
+Exception.common_filters = [
+  "/gems/haml",
+  "/gems/tilt",
+  "/gems/facets",
+  "/gems/rack",
+  "/gems/mongrel",
+  "/gems/rspec",
+  "/timeout.rb",
+  "/bin/spec",
+
+  "/monitor",
+  "/synchronize",
+  "/class_loader",
+  "/micon"
+]
+# Exception.common_filters = []

data/lib/crystal/support/filters.rb

@@ -0,0 +1,34 @@
+module Crystal
+  module Filters
+    inherit Callbacks    
+          
+    module ClassMethods
+      def before *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :before, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :before, executor, opt}        
+        end
+      end
+      
+      def around *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :around, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :around, executor, opt}        
+        end
+      end
+      
+      def after *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :after, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :after, executor, opt}        
+        end
+      end
+    end
+  end
+end

data/lib/crystal/support/format.rb

@@ -0,0 +1,9 @@
+module Crystal
+  class Format < String
+    def method_missing m
+      m = m.to_s
+      super unless m[-1..-1] == '?'
+      self == m[0..-2]
+    end
+  end
+end

data/lib/crystal/support/gems.rb

@@ -0,0 +1,12 @@
+gem 'activesupport', '>= 3.0.0'
+
+gem 'haml'
+gem 'tilt'
+gem 'facets'
+gem 'dictionary'
+gem 'json'
+gem 'addressable'
+gem 'nokogiri'
+
+gem 'rack', '>= 1.1'
+# gem 'ruby-ext'

data/lib/crystal/support/micon.rb

@@ -0,0 +1,16 @@
+module Crystal
+  class << self
+    delegate :register, :[], :[]=, :before, :after, :before_scope, :after_scope, :activate, :include?, :clear, :to => Micon
+  end
+end
+
+def crystal &block
+  
+  
+  
+  if block
+    Crystal.class_eval &block
+  else
+    Crystal
+  end
+end

data/lib/crystal/support/mime.rb

@@ -0,0 +1,11 @@
+module Mime
+  class << self
+    def method_missing m
+      self[m]
+    end
+  
+    def [] type
+      Rack::Mime.mime_type(".#{type}") || raise("Unknown MIME type: #{type}")
+    end
+  end
+end

data/lib/crystal/support/module.rb

@@ -0,0 +1,44 @@
+class Module
+  
+  # 
+  # Dynamically enables cache in :production and disables in another environments.
+  # If no environment given uses non-cached version.
+  # 
+  def cache_method_with_params_in_production method        
+    method_with_cache, method_without_cache = "#{method}_with_cache", "#{method}_without_cache"
+    iv = "@#{method}_cache"
+    
+    raise "Method '#{method}' already defined!" if instance_methods.include?(method)
+    raise "Can't cache the '#{method}' twice!" if instance_methods.include?(method_with_cache)
+        
+    # create cached method
+    define_method method_with_cache do |*args| 
+      unless results = instance_variable_get(iv)
+        results = Hash.new(NotDefined)
+        instance_variable_set iv, results
+      end
+      
+      result = results[args]
+                
+      if result.equal? NotDefined 
+        result = send als, *args
+        results[args] = result
+      end
+    
+      result
+    end
+        
+    # listen to environment events
+    crystal.after :config do |config|
+      if config.production?
+        alias_method method, method_with_cache
+      else
+        alias_method method, method_without_cache
+      end
+    end
+    
+    # by default uses non-cached version
+    alias_method method, method_without_cache
+  end
+  
+end