xbrlware-ruby19 1.1.2.19

data/lib/xbrlware-ruby19/linkbase/linkbase.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
+  module Linkbase
+
+    class Linkbase
+      # Creates a Linkbase.
+      #
+      # linkbase_path::
+      #   XBRL Linkbase source. Tries to load and parse linkbase from path.
+      #
+      def initialize(linkbase_path)
+        m=Benchmark.measure do
+          begin
+            @linkbase_content = XmlParser.xml_in(linkbase_path, {'ForceContent' => true})
+          rescue Exception
+            $LOG.warn "File ["+linkbase_path+"] is not well formed. Starting reparsing after removing new lines."
+            @linkbase_content = XmlParser.xml_in(File.open(linkbase_path).read.gsub("\n", ""), {'ForceContent' => true})
+          end
+        end
+        bm("Parsing [" + linkbase_path + "] took", m)
+
+        #Populate role map
+        role_map()
+      end
+
+      private
+      def role_map
+        @role_map={}
+        @linkbase_content["roleRef"].each do |role_ref|
+          href = role_ref["xlink:href"]
+          unless href.index("#").nil?
+            @role_map[role_ref["roleURI"]]= href[href.index("#")+1, href.length]
+          else
+            @role_map[role_ref["roleURI"]]=href
+          end
+        end unless @linkbase_content["roleRef"].nil?
+      end
+
+      public
+
+      def inspect
+        self.to_s
+      end
+
+      def self.wireup_relationship(map, parent, child) # :nodoc:
+
+        if child.is_a?(Array)
+          child.each do |c|
+            wireup_relationship(map, parent, c)
+          end
+          return
+        end
+
+        child.parent=parent
+        parent.children.add(child)
+        return unless map.has_key?(child)
+
+        # map contains different instance (that equals to child) as key.
+        # Delete the key, reinsert the proper instance as key  
+        children_of_child=map[child]
+        #map.delete(child)
+        map[child]=children_of_child
+        wireup_relationship(map, child, map[child])
+      end
+
+      def self.build_relationship(map) # :nodoc:
+        map.each do |key, value|
+          wireup_relationship(map, key, value)
+        end
+        root_elements=map.keys.select { |key| key.parent.nil?}
+        root_elements.each {|root_element| sort_by_order(root_element)}
+        return root_elements
+      end
+
+      def self.sort_by_order(element) # :nodoc:
+        return if element.children.nil?
+        element.children=element.children.sort_by {|e| (e.respond_to?(:order) && e.order) || "0"}
+        element.children.each do |child|
+          sort_by_order(child)
+        end
+      end
+
+      class Link
+
+        attr_reader :link_type, :title, :role, :href, :arcs
+
+        def initialize(link_type, title, role, href, arcs=nil)
+          @link_type=link_type
+          @role = role
+          @href = href
+
+          @title=title unless title.nil?
+          @title=role.split("/")[-1] if title.nil?
+          @title=@title.split(/(?=[A-Z])/).join(' ')
+          @title.gsub!(/_/, " ")
+          @title.gsub!(/[ ]+/, " ")
+
+          @arcs = arcs
+        end
+
+        private
+        def print_arc_hierarchy(verbose_flag="q", arcs=@arcs, indent=0)
+          arcs.each do |arc|
+            str=" " * indent + arc.item_name + "("+(arc.label if arc.respond_to?(:label)).to_s+")"
+            if verbose_flag=="v"
+              str +=" label [" +(arc.label if arc.respond_to?(:label)).to_s+"], role ["+arc.role.to_s+"]"
+            end
+            str += " order ["+arc.order.to_s+"]"
+            puts str
+            print_arc_hierarchy(verbose_flag, arc.children, indent+1) if arc.children
+          end unless arcs.nil?
+        end
+
+        public
+        def inspect
+          self.to_s
+        end
+
+        def print(verbose_flag="q")
+          puts " title ["+title+"] role ["+role+"]"
+          print_arc_hierarchy(verbose_flag)
+          return self.to_s
+        end
+
+        class Arc
+          attr_reader :item_id, :item_name, :role, :label, :href, :order, :priority
+          attr_accessor :items, :children, :parent
+
+          def initialize(item_id, href, role=nil, order=nil, priority=nil, label=nil)
+            @item_id=item_id
+            @item_name = @item_id[0, (@item_id.rindex("_")==nil ? @item_id.size: @item_id.rindex("_"))]
+            @href=href
+            @role=role
+            @order=order.to_i
+            @priority=priority.to_i
+            if label.nil?
+              if href.nil?
+                dash_index=item_id.index("_")
+                dash_index=dash_index.nil? ? 0 :(dash_index+1)
+                label=item_id[dash_index, item_id.length]
+              else
+                label=href[href.index("#")+1, href.length] unless href.index("#").nil?
+                label=href if href.index("#").nil?
+                unless label.index("_").nil?
+                  dash_index=label.index("_")
+                  label=label[dash_index+1, label.length]
+                end
+              end
+            end
+            @label=label
+            @children=Set.new()
+          end
+
+          def has_children?
+            @children.size>0
+          end
+
+          def eql?(o)
+            o.is_a?(Arc) && @item_id == o.item_id
+          end
+
+          def hash
+            @item_id.hash
+          end
+
+          def inspect
+            self.to_s
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/xbrlware-ruby19/linkbase/presentation_linkbase.rb

@@ -0,0 +1,204 @@
+#!/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 Linkbase
+    class PresentationLinkbase < Linkbase
+
+      # Creates a PresentationLinkbase.
+      #
+      # linkbase_path::
+      #   XBRL Presentation Linkbase source. Tries to load and parse presentation linkbase from path.
+      #      
+      # instance::
+      #   Instance object
+      #
+      # def_linkbase::
+      #   DefinitionLinkbase object      
+      #
+      # label_linkbase::
+      #   optional parameter, LabelLinkbase object      
+      def initialize(linkbase_path, instance, def_linkbase, label_linkbase=nil)
+        super linkbase_path
+        @instance=instance
+        @def_linkbase=def_linkbase
+        @label_linkbase=label_linkbase
+        @pre_content_optimized=nil
+      end
+
+      def presentation(role=nil)
+        presentations=[]
+
+        if @pre_content_optimized.nil?
+          pre_content=@linkbase_content["presentationLink"]
+
+          @pre_content_optimized = []
+          pre_content.each_with_index do |pre, index|
+            next if pre["loc"].nil? || pre["presentationArc"].nil?
+            pre["loc"].map! do |e|
+              e["xlink:label"]="#{e['xlink:label']}_#{index}"
+              e
+            end
+
+            pre["presentationArc"].map! do |e|
+              e["xlink:from"]="#{e['xlink:from']}_#{index}"
+              e["xlink:to"]="#{e['xlink:to']}_#{index}"
+              e
+            end
+            selected=@pre_content_optimized.select {|pre_existing| pre_existing["xlink:role"]==pre["xlink:role"]}[0]
+            if selected.nil?
+              @pre_content_optimized << pre
+            else
+              pre["loc"].each do |current|
+                matched_loc=nil
+                selected["loc"].each do |existing|
+                  if existing["xlink:href"]==current["xlink:href"]
+                    matched_loc=current
+                    pre["presentationArc"].each do |arc|
+                      arc["xlink:from"] = existing["xlink:label"] if current["xlink:label"]==arc["xlink:from"]
+                      arc["xlink:to"] = existing["xlink:label"] if current["xlink:label"]==arc["xlink:to"]
+                    end
+                    break
+                  end
+                end
+                selected["loc"] << current if matched_loc.nil?
+              end
+              selected["presentationArc"] += pre["presentationArc"]
+            end
+          end
+        end
+
+        @pre_content_optimized.each do |pre|
+          next unless pre["xlink:role"]==role unless role.nil?
+
+          if pre["presentationArc"].nil?
+            presentations << Presentation.new(@instance.entity_details, pre["xlink:title"], pre["xlink:role"], @role_map[pre["xlink:role"]])
+          else
+            definition=nil
+            definition=@def_linkbase.definition(pre["xlink:role"]) unless @def_linkbase.nil?
+
+            dimensions=[]
+            dimensions = definition.dimension_domain_map.keys unless definition.nil?
+
+            contexts_and_arcs=arcs(pre, dimensions)
+            presentations << Presentation.new(@instance.entity_details, pre["xlink:title"], pre["xlink:role"], @role_map[pre["xlink:role"]], contexts_and_arcs["contexts"], contexts_and_arcs["arcs"], definition, @instance, dimensions)
+          end
+        end
+        return presentations[0] unless role.nil?
+        presentations
+      end
+
+      private
+      def fetch_label(label_name, pref_label)
+        pref_label="http://www.xbrl.org/2003/role/label" if pref_label.nil?
+        label_obj=@label_linkbase.label(label_name, pref_label)
+        label = label_obj.value unless label_obj.nil?
+        return label
+      end
+
+      def arcs(pre, dimensions=[])
+        locators={}
+        pre["loc"].each do |loc|
+          href = loc["xlink:href"]
+          unless href.index("#").nil?
+            locators[loc["xlink:label"]]= href[href.index("#")+1, href.length]
+          else
+            locators[loc["xlink:label"]]=href
+          end
+        end
+
+        arc_map={}
+
+        contexts = Set.new()
+
+        pre["presentationArc"].each do |arc|
+          from_label, to_label = nil, nil
+          unless @label_linkbase.nil?
+            to_label = fetch_label(locators[arc["xlink:to"]], arc["preferredLabel"])
+            from_label = fetch_label(locators[arc["xlink:from"]], arc["preferredLabel"])
+          end
+
+          to = Presentation::PresentationArc.new(arc["xlink:to"], locators[arc["xlink:to"]], arc["xlink:arcrole"], arc["order"], arc["priority"], arc["use"], to_label)
+          from = Presentation::PresentationArc.new(arc["xlink:from"], locators[arc["xlink:from"]], role=nil, order=nil, priority=nil, use=nil, label=from_label)
+
+          to_item_name = locators[arc["xlink:to"]].gsub(/.*_/, "")
+          from_item_name = locators[arc["xlink:from"]].gsub(/.*_/, "")
+
+          to_item_map=item_map(@instance.item(to_item_name), dimensions)
+          to.items=to_item_map.values
+          contexts.merge(to_item_map.keys)
+
+          from_item_map=item_map(@instance.item(from_item_name), dimensions)
+          from.items=from_item_map.values
+          contexts.merge(from_item_map.keys)
+
+          if arc_map.has_key?(from)
+            arc_map[from] << to
+          else
+            arc_map[from]=[to]
+          end
+        end
+        return {"contexts" => contexts, "arcs" => Linkbase.build_relationship(arc_map)}
+      end
+
+
+      private
+      def item_map(items, dimensions=[])
+        item_map={}
+        items.each do |item|
+          if dimensions.size>0
+            dims=item.context.dimensions
+            item_map[item.context]=item if (dimensions-dims).size != dimensions.size && (not item.value.nil?)
+          else
+            item_map[item.context]=item unless item.context.has_explicit_dimensions? || item.value.nil?
+          end
+        end unless items.nil?
+        item_map
+      end
+
+      public
+      class Presentation < Linkbase::Link
+
+        attr_reader :contexts, :definition, :instance, :dimensions, :entity_details
+
+        def initialize(entity_details, title, role, href=nil, contexts=nil, arcs=nil, definition=nil, instance=nil, dimensions=[])
+          super("Presentation", title, role, href, arcs)
+          @entity_details=entity_details
+          @contexts=contexts
+          @definition=definition
+          @instance=instance
+          @dimensions=dimensions
+        end
+
+        def has_dimensions?
+          return @dimensions.size>0
+        end
+
+        class PresentationArc < Linkbase::Link::Arc
+          attr_reader :use
+
+          def initialize(item_id, href, role=nil, order=nil, priority=nil, use=nil, label=nil)
+            super item_id, href, role, order, priority, label
+            @use=use
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xbrlware-ruby19/meta_util.rb

@@ -0,0 +1,50 @@
+#!/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 MetaUtil # :nodoc:
+    def self.introduce_instance_var(o, i_var_name, i_var_value)
+      o.instance_variable_set("@#{i_var_name}", i_var_value)
+      o.instance_eval %{
+            def #{i_var_name}
+              self.instance_variable_get("@#{i_var_name}")
+            end
+    }
+    end
+
+    def self.introduce_instance_writer(o, method_name, i_var_name)
+      o.instance_eval %{
+            def #{method_name}=(value)
+              self.instance_variable_set("@#{i_var_name}", value)
+            end
+    }
+    end
+
+    def self.introduce_instance_alias(o, alias_name, actual_name)
+      o.instance_eval %{
+            alias :#{alias_name} :#{actual_name}
+      }
+    end
+
+    def self.eval_on_instance(o, method_block)
+      p "#{o.class}"
+      o.instance_eval method_block
+    end
+  end
+end

data/lib/xbrlware-ruby19/ns_aware.rb

@@ -0,0 +1,5 @@
+# namespace aware
+module NSAware
+  # namespace and namespace prefix
+  attr_accessor :ns, :nsp
+end