crystal_ext 0.0.7 → 0.0.11

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
+
+Spec::Example::ExampleGroup.class_eval do
+  def self.with_http
+    Spec::Example::ExampleGroup.include Crystal::RSpecHelper
+    
+    before :each do
+      self.response = nil
+    end        
+    
+    before :all do
+      crystal.before :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
+# 
+Spec::Example::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'
+
+Spec::Example::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
+# 
+Spec::Example::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/support.rb

@@ -0,0 +1,46 @@
+require 'crystal/support/gems'
+
+
+require 'crystal/support/active_support'
+
+
+require 'ruby_ext'
+require 'vresource'
+require 'ruby_ext/open_constructor'
+require 'crystal/support/ruby_ext_with_active_support'
+
+
+require 'micon'
+Micon::Managed.hook! Module
+require 'crystal/support/micon'
+
+
+require 'facets/dictionary'
+
+
+require 'thread'
+require 'time'
+require 'uri'
+require 'json'
+
+
+require 'addressable/uri'
+require 'crystal/support/addressable'
+::Uri = Addressable::URI
+
+
+autoload :Nokogiri, 'nokogiri'
+
+
+[  
+  'module',
+  'buffered_logger',
+  'callbacks',
+  'filters',
+  'format',
+  'mime',  
+  'string',
+  'rson',
+  'exception',
+  'safe_hash'
+].each{|f| require "crystal/support/#{f}"}

data/lib/crystal/support/active_support.rb

@@ -0,0 +1,39 @@
+require 'active_support/all'
+
+# 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'
+
+
+# 
+# Hacks
+# 
+require 'crystal/support/active_support/micelaneous'

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/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