society 1.1.1 → 1.2.0

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: society
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Coraline Ada Ehmke
-- Kerri Miller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-08 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -109,20 +108,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -193,10 +178,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Social graph for Ruby objects
+description: Social graph for Ruby objects. Based on an original idea by Kerri Miller.
 email:
 - coraline@instructure.com
-- kerrizor@gmail.com
 executables:
 - society
 extensions: []
@@ -214,11 +198,8 @@ files:
 - bin/society
 - bower.json
 - lib/society.rb
-- lib/society/association_processor.rb
 - lib/society/cli.rb
-- lib/society/clusterer.rb
 - lib/society/edge.rb
-- lib/society/formatter/graph/json.rb
 - lib/society/formatter/report/html.rb
 - lib/society/formatter/report/json.rb
 - lib/society/formatter/report/templates/components/.gitignore
@@ -226,26 +207,19 @@ files:
 - lib/society/formatter/report/templates/components/society-assets/society.css
 - lib/society/formatter/report/templates/components/society-assets/society.js
 - lib/society/formatter/report/templates/index.htm.haml
+- lib/society/node.rb
 - lib/society/object_graph.rb
 - lib/society/parser.rb
-- lib/society/reference_processor.rb
 - lib/society/version.rb
 - society.gemspec
-- society_graph.json
-- spec/association_processor_spec.rb
 - spec/cli_spec.rb
-- spec/clusterer_spec.rb
-- spec/fixtures/clustering/clusterer_fixtures.rb
-- spec/fixtures/clustering/edges_1.txt
 - spec/fixtures/for_parser_spec/whaler.rb
-- spec/formatter/graph/json_spec.rb
 - spec/formatter/report/html_spec.rb
 - spec/formatter/report/json_spec.rb
 - spec/object_graph_spec.rb
 - spec/parser_spec.rb
-- spec/reference_processor_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/Bantik/society
+homepage: https://github.com/CoralineAda/society
 licenses:
 - MIT
 metadata: {}
@@ -270,16 +244,10 @@ signing_key:
 specification_version: 4
 summary: Social graph for Ruby objects
 test_files:
-- spec/association_processor_spec.rb
 - spec/cli_spec.rb
-- spec/clusterer_spec.rb
-- spec/fixtures/clustering/clusterer_fixtures.rb
-- spec/fixtures/clustering/edges_1.txt
 - spec/fixtures/for_parser_spec/whaler.rb
-- spec/formatter/graph/json_spec.rb
 - spec/formatter/report/html_spec.rb
 - spec/formatter/report/json_spec.rb
 - spec/object_graph_spec.rb
 - spec/parser_spec.rb
-- spec/reference_processor_spec.rb
 - spec/spec_helper.rb

data/lib/society/association_processor.rb

@@ -1,206 +0,0 @@
-module Society
-
-  class AssociationProcessor
-
-    ACTIVE_MODEL_ASSOCIATIONS = %w[belongs_to has_one has_many has_and_belongs_to_many]
-
-    attr_reader :classes, :associations, :unresolved_associations
-
-    def initialize(classes)
-      @classes = classes
-      process
-    end
-
-    private
-
-    def process
-      default_resolver = DefaultResolver.new(classes)
-      through_resolver = ThroughResolver.new(classes)
-      poly_resolver = PolymorphicResolver.new(default_resolver)
-
-      classes.each do |klass|
-        klass.macros.select do |macro|
-          ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name)
-          # TODO: make sure macro.target is 'self' (it pretty much always will be)
-        end.each do |association|
-          through_resolver.process(association, klass) or
-            poly_resolver.process(association, klass) or
-            default_resolver.process(association, klass)
-        end
-      end
-
-      @associations = default_resolver.associations
-      @unresolved_associations = default_resolver.unresolved_associations
-
-      @associations.concat(poly_resolver.associations).concat(through_resolver.associations)
-      @unresolved_associations.concat(through_resolver.unresolved_associations)
-    end
-
-
-    class ThroughResolver
-
-      attr_reader :associations, :unresolved_associations
-
-      def initialize(classes)
-        @classes = classes
-        @my_own_default_resolver = DefaultResolver.new(classes)
-        @associations = []
-        @unresolved_associations = []
-      end
-
-      def process(association, klass)
-        return false unless thru = through_of(association)
-
-        if source_type = association.arguments.last.to_hash[:source_type]
-          target = @classes.detect { |cls| cls.full_name == source_type }
-        else
-          joiner = klass.macros.detect do |macro|
-            ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name) && macro.arguments.first.value == thru
-          end
-          joining_class_entities = @my_own_default_resolver.all_classes_for(joiner)
-
-          source_str = source_of(association).to_s
-
-          target = joining_class_entities.reduce(nil) do |_,cls|
-            assoc = find_association_in(cls, source_str)
-            break @my_own_default_resolver.process(assoc, cls) if assoc
-          end
-        end
-
-        if target
-          @associations << Edge.new(from: klass,
-                                    to: target,
-                                    meta: {
-                                      type: :through_association,
-                                      macro: association })
-        else
-          @unresolved_associations << { class: klass,
-                                        macro: association,
-                                        thru_macro: joiner,
-                                        joining_classes: joining_class_entities }
-        end
-        true
-      end
-
-      private
-
-      def find_association_in(klass, name)
-        klass.macros.detect do |macro|
-          ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name) &&
-            macro.arguments.first.value.to_s.singularize == name.singularize
-        end
-      end
-
-      def through_of(association)
-        last_arg = association.arguments.last
-        last_arg.is_a?(Analyst::Entities::Hash) && last_arg.to_hash[:through]
-      end
-
-      def source_of(association)
-        association.arguments.last.to_hash[:source] || association.arguments.first.value
-      end
-
-    end
-
-
-    class DefaultResolver
-
-      attr_reader :associations, :unresolved_associations
-
-      def initialize(classes)
-        @classes = classes
-        @associations = []
-        @unresolved_associations = []
-      end
-
-      def process(association, klass)
-        if target = all_classes_for(association).first
-          @associations << Edge.new(from: klass,
-                                    to: target,
-                                    meta: {
-                                      type: :association,
-                                      macro: association })
-        else
-          @unresolved_associations << { class: klass,
-                                        target_name: target_class_name_for(association),
-                                        macro: association }
-        end
-        target
-      end
-
-      def all_classes_for(association)
-        target_name = target_class_name_for(association)
-        classes.select { |klass| klass.full_name == target_name }
-      end
-
-      private
-
-      attr_reader :classes
-
-      def target_class_name_for(association)
-        last_arg = association.arguments.last
-        if last_arg.is_a? Analyst::Entities::Hash
-          target_name = last_arg.to_hash[:class_name]
-        end
-        target_name ||= association.arguments.first.value.to_s.pluralize.classify
-      end
-
-    end
-
-
-    class PolymorphicResolver
-
-      def initialize(default_resolver)
-        @default_resolver = default_resolver
-        @polymorphics = []
-        @ases = []
-      end
-
-      # stores off any `polymorphic: true` or `as: :something` associations for
-      # later processing. also does default processing on `as: :something`
-      # associations. returns true iff association requires no further processing.
-      def process(association, klass)
-        last_arg = association.arguments.last
-        return false unless last_arg.is_a?(Analyst::Entities::Hash)
-
-        opts = last_arg.to_hash
-        if opts.key? :polymorphic
-          @polymorphics << { class: klass,
-                            key: association.arguments.first.value,
-                            macro: association }
-          return true
-
-        elsif opts.key? :as
-          if target = @default_resolver.process(association, klass)
-            @ases << { class: klass, target: target,
-                      macro: association, key: opts[:as] }
-          end
-          return true
-        end
-
-        false
-      end
-
-      def associations
-        associations = []
-        @polymorphics.each do |poly|
-          matching = @ases.select do |as|
-            as[:key] == poly[:key] && as[:target] == poly[:class]
-          end
-          matching.each do |as|
-            associations << Edge.new(from: poly[:class],
-                                      to: as[:class],
-                                      meta: {
-                                        type: :polymorphic_association,
-                                        macro: poly[:macro],
-                                        complement: as[:macro] })
-          end
-        end
-        associations
-      end
-    end
-
-  end
-
-end
-

data/lib/society/clusterer.rb

@@ -1,188 +0,0 @@
-# This file has been translated from the `minimcl` perl script, which was
-# sourced from the MCL-edge library, release 14-137. The homepage for MCL-edge
-# is http://micans.org/mcl
-#
-# The original copyright for `minimcl` is as follows:
-#
-#   (C) Copyright 2006, 2007, 2008, 2009 Stijn van Dongen
-#
-#   This file is part of MCL.  You can redistribute and/or modify MCL under the
-#   terms of the GNU General Public License; either version 3 of the License or
-#   (at your option) any later version.  You should have received a copy of the
-#   GPL along with MCL, in the file COPYING.
-
-module Society
-  class Clusterer
-
-    def initialize(params={})
-      @params = DEFAULT_PARAMS.merge(params)
-    end
-
-    # returns an array of arrays of nodes
-    def cluster(graph)
-      m = matrix_from(graph)
-      clusters = mcl(m)
-      clusters.map { |index, members| members.keys }
-              .sort_by(&:size).reverse
-    end
-
-    private
-
-    attr_reader :params
-
-    DEFAULT_PARAMS = {
-      inflation: 2.0
-    }
-
-    # TODO: "weights" are ignored right now, but soon will be an attribute of
-    #       the edge
-    def matrix_from(graph)
-      matrix = SparseMatrix.new
-      graph.edges.each do |edge|
-        a = edge.from
-        b = edge.to
-        matrix[a][b] = 1
-        matrix[b][a] = 1
-      end
-      matrix
-    end
-
-    def mcl(matrix)
-      matrix_add_loops(matrix)
-      matrix_make_stochastic(matrix)
-      chaos = 1.0
-      while (chaos > 0.001) do
-        sq = matrix_square(matrix)
-        chaos = matrix_inflate(sq)
-        matrix = sq
-      end
-      matrix_interpret(matrix)
-    end
-
-    def matrix_square(matrix)
-      squared = SparseMatrix.new
-      matrix.each do |node, vector|
-        squared[node] = matrix_multiply_vector(matrix, vector)
-      end
-      squared
-    end
-
-    def matrix_multiply_vector(matrix, vector)
-      result_vec = SparseVector.new
-      vector.each do |entry, val|
-        matrix[entry].each do |f, matrix_val|
-          result_vec[f] += val * matrix_val
-        end
-      end
-      result_vec
-    end
-
-    def matrix_make_stochastic(matrix)
-      matrix_inflate(matrix, 1)
-    end
-
-    def matrix_add_loops(matrix)
-      matrix.each do |key,_|
-        matrix[key][key] = 1.0
-        matrix[key][key] = vector_max(matrix[key])
-      end
-    end
-
-    def vector_max(vector)
-      vector.values.max || 0.0
-    end
-
-    def vector_sum(vector)
-      vector.values.reduce(&:+) || 0.0
-    end
-
-    # prunes small elements as well
-    def matrix_inflate(matrix, inflation = params[:inflation])
-      chaos = 0.0
-      matrix.each do |node, vector|
-        sum = 0.0
-        sumsq = 0.0
-        max = 0.0
-        vector.each do |node2, value|
-          vector.delete node2 and next if value < 0.00001
-
-          inflated = value ** inflation
-          vector[node2] = inflated
-          sum += inflated
-        end
-        if sum > 0.0
-          vector.each do |node2, value|
-            vector[node2] /= sum
-            sumsq += vector[node2] ** 2
-            max = [vector[node2], max].max
-          end
-        end
-        chaos = [max - sumsq, chaos].max
-      end
-      chaos  # only meaningful if input is stochastic
-    end
-
-    # assumes but does not check doubly idempotent matrix.
-    # can handle attractor systems of size < 10.
-    # recognizes/preserves overlap.
-    def matrix_interpret(matrix)
-      clusters = SparseMatrix.new
-      attrid = {}
-      clid = 0
-
-      # crude removal of small elements
-      matrix.each do |n, vec|
-        vec.each do |nb, val|
-          matrix[n].delete nb if val < 0.1
-        end
-      end
-
-      attr = {}
-      matrix.each_key do |key|
-        attr[key] = 1 if matrix[key].key? key
-      end
-
-      attr.each_key do |a|
-        next if attrid.key?(a)
-        aa = [a]
-        while aa.size > 0 do
-          bb = []
-          aa.each do |aaa|
-            attrid[aaa] = clid
-            matrix[aaa].each_key { |akey| bb.push(akey) if attr.key? akey }
-          end
-          aa = bb.select { |b| !attrid.key?(b) }
-        end
-        clid += 1
-      end
-
-      matrix.each do |n, val|
-        if !attr.key?(n)
-          val.keys.select { |x| attr.key? x }.each do |a|
-            clusters[attrid[a]][n] += 1
-          end
-        else
-          clusters[attrid[n]][n] += 1
-        end
-      end
-
-      clusters
-    end
-
-
-    module SparseMatrix
-      def self.new
-        Hash.new do |hash, key|
-          hash[key] = SparseVector.new
-        end
-      end
-    end
-
-    module SparseVector
-      def self.new
-        Hash.new(0.0)
-      end
-    end
-  end
-end
-