xbrlware-ruby19 1.1.2.19

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xbrlware-ruby19.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jim Lindstrom
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,4 @@
+# Xbrlware-ruby19
+
+xbrlware-ruby19 is a re-packaging and ruby19-ification of <http://code.google.com/p/xbrlware/>, which describes itself as "a fast, lightweight framework for automation & analysis of XBRL." This repackaging carries the same Apache2.0 licensing as the original package.
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/xbrlware-ruby19/cgi_patch.rb

@@ -0,0 +1,58 @@
+# This patch is to fix a bug in Ruby 1.8.x CGI::unescapeHTML
+# Till we upgrade to Ruby 1.9, we will use this patch. Ruby 1.9 handles it properly.
+# Other alternative is using htmlentities - http://htmlentities.rubyforge.org/
+#
+# Bug explanation,
+# CGI::unescapeHTML("Equity in Earnings of") returns "Equity in Earnings\240of" instead of "Equity in Earnings of"
+# CGI::unescapeHTML is not handling HTML numbers bigger than ~
+#
+# Fix explanation
+# If HTML number is bigger than ~ treat them as   (32 is for space)
+
+# below method copied from ruby-1.8.7-p248, ruby 1.8.7 (2009-12-24 patchlevel 248) for patching.
+
+
+#class CGI
+#  # Unescape a string that has been HTML-escaped
+#  #   CGI::unescapeHTML("Usage: foo "bar" <baz>")
+#  #      # => "Usage: foo \"bar\" <baz>"
+#  def CGI::unescapeHTML(string)
+#    string.gsub(/&(amp|quot|gt|lt|\#[0-9]+|\#x[0-9A-Fa-f]+);/n) do
+#      match = $1.dup
+#      case match
+#        when 'amp' then
+#          '&'
+#        when 'quot' then
+#          '"'
+#        when 'gt' then
+#          '>'
+#        when 'lt' then
+#          '<'
+#        when /\A#0*(\d+)\z/n then
+#          if Integer($1) < 256
+#            32.chr if Integer($1) > 126 
+#            Integer($1).chr if Integer($1) <= 126
+#          else
+#            if Integer($1) < 65536 and ($KCODE[0] == ?u or $KCODE[0] == ?U)
+#              [Integer($1)].pack("U")
+#            else
+#              "&##{$1};"
+#            end
+#          end
+#        when /\A#x([0-9a-f]+)\z/ni then
+#          if $1.hex < 128
+#            $1.hex.chr
+#          else
+#            if $1.hex < 65536 and ($KCODE[0] == ?u or $KCODE[0] == ?U)
+#              [$1.hex].pack("U")
+#            else
+#              "&#x#{$1};"
+#            end
+#          end
+#        else
+#          "&#{match};"
+#      end
+#    end
+#  end
+#
+#end

data/lib/xbrlware-ruby19/constants.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+#
+# Author:: xbrlware@bitstat.com
+#
+# Copyright:: 2009, 2010 bitstat (http://www.bitstat.com). All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+module Xbrlware
+  # Linkbase constants
+  module LBConstants
+    CALCULATION="http://www.xbrl.org/2003/role/calculationLinkbaseRef"
+    DEFINITION="http://www.xbrl.org/2003/role/definitionLinkbaseRef"
+    PRESENTATION="http://www.xbrl.org/2003/role/presentationLinkbaseRef"
+    LABEL="http://www.xbrl.org/2003/role/labelLinkbaseRef"
+    REFERENCE="http://www.xbrl.org/2003/role/referenceLinkbaseRef"
+  end
+end

data/lib/xbrlware-ruby19/context.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/ruby
+#
+# Author:: xbrlware@bitstat.com
+#
+# Copyright:: 2009, 2010 bitstat (http://www.bitstat.com). All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+module Xbrlware
+  # This class represents each context in the XBRL instance file.
+  # Look at {delaing with instance page on xbrlware wiki}[http://code.google.com/p/xbrlware/wiki/InstanceTaxonomy] for more details.
+  class Context
+    include NSAware
+    
+    attr_reader :id, :entity, :period, :scenario
+    PERIOD_FOREVER = -1
+
+    class Period
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        @value.to_s
+      end
+
+      def eql?(o)
+        o.is_a?(Period) && @value == o.value
+      end
+
+      def hash
+        @value.hash
+      end
+
+      def is_instant?
+        @value.is_a?(Date)
+      end
+
+      def is_duration?
+        @value.is_a?(Hash)
+      end
+
+      def is_forever?
+        @value.is_a?(Fixnum)
+      end
+    end
+
+    def initialize(id, entity, period, scenario=nil)
+      @id = id
+      @entity = entity
+      @period = Period.new(period)
+      @scenario=scenario
+    end
+
+    def has_scenario?
+      (not @scenario.nil?)
+    end
+
+    def to_s
+      "Id [" + id + "], Entity { " + @entity.to_s + " },  period ["+period.to_s+"]"+ (",  scenario ["+scenario+"]" unless scenario.nil?).to_s
+    end
+
+    def eql?(o)
+      o.is_a?(Context) && @id == o.id
+    end
+
+    def hash
+      @id.hash
+    end
+
+    def has_explicit_dimensions?(dimensions=[])
+      return @entity.has_explicit_dimensions?(dimensions) unless @entity.nil?
+      false
+    end
+
+    alias_method :has_dimensions?, :has_explicit_dimensions?
+
+    def explicit_dimensions
+      return @entity.explicit_dimensions
+    end
+
+    alias_method :dimensions, :explicit_dimensions
+
+    def explicit_domains(dimensions=[])
+      return @entity.explicit_domains(dimensions)
+    end
+
+    alias_method :domains, :explicit_domains
+
+    def explicit_dimensions_domains
+      return @entity.explicit_dimensions_domains
+    end
+
+    alias_method :dimensions_domains, :explicit_dimensions_domains
+
+  end
+
+  class Entity
+    attr_reader :identifier, :segment
+
+    def initialize(identifier, segment=nil)
+      @identifier = identifier
+      @segment = segment
+    end
+
+    def has_segment?
+      (not @segment.nil?)
+    end
+
+    def to_s
+      "Identifier { " + @identifier.to_s + " } " + (", segment [" + segment.to_s + "]" unless segment.nil?).to_s
+    end
+
+    def has_explicit_dimensions?(dimensions=[])
+      dimensions_set=Set.new
+      dimensions_set.merge(dimensions)
+      unless @segment.nil? || @segment["explicitMember"].nil?
+
+        return true if dimensions.size==0
+
+        dim = Set.new
+        @segment["explicitMember"].each do |member|
+          dim << member["dimension"]
+        end
+        return dim.superset?(dimensions_set)
+      end
+
+      return false
+    end
+
+    def explicit_dimensions
+      dim = Set.new
+      unless @segment.nil? || @segment["explicitMember"].nil?
+        @segment["explicitMember"].each do |member|
+          dim << member["dimension"]
+        end
+      end
+      return dim.to_a
+    end
+
+    def explicit_domains(dimensions=[])
+      dom = Set.new
+      if has_explicit_dimensions?(dimensions)
+        @segment["explicitMember"].each do |member|
+          dimensions=explicit_dimensions if dimensions.size==0
+          dimensions.each do |dim|
+            next unless dim==member["dimension"]
+            dom << member["content"]
+          end
+        end
+      end
+      return dom.to_a
+    end
+
+    def explicit_dimensions_domains
+      dim_dom={}
+      if has_explicit_dimensions?
+        @segment["explicitMember"].each do |member|
+          dim_dom[member["dimension"]]=[] if dim_dom[member["dimension"]].nil?
+          dim_dom[member["dimension"]] << member["content"]
+        end
+      end
+      return dim_dom
+    end
+
+  end
+
+  class Identifier
+    attr_reader :value, :scheme
+
+    def initialize(scheme, value)
+      @scheme = scheme
+      @value = value
+    end
+
+    def to_s
+      "schema [" + @scheme.to_s + "], value [" + @value.to_s + "]"
+    end
+  end
+end

data/lib/xbrlware-ruby19/date_util.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/ruby
+#
+# Author:: xbrlware@bitstat.com
+#
+# Copyright:: 2009, 2010 bitstat (http://www.bitstat.com). All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+module Xbrlware
+  module DateUtil # :nodoc:
+    def self.stringify_date (date)
+      return "" if date.nil?
+      begin
+        _date=Date.parse(date) if date.is_a?(String)
+        _date=date if date.is_a?(Date)
+        m=Date::ABBR_MONTHNAMES[_date.month]
+        m + " " + _date.day.to_s + ", " + _date.year.to_s
+      rescue Exception => e
+        ""
+      end
+    end
+
+    def self.months_between(date1=Date.today, date2=Date.today)
+      begin
+        date1=Date.parse(date1) if date1.is_a?(String)
+        date2=Date.parse(date2) if date2.is_a?(String)
+        (date1 > date2) ? (recent_date, past_date = date1, date2) : (recent_date, past_date = date2, date1)
+        (recent_date.year - past_date.year) * 12 + (recent_date.month - past_date.month) + 1
+      rescue Exception => e
+        0
+      end
+    end
+  end
+end

data/lib/xbrlware-ruby19/float_patch.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby
+#
+# Author:: xbrlware@bitstat.com
+#
+# Copyright:: 2009, 2010 bitstat (http://www.bitstat.com). All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+class Float # :nodoc:
+  def round_at(precision)
+    (self * (10 ** precision)).round.to_f / 10 ** precision
+  end
+end
+
+ 

data/lib/xbrlware-ruby19/hash_util.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/ruby
+#
+# Author:: xbrlware@bitstat.com
+#
+# Copyright:: 2009, 2010 bitstat (http://www.bitstat.com). All Rights Reserved.
+#
+# License:: Licensed under the Apache License, Version 2.0 (the "License");
+#           you may not use this file except in compliance with the License.
+#           You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#           Unless required by applicable law or agreed to in writing, software
+#           distributed under the License is distributed on an "AS IS" BASIS,
+#           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#           implied.
+#           See the License for the specific language governing permissions and
+#           limitations under the License.
+#
+module Xbrlware
+  module HashUtil # :nodoc:
+    def self.to_obj(hash)
+      o = Object.new()
+      hash.each do |k, v|
+        v=self.to_obj(v) if v.is_a?(Hash)
+        MetaUtil::introduce_instance_var(o, k, v)
+      end
+      return o
+    end
+
+    # In Ruby 1.9, the Hash is ordered by default.
+    if RUBY_VERSION >= '1.9'
+      OHash = ::Hash
+    else
+      class OHash < Hash #:nodoc:
+        def initialize(*args, &block)
+          super
+          @keys = []
+        end
+
+        def self.[](*args)
+          ordered_hash = new
+
+          if (args.length == 1 && args.first.is_a?(Array))
+            args.first.each do |key_value_pair|
+              next unless (key_value_pair.is_a?(Array))
+              ordered_hash[key_value_pair[0]] = key_value_pair[1]
+            end
+
+            return ordered_hash
+          end
+
+          unless (args.size % 2 == 0)
+            raise ArgumentError.new("odd number of arguments for Hash")
+          end
+
+          args.each_with_index do |val, ind|
+            next if (ind % 2 != 0)
+            ordered_hash[val] = args[ind + 1]
+          end
+
+          ordered_hash
+        end
+
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
+        end
+
+        def []=(key, value)
+          @keys << key if !has_key?(key)
+          super
+        end
+
+        def keys
+          @keys.dup
+        end
+
+        def values
+          @keys.collect { |key| self[key] }
+        end
+
+        def delete(key)
+          if has_key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
+
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
+
+        def reject!
+          super
+          sync_keys!
+          self
+        end
+
+        def reject(&block)
+          dup.reject!(&block)
+        end
+
+        def to_hash
+          self
+        end
+
+        def to_a
+          @keys.map { |key| [ key, self[key] ] }
+        end
+
+        def each_key
+          @keys.each { |key| yield key }
+        end
+
+        def each_value
+          @keys.each { |key| yield self[key]}
+        end
+
+        def each
+          @keys.each {|key| yield [key, self[key]]}
+        end
+
+        alias_method :each_pair, :each
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
+
+        def merge!(other_hash)
+          other_hash.each {|k, v| self[k] = v }
+          self
+        end
+
+        def merge(other_hash)
+          dup.merge!(other_hash)
+        end
+
+        # replace with keys from other Hash. The other Hash could be ordered or not ordered.
+        def replace(other)
+          super
+          @keys = other.keys
+          self
+        end
+
+        def inspect
+          "#<OHash #{super}>"
+        end
+
+        # XmlSimple's export to xml from Hash depends on instance_of?(Hash)
+        def instance_of?(clazz)
+          self.is_a?(clazz)
+        end
+
+        private
+
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
+      end
+    end
+  end
+end