wordpress_config_parser 0.9.0 → 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38f90fe48a8714b268601c33bced5f5c6e9b00a4
+  data.tar.gz: 06061cd7e28fad3c370c54b878a790fadeddf822
+SHA512:
+  metadata.gz: a79084d5859d13b9ad4ae2d6692e981ae78e2624da37d3462406071c3a3e73c7d625055eeaf659569e72cec95cf5fa02fc614567f7caafa743ed8b00e2be32f0
+  data.tar.gz: 7c6a9f9e79f98d727954aba1b442dcd40ca23c91eac408f95c87fc4c81086aa8b7fbe3836930aaa018e67c125c04aef4f880245f8a1e953cf528c6c8fe5b93b4

data/README.md

@@ -40,10 +40,37 @@ entire shell account), and pushes them to the origin repo:
 
 ```ruby
 #!/usr/bin/env ruby
-
-require 'wordpress_config_parser'
+#
+# backup-wordpress-db.rb
+#
+# Calls mysqldump to create a backup of a MySQL data base
+# in the form of a .sql file containing the SQL commands
+# required to reconstruct it.
+#
+# Assumptions:
+#
+# 1) The directory containing the output (backup) files is in a git repo.
+#
+# 2) Either you have .ssh keys set up, or you're willing to
+#    type in your password for the git push.
+#
+# 3) You're storing your SQL backup files in ~/sql-backups, and
+#    that directory already exists.
+#
+# 4) The blogs are all under the $HOME/public_html directory.
+#
+# 5) There are no changes git added when you run this script.
+#    Otherwise, those changes will be included in the commit,
+#    without any commit message to describe them.
+
+require 'wordpress_config_reader'
 require 'shellwords'
 
+if ARGV.empty?
+  puts "Syntax is backup-wordpress.rb blog_dir_name_1 [...blog_dir_name_n]."
+  exit -1
+end
+
 
 def run_command(command)
   puts(command)
@@ -53,29 +80,28 @@ end
 
 home = ENV['HOME']
 output_dir = File.join(home, 'sql-backups')
-blognames = %w(blog1 blog2)
-
+blognames = ARGV
 
 blognames.each do |blogname|
 
   blog_dir = File.join(home, 'public_html', blogname)
-  parser = WCParser.new(blog_dir)
-  time_str = Time.now.strftime("%Y_%m_%d__%H%M%S")
-  outfilespec = File.join(output_dir, "#{blogname}-db-backup-#{time_str}.sql")
+  reader = WCReader.new(blog_dir)
+  outfilespec = File.join(output_dir, "#{blogname}-db-backup.sql")
 
-  user     = Shellwords.escape(parser.db_user)
-  password = Shellwords.escape(parser.db_password)
-  host     = Shellwords.escape(parser.db_host)
-  name     = Shellwords.escape(parser.db_name)
+  user     = Shellwords.escape(reader.db_user)
+  password = Shellwords.escape(reader.db_password)
+  host     = Shellwords.escape(reader.db_host)
+  name     = Shellwords.escape(reader.db_name)
 
 
-  Dir.chdir(home) do   # in case you have another .git dir where you are
+  Dir.chdir(output_dir) do  # make sure we're in the right repo
     run_command("mysqldump -u#{user} -p#{password} -h#{host} #{name} 2>&1 | tee #{outfilespec}")
     run_command("git add #{outfilespec} 2>&1")
-    run_command("git commit -m \"Added #{outfilespec}.\"")
   end
 end
 
+
+run_command("git commit -m \"Updated SQL backups for blogs: #{blognames.join(', ')}.\"")
 run_command("git push -u origin master")
 ```
 
@@ -97,7 +123,7 @@ value = parser.db_xyz
 ```
 
 You can also call has_key? (with either string or symbol) to see if it's there
-before trying to get it.  This function is very fast, and pulls the value into
+before trying to get it.  This function pulls the value into
 the cache if it wasn't already there, so the subsequent access to get the
 actual value is very fast.
 
@@ -123,9 +149,6 @@ Or install it yourself as:
 
     $ gem install wordpress_config_parser
 
-## Usage
-
-TODO: Write usage instructions here
 
 ## Contributing
 

data/{sample_scripts/backup-wordpress-db.rb → bin/backup-wordpress-db}

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# backup-wordpress-db.rb
+# backup-wordpress-db
 #
 # Calls mysqldump to create a backup of a MySQL data base
 # in the form of a .sql file containing the SQL commands
@@ -22,7 +22,7 @@
 #    Otherwise, those changes will be included in the commit,
 #    without any commit message to describe them.
 
-require 'wordpress_config_reader'
+require 'wordpress_config_parser'
 require 'shellwords'
 
 if ARGV.empty?
@@ -44,13 +44,13 @@ blognames = ARGV
 blognames.each do |blogname|
 
   blog_dir = File.join(home, 'public_html', blogname)
-  reader = WCReader.new(blog_dir)
+  parser = WordpressConfigParser::Parser.new(blog_dir)
   outfilespec = File.join(output_dir, "#{blogname}-db-backup.sql")
 
-  user     = Shellwords.escape(reader.db_user)
-  password = Shellwords.escape(reader.db_password)
-  host     = Shellwords.escape(reader.db_host)
-  name     = Shellwords.escape(reader.db_name)
+  user     = Shellwords.escape(parser.db_user)
+  password = Shellwords.escape(parser.db_password)
+  host     = Shellwords.escape(parser.db_host)
+  name     = Shellwords.escape(parser.db_name)
 
 
   Dir.chdir(output_dir) do  # make sure we're in the right repo

data/lib/wordpress_config_parser.rb

@@ -1,9 +1,4 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'wordpress_config_parser'))
 
 require "wordpress_config_parser/version"
-
-
-module WordpressConfigParser
-
-  require 'wc_parser'
-end
+require "wordpress_config_parser/parser"

data/lib/wordpress_config_parser/parser.rb

@@ -0,0 +1,82 @@
+module WordpressConfigParser
+class Parser
+
+  attr_accessor :lines
+
+
+  def initialize(filespec_or_array)
+
+    @cache = {}
+
+    error_message = "WCParser constructor must be passed an array of lines, " +
+        "a config filespec, or a directory name that contains a wp-config.php file."
+
+    @lines = case filespec_or_array
+
+      when Array
+        filespec_or_array
+
+      when String  # can be the config filespec or its directory
+        filespec = filespec_or_array
+
+        if File.directory?(filespec)
+          filespec = File.join(filespec, 'wp-config.php')
+        end
+
+        unless File.file?(filespec)
+          raise ArgumentError.new("File '#{filespec}' does not exist.  #{error_message}")
+        end
+
+        File.readlines(filespec).map(&:chomp)
+
+      else  # error: neither array nor string
+        raise ArgumentError.new(error_message)
+    end
+  end
+
+
+  def get(token)
+
+    hash_key = token.to_s.downcase.to_sym
+
+    @cache[hash_key] ||= begin
+      config_file_key = token.to_s.upcase
+      line = find_def_line(config_file_key)
+      line.nil? ? nil : extract_value_from_line(line)   # Note: cache will contain any invalid keys requested
+    end
+  end
+
+
+  def has_key?(key)
+    !! get(key)
+  end
+
+
+  alias [] get
+
+  # For missing methods, assume the method_name is the name or symbol
+  # of a defined value's key.  The key is looked up, and if it exists,
+  # its corresponding value is returned; otherwise, super's
+  # method_missing is called.
+  def method_missing(method_name, *method_args)
+    get(method_name) || super.method_missing(method_name, *method_args)
+  end
+
+
+  # Gets *last* matching def line's value, or nil if not found.
+  def find_def_line(token)
+    search_string = "define('#{token}'"
+    lines.reverse.detect { |line| line.start_with?(search_string) }
+  end
+
+
+  def extract_value_from_line(line)
+    # Ex: define('DB_NAME', 'abcdefgh_0001');
+    # Splitting by ' will leave value as array[3]
+    line.split("'")[3]
+  end
+
+  private :find_def_line, :extract_value_from_line
+
+end
+end

data/lib/wordpress_config_parser/version.rb

@@ -1,3 +1,3 @@
 module WordpressConfigParser
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

data/spec/wordpress_config_parser/parser_spec.rb

@@ -0,0 +1,86 @@
+require_relative '../spec_helper'
+require 'wordpress_config_parser'
+require 'tempfile'
+
+module WordpressConfigParser
+
+describe Parser do
+
+
+  let(:sample_lines) { %w(abc 789) }
+  let(:sample_dirspec) { File.expand_path(File.join(File.dirname(__FILE__), '..', 'resources')) }
+  let(:sample_filespec) { File.join(sample_dirspec, 'wp-config.php') }
+  let(:sample_parser) { Parser.new(sample_filespec) }
+
+  it "should initialize correctly when creating with an array of lines" do
+    parser = Parser.new(sample_lines)
+    expect(parser.lines).to eq(sample_lines)
+  end
+
+  it "parser.lines should be an array when instantiating with a filespec" do
+    expect(sample_parser.lines).to be_an(Array)
+  end
+
+  specify "parser.lines should equal the initial array when instantiating with a filespec" do
+    parser = Parser.new(sample_filespec)
+    expect(parser.lines).to eq(File.readlines(sample_filespec).map(&:chomp))
+  end
+
+  it "should correctly extract the value from a config line" do
+    config_line = "define('DB_NAME', 'abcdefgh_0001');"
+    expect(sample_parser.send(:extract_value_from_line, config_line)).to eq('abcdefgh_0001')
+  end
+
+  it "should extract the correct (i.e., the last) matching line when > 1 matches are present" do
+    line = sample_parser.send(:find_def_line, 'DB_NAME')
+    value = sample_parser.send(:extract_value_from_line, line)
+    expect(value).to eq('mysite_wrd2')
+  end
+
+  specify "get should get the correct value" do
+    expect(sample_parser.get('DB_NAME')).to eq('mysite_wrd2')
+  end
+
+  it "[] operator should get the correct value" do
+    expect(sample_parser['DB_NAME']).to eq('mysite_wrd2')
+  end
+
+  it "should correctly generate a new method when receiving a property in lower case" do
+    expect(sample_parser.db_name).to eq('mysite_wrd2')
+  end
+
+  it "should correctly create a mysqladmin dump command with parameters from the file" do
+    db_name     = sample_parser.db_name
+    db_password = sample_parser.db_password
+    db_hostname = sample_parser.db_host
+    db_user     = sample_parser.db_user
+
+    # mysqldump -u#{userid} -p#{password} -h#{hostname} #{database_name} 2>&1 > #{outfilespec}`
+    command = "mysqldump -u#{db_user} -p#{db_password} -h#{db_hostname} #{db_name}"
+    expected = "mysqldump -umysite_user -pgobbledygook -hlocalhost mysite_wrd2"
+    expect(command).to eq(expected)
+  end
+
+  it "should correctly return true for has_key?(:db_name) and has_key?('DB_NAME')" do
+    expect(sample_parser.has_key?(:db_name) && sample_parser.has_key?('DB_NAME')).to eq(true)
+  end
+
+  it "should correctly return false for has_key?(:zyx) and has_key?('ZYX')" do
+    expect(sample_parser.has_key?(:zyx) || sample_parser.has_key?('ZYX')).to eq(false)
+  end
+
+  it "should throw an ArgumentError if a bad file is provided" do
+    expect{ Parser.new('/:!@#$%^&') }.to raise_error(ArgumentError)
+  end
+
+  it "should throw an ArgumentError if a something other than a string or array is provided" do
+    expect { Parser.new(123) }.to raise_error(ArgumentError)
+  end
+
+  it "should throw a NoMethodError if a method is called for which there is no key" do
+    expect { sample_parser.foo }.to raise_error(NoMethodError)
+  end
+
+end
+end
+

data/wordpress_config_parser.gemspec

@@ -1,12 +1,13 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/wordpress_config_parser/version', __FILE__)
+require_relative 'lib/wordpress_config_parser/version'
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Keith Bennett"]
   gem.email         = ["keithrbennett@gmail.com"]
   gem.description   = %q{Gets values defined in Wordpress wp-config.php file.}
-  gem.summary       = %q{Gets values defined in Wordpress wp-config.php file.}
+  gem.summary       = gem.description
   gem.homepage      = "https://github.com/keithrbennett/wordpress_config_parser"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -14,4 +15,7 @@ Gem::Specification.new do |gem|
   gem.name          = "wordpress_config_parser"
   gem.require_paths = ["lib"]
   gem.version       = WordpressConfigParser::VERSION
+
+  gem.add_development_dependency "rspec", '~> 3.0'
+
 end

metadata

@@ -1,62 +1,76 @@
 --- !ruby/object:Gem::Specification
 name: wordpress_config_parser
 version: !ruby/object:Gem::Version
-  version: 0.9.0
-  prerelease: 
+  version: 0.11.0
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-21 00:00:00.000000000 Z
-dependencies: []
+date: 2016-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Gets values defined in Wordpress wp-config.php file.
 email:
 - keithrbennett@gmail.com
-executables: []
+executables:
+- backup-wordpress-db
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- bin/backup-wordpress-db
 - lib/wordpress_config_parser.rb
+- lib/wordpress_config_parser/parser.rb
 - lib/wordpress_config_parser/version.rb
-- lib/wordpress_config_parser/wc_parser.rb
 - make-gem.sh
-- sample_scripts/backup-wordpress-db.rb
 - spec/resources/wp-config.php
 - spec/spec_helper.rb
-- spec/wordpress_config_reader/wc_reader_spec.rb
+- spec/wordpress_config_parser/parser_spec.rb
 - wordpress_config_parser.gemspec
 homepage: https://github.com/keithrbennett/wordpress_config_parser
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gets values defined in Wordpress wp-config.php file.
 test_files:
 - spec/resources/wp-config.php
 - spec/spec_helper.rb
-- spec/wordpress_config_reader/wc_reader_spec.rb
+- spec/wordpress_config_parser/parser_spec.rb

data/lib/wordpress_config_parser/wc_parser.rb

@@ -1,95 +0,0 @@
-class WCParser
-
-  attr_accessor :lines
-
-  def initialize(filespec_or_array)
-
-    error_message = "WCParser constructor must be passed an array of lines, " +
-        "a config filespec, or a directory name that contains a wp-config.php file."
-
-    case filespec_or_array
-
-      when Array
-        @lines = filespec_or_array
-
-      when String
-        filespec = filespec_or_array
-        unless File.exists?(filespec)
-          raise ArgumentError.new("File/directory '#{filespec}' does not exist. #{error_message}")
-        end
-
-        if File.directory?(filespec)
-          filespec = File.join(filespec, 'wp-config.php')
-          unless File.exists?(filespec)
-            raise ArgumentError.new("File '#{filespec}' does not exist.  #{error_message}")
-          end
-        end
-
-        @lines = File.readlines(filespec).map(&:chomp)
-
-      else
-        raise ArgumentError.new(error_message)
-    end
-
-    @cache = {}
-  end
-
-  # Ex: define('DB_NAME', 'abcdefgh_0001');
-  def find_def_line(token)
-    search_string = "define('#{token}'"
-    matches = lines.select { |line| line[0...search_string.size] == search_string }
-    matches.empty? ? nil : matches.last  # last one wins
-  end
-
-
-  def extract_value_from_line(line)
-    # Ex: define('DB_NAME', 'abcdefgh_0001');
-    # Splitting by ' will leave value as array[3]
-    line.split("'")[3]
-  end
-
-  def get(token)
-
-    hash_key = token.to_s.downcase.to_sym
-
-    if @cache.has_key?(hash_key)
-      value = @cache[hash_key]
-    else
-      config_file_key = token.to_s.upcase
-      line = find_def_line(config_file_key)
-      value = (line.nil? ? nil : extract_value_from_line(line))
-      @cache[hash_key] = value # Note: cache will contain any invalid keys requested
-    end
-    value
-  end
-
-
-  def has_key?(key)
-    !! get(key)
-  end
-
-
-  alias [] get
-
-  # For missing methods, assume the method_name is the name or symbol
-  # of a defined value's key.  If the key exists in the config file,
-  # a method is created and that value returned.  Otherwise, super's
-  # method_missing will be called.
-  def method_missing(method_name, *method_args)
-
-    value = get(method_name)
-
-    if value.nil?
-      super.method_missing(method_name, *method_args)
-    else
-      instance_eval("""
-          def #{method_name.to_s.downcase}
-            get('#{method_name.to_s.upcase}')
-          end
-      """)
-    end
-
-    value
-  end
-
-end

data/spec/wordpress_config_reader/wc_reader_spec.rb

@@ -1,82 +0,0 @@
-require_relative '../spec_helper'
-require 'wc_parser'
-require 'tempfile'
-
-describe WCParser do
-
-
-  let(:sample_lines) { %w(abc 789) }
-  let(:sample_dirspec) { File.expand_path(File.join(File.dirname(__FILE__), '..', 'resources')) }
-  let(:sample_filespec) { File.join(sample_dirspec, 'wp-config.php') }
-  let(:sample_parser) { WCParser.new(sample_filespec) }
-
-  it "should initialize correctly when calling create_with_lines" do
-    parser = WCParser.new(sample_lines)
-    parser.lines.should == sample_lines
-  end
-
-  it "parser.lines should be an array when instantiating with a filespec" do
-    sample_parser.lines.should be_a Array
-  end
-
-  it "parser.lines should equal the initial array when calling create_with_filespec" do
-    parser = WCParser.new(sample_filespec)
-    parser.lines.should == File.readlines(sample_filespec).map(&:chomp)
-  end
-
-  it "should correctly extract the value from a config line" do
-    config_line = "define('DB_NAME', 'abcdefgh_0001');"
-    sample_parser.extract_value_from_line(config_line).should == 'abcdefgh_0001'
-  end
-
-  it "should extract the correct line when > 1 matches are present" do
-    line = sample_parser.find_def_line('DB_NAME')
-    value = sample_parser.extract_value_from_line(line)
-    value.should == 'mysite_wrd2'
-  end
-
-  it "(get) should get the correct value" do
-    sample_parser.get('DB_NAME').should == 'mysite_wrd2'
-  end
-
-  it "[] operator should get the correct value" do
-    sample_parser['DB_NAME'].should == 'mysite_wrd2'
-  end
-
-  it "should correctly generate a new method when receiving a property in lower case" do
-    sample_parser.db_name.should == 'mysite_wrd2'
-  end
-
-  it "should correctly create a mysqladmin dump command with parameters from the file" do
-    db_name = sample_parser.db_name
-    db_password = sample_parser.db_password
-    db_hostname = sample_parser.db_host
-    db_user = sample_parser.db_user
-
-    # mysqldump -u#{userid} -p#{password} -h#{hostname} #{database_name} 2>&1 > #{outfilespec}`
-    command = "mysqldump -u#{db_user} -p#{db_password} -h#{db_hostname} #{db_name}"
-    expected = "mysqldump -umysite_user -pgobbledygook -hlocalhost mysite_wrd2"
-    command.should == expected
-  end
-
-  it "should correctly return true for has_key?(:db_name) and has_key?('DB_NAME')" do
-    (sample_parser.has_key?(:db_name) && sample_parser.has_key?('DB_NAME')).should be_true
-  end
-
-  it "should correctly return false for has_key?(:zyx) and has_key?('ZYX')" do
-    (sample_parser.has_key?(:zyx) || sample_parser.has_key?('ZYX')).should be_false
-  end
-
-  it "should throw an ArgumentError if a bad file is provided" do
-    lambda { WCParser.new('/:!@#$%^&') }.should raise_error(ArgumentError)
-  end
-
-  it "should throw an ArgumentError if a something other than a string or array is provided" do
-    lambda { WCParser.new(123) }.should raise_error(ArgumentError)
-  end
-
-  it "should throw a NoMethodError if a method is called for which there is no key" do
-    lambda { sample_parser.foo }.should raise_error(NoMethodError)
-  end
-
-end