ptj 0.1.0

data/lib/ptj/ext.rb

@@ -0,0 +1 @@
+require 'ptj/ext/datamapper_collection'

data/lib/ptj/ext/datamapper_collection.rb

@@ -0,0 +1,74 @@
+require 'dm-core'
+
+module DataMapper
+
+  class Collection < LazyArray
+
+    def get_value(entry)
+      returned_array = []
+      self.each do |item|
+        meth = item.method(entry)
+        returned_array << meth.call()
+      end
+      returned_array
+    end
+  
+    def analyze_and_sort
+      b = Hash.new(0)
+      self.each do |item|
+        meth = item.method(entry)
+        b[meth.call()] += 1
+      end
+      b = b.sort_by { |k,v| -1*v }
+      b
+    end
+
+    def analyze
+      h = Hash.new(0)
+      self.each { | v | h.store(v, h[v]+1) }
+      h
+    end
+
+    def sort_by_occurance(entry)
+      returned_array = []
+      sorted_array = self.analyze_and_sort(entry)
+      sorted_array.each do |smaller_array|
+        returned_array << smaller_array[0]
+      end
+      returned_array
+    end
+
+  end
+end
+
+class Array
+  def analyze
+    h = Hash.new(0)
+    self.each { | v | h.store(v, h[v]+1) }
+    h
+  end
+
+  def analyze_and_sort
+    b = Hash.new(0)
+    self.each { | v | b.store(v, b[v]+1) }
+    b = b.sort_by { |k,v| -1*v }
+    b
+  end
+
+  def analyze_and_sort_key
+    b = Hash.new(0)
+    self.each { | v | b.store(v, b[v]+1) }
+    b = b.sort_by { |k,v| k }
+    b
+  end
+end
+
+
+module Kernel
+  def Boolean(string)
+    return true if string== true || string =~ (/(true|t|yes|y|1)$/i)
+    return false if string== false || string.nil? || string =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{string}\"")
+  end
+end
+

data/lib/ptj/model.rb

@@ -0,0 +1,65 @@
+require 'dm-core'
+require 'dm-types'
+require 'dm-migrations'
+require 'dm-transactions'
+require 'dm-validations'
+require 'dm-serializer'
+require 'dm-timestamps'
+require 'dm-aggregates'
+
+
+require 'ptj/environment'
+
+module PTJ
+
+  module Model
+    module FixtureTable
+      def fixture_table?
+        true
+      end
+    end
+
+  
+    require 'ptj/model/password'
+    require 'ptj/model/tag'
+
+    # Sets up the model using with the currently configured db_conn 
+    # configuration.
+    def self.setup!
+      DataMapper::Logger.new($stdout, :debug) if Env::CONFIG[Env::KEY_DEBUG]
+      DataMapper.setup(:default, Env::CONFIG[Env::KEY_DB_CONN])
+      DataMapper.finalize
+      @setup = true
+    end
+
+    # @return True,False
+    #   Indicates whether the the model has been set up yet with the 
+    #   setup! method.
+    def self.setup?
+      @setup == true
+    end
+
+    # Updates the model schema in the current database.
+    # 
+    # @return Object
+    #   Returns the return value from DataMapper.auto_upgrade!
+    def self.migrate_all!
+      setup! unless setup?
+      # use a non-destructive schema migration across the whole model
+      ret=DataMapper.auto_upgrade!
+      @migrated = true
+      return ret
+    end
+
+    # @return True,False
+    #   Indicates whether the current model has been migrated 
+    #   (via auto_upgrade).
+    def self.migrated?
+      @migrated == true
+    end
+
+  end
+end
+
+
+

data/lib/ptj/model/password.rb

@@ -0,0 +1,116 @@
+
+module PTJ
+
+  class Password
+    include DataMapper::Resource
+    include Model::FixtureTable
+
+    # id value for every entry
+    property :id,         Serial
+
+    # password
+    property :password,    String, :required => true
+
+    # hash of password
+    property :pw_hash,         String
+
+    # time this was added to database
+    property :created_at,          DateTime, :writer => :private
+
+    # upper-case letters in password
+    property :upper,         Boolean,
+      :default => lambda{|this,p| self.classify_passwords(this.password)[:upper] }
+
+    # lower-case letters in password
+    property :lower,         Boolean,
+      :default => lambda{|this,p| self.classify_passwords(this.password)[:lower] }
+
+    # numbers in password
+    property :number,         Boolean,
+      :default => lambda{|this,p| self.classify_passwords(this.password)[:number] }
+
+    # special characters in password
+    property :special,         Boolean,
+      :default => lambda{|this,p| self.classify_passwords(this.password)[:special] }
+
+    # length of the password
+    property :size,         Integer,
+      :default => lambda{|this,p| this.password.size }
+
+    # Tags associated with a sample
+    has n, :tags, :through => Resource
+
+    # Classify an individual password based on the levels of complexities 
+    # present. 
+    #
+    # @param pass
+    #   Password to classify.
+    #
+    # @return Hash
+    #   :lower => value, :upper => value, :special => value, :number => value
+    def self.classify_passwords(pass)
+      pass = pass.to_s
+      lower = false
+      upper = false
+      special = false
+      number = false
+
+      case pass
+      when /^[a-z]+$/
+        lower = true
+      when /^[^a-zA-Z0-9]+$/
+        special = true
+      when /^[A-Z]+$/
+        upper = true 
+      when /^[0-9]+$/
+        number = true
+      when /^([a-zA-Z]*([a-z]+[A-Z]+|[A-Z]+[a-z]+)[a-zA-Z]*)$/
+        lower = upper = true
+      when /^([a-z0-9]*([a-z]+[0-9]+|[0-9]+[a-z]+)[a-z0-9]*)$/
+        lower = number = true
+      when /^(([a-z]|[^a-zA-Z0-9])*([a-z]+[^a-zA-Z0-9]+|[^a-zA-Z0-9]+[a-z]+)([a-z]|[^a-zA-Z0-9])*)$/
+        lower = special = true
+      when /^([0-9A-Z]*([0-9]+[A-Z]+|[A-Z]+[0-9]+)[0-9A-Z]*)$/
+        upper = number = true
+      when /^(([A-Z]|[^a-zA-Z0-9])*([A-Z]+[^a-zA-Z0-9]+|[^a-zA-Z0-9]+[A-Z]+)([A-Z]|[^a-zA-Z0-9])*)$/
+        upper = special = true
+      when /^(([0-9]|[^a-zA-Z0-9])*([0-9]+[^a-zA-Z0-9]+|[^a-zA-Z0-9]+[0-9]+)([0-9]|[^a-zA-Z0-9])*)$/
+        number = special = true
+      when /^([a-zA-Z0-9]*([a-z]+[A-Z]+[0-9]+|[a-z]+[0-9]+[A-Z]+|[A-Z]+[a-z]+[0-9]+|[A-Z]+[0-9]+[a-z]+|[0-9]+[A-Z]+[a-z]+|[0-9]+[a-z]+[A-Z]+)+[a-zA-Z0-9]*)$/
+        lower = upper = number = true
+      when /^(([^a-zA-Z0-9]|[A-Z0-9])*([^a-zA-Z0-9]+[A-Z]+[0-9]+|[^a-zA-Z0-9]+[0-9]+[A-Z]+|[A-Z]+[^a-zA-Z0-9]+[0-9]+|[A-Z]+[0-9]+[^a-zA-Z0-9]+|[0-9]+[A-Z]+[^a-zA-Z0-9]+|[0-9]+[^a-zA-Z0-9]+[A-Z]+)+([^a-zA-Z0-9]|[A-Z0-9])*)$/
+        upper = number = special = true
+      when /^(([^a-zA-Z0-9]|[a-z0-9])*([^a-zA-Z0-9]+[a-z]+[0-9]+|[^a-zA-Z0-9]+[0-9]+[a-z]+|[a-z]+[^a-zA-Z0-9]+[0-9]+|[a-z]+[0-9]+[^a-zA-Z0-9]+|[0-9]+[a-z]+[^a-zA-Z0-9]+|[0-9]+[^a-zA-Z0-9]+[a-z]+)+([^a-zA-Z0-9]|[a-z0-9])*)$/
+        lower = number = special = true
+      when /^(([^a-zA-Z0-9]|[a-zA-Z])*([^a-zA-Z0-9]+[a-z]+[A-Z]+|[^a-zA-Z0-9]+[A-Z]+[a-z]+|[a-z]+[^a-zA-Z0-9]+[A-Z]+|[a-z]+[A-Z]+[^a-zA-Z0-9]+|[A-Z]+[a-z]+[^a-zA-Z0-9]+|[A-Z]+[^a-zA-Z0-9]+[a-z]+)+([^a-zA-Z0-9]|[a-zA-Z])*)$/
+        lower = upper = special = true
+      else
+        lower = number = special = upper = true unless pass == ""
+      end
+      
+      return {:lower => lower, :upper => upper, :special => special, :number => number}
+    end
+
+    # Add a single password/hash to the database.
+    #
+    # @param mypass
+    #   Password to add.
+    #
+    # @param myhash
+    #   Password hash to add.
+    #
+    # @return DataMapper::Password
+    def self.add_single(mypass, myhash = "")
+      begin
+        return if mypass.to_s.empty?
+        pass = Password.create!(:password => mypass, :pw_hash => myhash)
+        pass.save!
+        pass
+      rescue
+        return
+      end
+    end
+
+  end
+end
+

data/lib/ptj/model/tag.rb

@@ -0,0 +1,19 @@
+module PTJ
+
+  class Tag
+    include DataMapper::Resource
+    include Model::FixtureTable
+
+    # A textual tag name
+    property :tag,          String, :key => true
+
+    # An optional description of the tag.
+    property :description,  Text
+
+    property :created_at,       DateTime, :writer => :private 
+    property :updated_at,       DateTime, :writer => :private 
+
+    has n, :passwords,    :through => Resource
+
+  end
+end

data/lib/ptj/model/tasks.rb

@@ -0,0 +1,38 @@
+require 'sinatra'
+require 'json'
+
+module PTJ
+  class Task 
+    include DataMapper::Resource
+
+    property :id,          Serial
+    property :description, Text, :required => true
+    property :is_done,     Boolean
+
+    def url
+      "/tasks/#{self.id}"
+    end
+    
+    def to_json(*a)
+      { 
+        'guid'        => self.url, 
+        'description' => self.description,
+        'isDone'      => self.is_done 
+      }.to_json(*a)
+    end
+
+    REQUIRED = [:description, :is_done]
+  
+    def self.parse_json(body)
+      json = JSON.parse(body)
+      ret = { :description => json['description'], :is_done => json['isDone'] }
+      return nil if REQUIRED.find { |r| ret[r].nil? }
+ 
+      ret 
+    end
+
+    
+
+  end
+end
+

data/lib/ptj/parser.rb

@@ -0,0 +1 @@
+require 'ptj/parser/fileparser'

data/lib/ptj/parser/fileparser.rb

@@ -0,0 +1,24 @@
+module PTJ
+  module Parser
+    class FileParser
+
+      # Parse a file line-by-line and return the necessary results.
+      #
+      # @param line
+      #   Individual line of the file.
+      #
+      # @return Hash 
+      #   :mypass => value, :myhash => value, :count => value (optional)
+      def parse_line(line)
+        raise(NotImplementedError, "This is an abstract implementation, you must override parse_line")
+      end
+
+    end
+  end
+end
+
+require 'ptj/parser/fileparser/passhashonly'
+require 'ptj/parser/fileparser/passonly'
+require 'ptj/parser/fileparser/hashpassonlycolon'
+require 'ptj/parser/fileparser/countpassonly'
+require 'ptj/parser/fileparser/passthreecolons'

data/lib/ptj/parser/fileparser/countpassonly.rb

@@ -0,0 +1,27 @@
+module PTJ
+  module Parser
+    # FileParser class which allows you to parse a file line by line.
+    #
+    class CountPassOnly < FileParser
+
+      # Expecting the following format:
+      # pass, hash
+      # pass, hash
+      # pass, hash
+      #
+      # @param line
+      #   Individual line from a text file
+      #
+      # @return Hash Password, Password Hash, Count
+      def parse_line(line)
+        if line =~ /^\s*(\d+)\s*(\S+)\s*$/
+          count = $~[1]
+          pass = $~[2]
+          hash = nil
+        end
+        {:mypass => pass, :myhash => hash, :count => count}
+      end
+
+    end
+  end
+end

data/lib/ptj/parser/fileparser/hashpassonlycolon.rb

@@ -0,0 +1,26 @@
+module PTJ
+  module Parser
+    # FileParser class which allows you to parse a file line by line.
+    #
+    class HashPassOnlyColon < FileParser
+
+      # Expecting the following format:
+      # hash:pass
+      # hash:pass
+      # hash:pass
+      #
+      # @param line
+      #   Individual line from a text file
+      #
+      # @return Hash Password, Password Hash
+      def parse_line(line)
+        if line =~ /^(\S+):(\S+)/
+          pass = $~[2]
+          hash = $~[1]
+        end
+        {:mypass => pass, :myhash => hash}
+      end
+
+    end
+  end
+end

data/lib/ptj/parser/fileparser/passhashonly.rb

@@ -0,0 +1,26 @@
+module PTJ
+  module Parser
+    # FileParser class which allows you to parse a file line by line.
+    #
+    class PassHashOnly < FileParser
+
+      # Expecting the following format:
+      # pass, hash
+      # pass, hash
+      # pass, hash
+      #
+      # @param line
+      #   Individual line from a text file
+      #
+      # @return Hash Password, Password Hash
+      def parse_line(line)
+        if line =~ /^(\S+),\s(\S+)/
+          pass = $~[1]
+          hash = $~[2]
+        end
+        {:mypass => pass, :myhash => hash}
+      end
+
+    end
+  end
+end

data/lib/ptj/parser/fileparser/passonly.rb

@@ -0,0 +1,26 @@
+module PTJ
+  module Parser
+    # FileParser class which allows you to parse a file line by line.
+    #
+    class PassOnly < FileParser
+
+      # Expecting the following format:
+      # pass
+      # pass
+      # pass
+      #
+      # @param line
+      #   Individual line from a text file
+      #
+      # @return Hash Password, Password Hash
+      def parse_line(line)
+        if line =~ /^\s*(\S+)\s*$/
+          pass = $~[1]
+          hash = nil
+        end
+        {:mypass => pass, :myhash => hash}
+      end
+
+    end
+  end
+end