ironnails 0.0.1

data/lib/ironnails/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,57 @@
+# Taken from the Rails codebase. I can't require any gem atm when I can I will use their implementation.
+#
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+#
+#  class Person
+#    cattr_accessor :hair_colors
+#  end
+#
+#  Person.hair_colors = [:brown, :black, :blonde, :red]
+class Class
+
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/ironnails/core_ext/class.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/class/attribute_accessors'
+
+class Class
+
+  def demodulize
+    self.to_s.gsub(/^.*::/, '')
+  end
+end

data/lib/ironnails/core_ext/fixnum.rb

@@ -0,0 +1,22 @@
+class Fixnum
+
+  def to_timespan(as=:seconds)
+    case as
+      when :hours || :hour
+        TimeSpan.new(self, 0, 0)
+      when :minutes || :minute
+        TimeSpan.new(0, self, 0)
+      else
+        TimeSpan.new(0, 0, self)
+    end
+  end
+
+  def minutes
+    self * 60
+  end
+
+  def seconds
+    self
+  end
+
+end

data/lib/ironnails/core_ext/hash.rb

@@ -0,0 +1,32 @@
+class Hash
+
+  #returns a string of post parameters for http posts, url-encoded
+  def to_post_parameters
+    params = ""
+
+    self.each do |k, v|
+      params += "&" unless params.empty?
+      params += "#{k}=#{HttpUtility.url_encode(v.to_s.to_clr_string)}"
+    end
+
+    params
+  end
+
+  def to_s
+    res = self.collect do |k, v|
+      val = case
+        when v.is_a?(String)
+          "\"#{v}\""
+        when v.is_a?(Symbol)
+          ":#{v}"
+        else
+          "#{v}"
+      end
+      "#{k.is_a?(Symbol) ? ":#{k}" : "#{k}" } => #{val}"
+    end
+    "{ #{res.join(', ')} }"
+  end
+
+  alias_method :to_str, :to_s
+  alias_method :inspect, :to_s
+end

data/lib/ironnails/core_ext/kernel.rb

@@ -0,0 +1,26 @@
+module Kernel
+
+  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  def using(o=nil)
+    begin
+      yield if block_given?
+    ensure
+      o.dispose 
+    end
+  end
+
+
+end

data/lib/ironnails/core_ext/string.rb

@@ -0,0 +1,58 @@
+class String
+
+  # ensures that our url starts with at least http
+  def ensure_http
+    return "http://#{self}" unless /^(ht|f)tp:\/\/.*/i.match(self)
+    self
+  end
+
+  # returns whether this string is a well formed url
+  def is_url?
+    !!(Uri.is_well_formed_uri_string(self.to_clr_string, UriKind.Absolute) && /^(ht|f)tp/i.match(Uri.new(self).scheme))
+  end
+
+  def strip_html
+    self.gsub(/<(.|\n)*?>/, '')
+  end
+
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self[0...1].downcase + camelize(self)[1..-1]
+    end
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            tr("-", "_").
+            downcase
+  end
+
+  def to_clr_char
+    self.to_clr_string.to_char_array[0]
+  end
+
+  def to_secure_string
+    IronNails::Security::SecureString.secure_string self
+  end
+
+  def decrypt
+    IronNails::Security::SecureString.decrypt_string self
+  end
+
+  def classify
+    Kernel.const_get(self.camelize)
+  end
+
+  def truncate(max=140)
+    if self.size > max
+      s = self[0...max-5]
+      return s.split(' ')[0...s.split(' ').size - 1].join(' ')
+    end
+    self
+  end
+
+end

data/lib/ironnails/core_ext/symbol.rb

@@ -0,0 +1,78 @@
+class Symbol
+
+  def to_brush
+    case self
+      when :black
+        Brushes.black
+      when :white
+        Brushes.white
+      when :green
+        Brushes.green
+      when :alice_blue
+        Brushes.alice_blue
+      when :red
+        Brushes.red
+    end
+  end
+
+  def to_orientation
+    case self
+      when :horizontal
+        Orientation.horizontal
+      when :vertical
+        Orientation.vertical
+    end
+  end
+
+  def to_visibility
+    case self
+      when :visible
+        Visibility.visible
+      when :hidden
+        Visibility.hidden
+      when :collapsed
+        Visibility.collapsed
+    end
+  end
+
+  def to_vertical_alignment
+    case self
+      when :center
+        VerticalAlignment.center
+      when :top
+        VerticalAlignment.top
+      when :bottom
+        VerticalAlignment.bottom
+      when :stretch
+        VerticalAlignment.strecht
+    end
+  end
+
+  def to_horizontal_alignment
+    case self
+      when :center
+        HorizontalAlignment.center
+      when :left
+        HorizontalAlignment.left
+      when :right
+        HorizontalAlignment.right
+      when :stretch
+        HorizontalAlignment.stretch
+    end
+  end
+
+  def to_binding_mode
+    case self
+      when :default
+        BindingMode.default
+      when :one_time
+        BindingMode.one_time
+      when :one_way
+        BindingMode.one_way
+      when :one_way_to_source
+        BindingMode.one_way_to_source
+      when :two_way
+        BindingMode.two_way
+    end
+  end
+end

data/lib/ironnails/core_ext/system/net/web_request.rb

@@ -0,0 +1,110 @@
+class System::Net::WebRequest
+
+  include IronNails::Logging::ClassLogger
+
+  def prepare_for_post(parameters = {})
+
+    params = parameters.to_post_parameters
+
+    self.clr_member(:Method=).call "POST"
+    self.content_type = "application/x-www-form-urlencoded"
+    self.content_length = params.length
+
+    using (stream = StreamWriter.new(self.get_request_stream, System::Text::Encoding.ASCII)) do
+      stream.write params
+    end
+
+    params
+  end
+
+  def prepare_for_async_post(parameters = {}, &callback)
+    self.clr_member(:Method=).call "POST"
+    self.content_type = "application/x-www-form-urlencoded"
+    self.content_length = parameters.to_post_parameters.length
+
+    self.begin_get_request_stream(AsyncCallback.new {|ar| callback.call(ar) }, nil)
+  end
+
+  def perform_post( params, parse_response=nil)
+    logger.debug("IronNails: WebRequest: Performing POST to #{request_uri.to_string}")
+    self.prepare_for_post(params)
+    begin
+      res = self.get_response # we get a real HttpWebResponse back instead of the WebResponse for the C# and VB.NET users. yay for duck typing
+      unless parse_response.nil?
+        using(rdr = StreamReader.new(res.get_response_stream)) do
+          return parse_response.call(rdr)
+        end
+      else
+        return res.status_code == HttpStatusCode.OK
+      end
+    rescue WebException => e
+      handle_exception e
+    end
+    false
+  end
+
+  def perform_async_post( params, parse_response=nil, &callback)
+    logger.debug("IronNails: WebRequest: Performing asynchronous POST to #{request_uri.to_string}")
+    self.prepare_for_async_post params do |async_result|
+      using(post_stream = self.end_get_request_stream(async_result)) do
+        pars = parameters.to_post_parameters
+        post_stream.write pars.convert_to_bytes, 0, pars.size
+      end
+
+      self.begin_get_response(AsyncCallback.new { |response|
+        res = self.end_get_response response
+        using(rdr = StreamReader.new(res.get_response_stream)) do
+          parse_response.call(rdr)
+        end unless parse_response.nil?
+        callback.call res.status_code == HttpStatusCode.OK if block_given?
+      }, nil);
+    end
+  end
+
+
+  def perform_get( parse_response=nil)
+    logger.debug("IronNails: WebRequest: Performing GET to #{request_uri.to_string}")
+    begin
+      response = self.get_response
+      using(rdr = StreamReader.new(response.get_response_stream)) do
+        parse_response.call(rdr)
+      end unless parse_response.nil?
+    rescue WebException => e
+      handle_exception e
+    end
+  end
+
+  def perform_async_get( parse_response=nil, &callback)
+    logger.debug("IronNails: WebRequest: Performing asynchronous GET to #{request_uri.to_string}")
+    self.begin_get_response AsyncCallback.new{ |response|
+      begin
+        res = self.end_get_response(response)
+        using(rdr = StreamReader.new(res.get_response_stream)) do
+          obj = parse_response.call(rdr)
+          callback.call(obj) if block_given?
+        end if parse_response
+      rescue WebException => e
+        handle_exception e
+      end
+    }, nil
+  end
+
+  def handle_exception(e)
+    logger.error("ERROR: IronNails: WebRequest (#{request_uri.to_string}):\nThere was an error while executing the web request: #{e.message}")
+    status = e.status;
+    if status == WebExceptionStatus.protocol_error
+      httpResponse = e.response
+
+      case httpResponse.status_code
+        when HttpStatusCode.NotModified: # 304 Not modified = no new tweets so ignore error.
+          break;
+        when HttpStatusCode.Unauthorized: # unauthorized
+          raise SecurityException.new("Not Authorized.");
+        else
+          raise
+      end
+    else
+      raise
+    end
+  end
+end

data/lib/ironnails/core_ext/system/security/secure_string.rb

@@ -0,0 +1,18 @@
+module System
+
+  module Security
+
+    class SecureString
+
+      def to_insecure_string
+        IronNails::Security::SecureString.unsecure_string self
+      end
+
+      def encrypt
+        IronNails::Security::SecureString.encrypt_string self
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/core_ext/system/windows/markup/xaml_reader.rb

@@ -0,0 +1,6 @@
+class System::Windows::Markup::XamlReader
+
+  def self.load_from_path(path)
+    self.load XmlReader.create(path)
+  end
+end

data/lib/ironnails/core_ext/system/windows/ui_element.rb

@@ -0,0 +1,17 @@
+module System
+
+  module Windows
+
+    class UIElement
+
+      @@empty_delegate = System::Action.new { }
+      @@empty_priorty = System::Windows::Threading::DispatcherPriority.render
+
+      def refresh
+        self.dispatcher.invoke @@empty_priorty, @@empty_delegate
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/core_ext/time.rb

@@ -0,0 +1,28 @@
+require 'time'
+class Time
+
+  def humanize
+    humanized_time = ""
+    delta = Time.now - self
+    case
+      when delta <= 1
+        humanized_time = "just now"
+      when delta < 60
+        humanized_time = "#{delta.floor} seconds ago"
+      when delta < 120
+        humanized_time = "about a minute ago"
+      when delta < (45 * 60)
+        humanized_time = "#{(delta / 60).round} minutes ago"
+      when delta < (90 * 60)
+        humanized_time = "about an hour ago"
+      when delta < (86400)
+        humanized_time = "about #{(delta / 3600 ).round } hours ago"
+    when delta < (48 * 3600) 
+      humanized_time = "1 day ago"
+    else
+      humanized_time = "#{(delta / 86400).round} days ago"
+    end
+    
+    humanized_time    
+  end 
+end

data/lib/ironnails/core_ext.rb

@@ -0,0 +1,12 @@
+require 'ironnails/core_ext/array'
+require 'ironnails/core_ext/class'
+require 'ironnails/core_ext/fixnum'
+require 'ironnails/core_ext/hash'
+require 'ironnails/core_ext/kernel'
+require 'ironnails/core_ext/string'
+require 'ironnails/core_ext/symbol'
+require 'ironnails/core_ext/time'
+require 'ironnails/core_ext/system/net/web_request'
+require 'ironnails/core_ext/system/windows/markup/xaml_reader'
+require 'ironnails/core_ext/system/windows/ui_element'
+require 'ironnails/core_ext/system/security/secure_string'

data/lib/ironnails/errors.rb

@@ -0,0 +1,19 @@
+module IronNails
+
+  module Errors
+
+    class IronNailsError < StandardError
+
+
+    end
+
+    class ContractError < IronNails::Errors::IronNailsError
+
+      def initialize(method)
+        super "#{method} needs to be overridden in an implementing class"
+      end
+
+    end
+
+  end
+end

data/lib/ironnails/iron_xml.rb

@@ -0,0 +1,83 @@
+module IronNails
+
+  module Core
+
+    class IronXml
+
+      attr_reader :xml_node, :parent
+
+      def initialize(xml_doc, parent=nil)
+        @xml_node = xml_doc
+        @parent = parent
+      end
+
+      # selects multiple child nodes from the tree
+      def elements(name, &b)
+        if has_element? name
+          ele = @xml_node.select_nodes xp_pref(name)
+          ele.each do |el|
+            raise "Expected a block for multiple elements" unless block_given?
+            b.call IronXml.new(el, self) unless el.nil?
+          end
+        else
+          []
+        end
+      end
+
+      # selects a single child node from the tree
+      def element(name)
+        if has_element? name
+          ele = @xml_node.select_single_node xp_pref(name)
+          xml = IronXml.new(ele, self)
+          yield xml if block_given?
+          xml
+        end
+      end
+
+      # indicates whether the element is present in the selected nodes.
+      def has_element?(name)
+        !@xml_node.nil? && @xml_node.select_nodes("#{name}").count > 0
+      end
+
+      # the XPath prefix (rooted or not?)
+      def xp_pref(name)
+        @parent.nil? ? "//#{name}" : name
+      end
+
+      # the value of the selected node
+      def value
+        @xml_node.inner_text
+      end
+
+      # parses an xml document. +content+ can be either 
+      # a string containing xml, a path to an xml document
+      # or a System::IO::Reader. You tell IronXml which type of 
+      # content you have by passing in a +content_type+. 
+      # +content_type+ is a symbol that defaults to :string
+      # it expects a block to traverse the xml provided. 
+      def self.parse(content, content_type = :string, &b)
+        xdoc = XmlDocument.new
+
+        if content_type == :string
+          xdoc.load_xml(content)
+        else
+          xdoc.load(content)
+        end
+        b.call(IronXml.new(xdoc))
+      end
+
+      def method_missing(sym, *args, &b)
+        # this is what gives us the syntactic sugar over the 
+        # Xlinq like syntax
+        if block_given?
+          self.elements(sym.to_s, &b)
+        else
+          self.element(sym.to_s).value
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/ironnails/logger.rb

@@ -0,0 +1,4 @@
+require 'ironnails/core_ext/array'
+require 'ironnails/core_ext/class'
+require "ironnails/logging/buffered_logger"
+require "ironnails/logging/class_logger"